1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "debug.h"

     6

#include "functions.h"

     7

#include "strings.h"

     8

#include "table/strings.h"

     9

#include "window.h"

    10

#include "gui.h"

    11

#include "station.h"

    12

#include "gfx.h"

    13

#include "player.h"

    14

#include "economy.h"

    15

#include "town.h"

    16

#include "command.h"

    17

#include "variables.h"

    18

#include "vehicle_gui.h"

    19

#include "date.h"

    20

    21

typedef int CDECL StationSortListingTypeFunction(const void*, const void*);

    22

    23

static StationSortListingTypeFunction StationNameSorter;

    24

static StationSortListingTypeFunction StationTypeSorter;

    25

static StationSortListingTypeFunction StationWaitingSorter;

    26

static StationSortListingTypeFunction StationRatingMaxSorter;

    27

    28

static void StationsWndShowStationRating(int x, int y, int type, uint acceptance, int rating)

    29

{

    30

	static const byte _rating_colors[NUM_CARGO] = {152, 32, 15, 174, 208, 194, 191, 55, 184, 10, 191, 48};

    31

	int color = _rating_colors[type];

    32

	uint w;

    33

    34

	if (acceptance > 575) acceptance = 575;

    35

    36

	acceptance = (acceptance + 7) / 8;

    37

    38

	/* draw cargo */

    39

	w = acceptance / 8;

    40

	if (w != 0) {

    41

		GfxFillRect(x, y, x + w - 1, y + 6, color);

    42

		x += w;

    43

	}

    44

    45

	w = acceptance % 8;

    46

	if (w != 0) {

    47

		if (w == 7) w--;

    48

		GfxFillRect(x, y + (w - 1), x, y + 6, color);

    49

	}

    50

    51

	x -= acceptance / 8;

    52

    53

	DrawString(x + 1, y, _cargoc.names_short[type], 0x10);

    54

    55

	/* draw green/red ratings bar */

    56

	GfxFillRect(x + 1, y + 8, x + 7, y + 8, 0xB8);

    57

    58

	rating >>= 5;

    59

    60

	if (rating != 0) GfxFillRect(x + 1, y + 8, x + rating, y + 8, 0xD0);

    61

}

    62

    63

const StringID _station_sort_listing[] = {

    64

	STR_SORT_BY_DROPDOWN_NAME,

    65

	STR_SORT_BY_FACILITY,

    66

	STR_SORT_BY_WAITING,

    67

	STR_SORT_BY_RATING_MAX,

    68

	INVALID_STRING_ID

    69

};

    70

    71

static char _bufcache[64];

    72

static const Station* _last_station;

    73

static int _internal_sort_order;

    74

    75

static int CDECL StationNameSorter(const void *a, const void *b)

    76

{

    77

	const Station* st1 = *(const Station**)a;

    78

	const Station* st2 = *(const Station**)b;

    79

	char buf1[64];

    80

	int r;

    81

    82

	SetDParam(0, st1->index);

    83

	GetString(buf1, STR_STATION);

    84

    85

	if (st2 != _last_station) {

    86

		_last_station = st2;

    87

		SetDParam(0, st2->index);

    88

		GetString(_bufcache, STR_STATION);

    89

	}

    90

    91

	r =  strcmp(buf1, _bufcache); // sort by name

    92

	return (_internal_sort_order & 1) ? -r : r;

    93

}

    94

    95

static int CDECL StationTypeSorter(const void *a, const void *b)

    96

{

    97

	const Station* st1 = *(const Station**)a;

    98

	const Station* st2 = *(const Station**)b;

    99

	return (_internal_sort_order & 1) ? st2->facilities - st1->facilities : st1->facilities - st2->facilities;

   100

}

   101

   102

static int CDECL StationWaitingSorter(const void *a, const void *b)

   103

{

   104

	const Station* st1 = *(const Station**)a;

   105

	const Station* st2 = *(const Station**)b;

   106

	int sum1 = 0, sum2 = 0;

   107

	int j;

   108

   109

	for (j = 0; j < NUM_CARGO; j++) {

   110

		if (st1->goods[j].waiting_acceptance & 0xfff) sum1 += GetTransportedGoodsIncome(st1->goods[j].waiting_acceptance & 0xfff, 20, 50, j);

   111

		if (st2->goods[j].waiting_acceptance & 0xfff) sum2 += GetTransportedGoodsIncome(st2->goods[j].waiting_acceptance & 0xfff, 20, 50, j);

   112

	}

   113

   114

	return (_internal_sort_order & 1) ? sum2 - sum1 : sum1 - sum2;

   115

}

   116

   117

static int CDECL StationRatingMaxSorter(const void *a, const void *b)

   118

{

   119

	const Station* st1 = *(const Station**)a;

   120

	const Station* st2 = *(const Station**)b;

   121

	byte maxr1 = 0;

   122

	byte maxr2 = 0;

   123

	int j;

   124

   125

	for (j = 0; j < NUM_CARGO; j++) {

   126

		if (st1->goods[j].waiting_acceptance & 0xfff) maxr1 = max(maxr1, st1->goods[j].rating);

   127

		if (st2->goods[j].waiting_acceptance & 0xfff) maxr2 = max(maxr2, st2->goods[j].rating);

   128

	}

   129

   130

	return (_internal_sort_order & 1) ? maxr2 - maxr1 : maxr1 - maxr2;

   131

}

   132

   133

typedef enum StationListFlags {

   134

	SL_ORDER   = 0x01,

   135

	SL_RESORT  = 0x02,

   136

	SL_REBUILD = 0x04,

   137

} StationListFlags;

   138

   139

typedef struct plstations_d {

   140

	const Station** sort_list;

   141

	uint16 list_length;

   142

	byte sort_type;

   143

	StationListFlags flags;

   144

	uint16 resort_timer;  //was byte refresh_counter;

   145

} plstations_d;

   146

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(plstations_d));

   147

   148

void RebuildStationLists(void)

   149

{

   150

	Window *w;

   151

   152

	for (w = _windows; w != _last_window; ++w) {

   153

		if (w->window_class == WC_STATION_LIST) {

   154

			WP(w, plstations_d).flags |= SL_REBUILD;

   155

			SetWindowDirty(w);

   156

		}

   157

	}

   158

}

   159

   160

void ResortStationLists(void)

   161

{

   162

	Window *w;

   163

   164

	for (w = _windows; w != _last_window; ++w) {

   165

		if (w->window_class == WC_STATION_LIST) {

   166

			WP(w, plstations_d).flags |= SL_RESORT;

   167

			SetWindowDirty(w);

   168

		}

   169

	}

   170

}

   171

   172

static void BuildStationsList(plstations_d* sl, PlayerID owner, byte facilities, uint16 cargo_filter)

   173

{

   174

	uint n = 0;

   175

	uint i, j;

   176

	const Station** station_sort;

   177

	const Station *st;

   178

   179

	if (!(sl->flags & SL_REBUILD)) return;

   180

   181

	/* Create array for sorting */

   182

	station_sort = malloc(GetStationArraySize() * sizeof(station_sort[0]));

   183

	if (station_sort == NULL)

   184

		error("Could not allocate memory for the station-sorting-list");

   185

   186

	DEBUG(misc, 1) ("Building station list for player %d...", owner);

   187

   188

	FOR_ALL_STATIONS(st) {

   189

		if (st->owner == owner) {

   190

			if (facilities & st->facilities) { //only stations with selected facilities

   191

				int num_waiting_cargo = 0;

   192

				for (j = 0; j < NUM_CARGO; j++) {

   193

					if (st->goods[j].waiting_acceptance & 0xFFF) {

   194

						num_waiting_cargo++; //count number of waiting cargo

   195

						if (HASBIT(cargo_filter, j)) {

   196

							station_sort[n++] = st;

   197

							break;

   198

						}

   199

					}

   200

				}

   201

				//stations without waiting cargo

   202

				if (num_waiting_cargo == 0 && HASBIT(cargo_filter, NUM_CARGO)) {

   203

					station_sort[n++] = st;

   204

				}

   205

			}

   206

		}

   207

	}

   208

   209

	free((void*)sl->sort_list);

   210

	sl->sort_list = malloc(n * sizeof(sl->sort_list[0]));

   211

	if (n != 0 && sl->sort_list == NULL) error("Could not allocate memory for the station-sorting-list");

   212

	sl->list_length = n;

   213

   214

	for (i = 0; i < n; ++i) sl->sort_list[i] = station_sort[i];

   215

   216

	sl->flags &= ~SL_REBUILD;

   217

	sl->flags |= SL_RESORT;

   218

	free((void*)station_sort);

   219

}

   220

   221

static void SortStationsList(plstations_d *sl)

   222

{

   223

	static StationSortListingTypeFunction* const _station_sorter[] = {

   224

		&StationNameSorter,

   225

		&StationTypeSorter,

   226

		&StationWaitingSorter,

   227

		&StationRatingMaxSorter

   228

	};

   229

   230

	if (!(sl->flags & SL_RESORT)) return;

   231

   232

	_internal_sort_order = sl->flags & SL_ORDER;

   233

	_last_station = NULL; // used for "cache" in namesorting

   234

	qsort((void*)sl->sort_list, sl->list_length, sizeof(sl->sort_list[0]), _station_sorter[sl->sort_type]);

   235

   236

	sl->resort_timer = DAY_TICKS * PERIODIC_RESORT_DAYS;

   237

	sl->flags &= ~SL_RESORT;

   238

}

   239

   240

static void PlayerStationsWndProc(Window *w, WindowEvent *e)

   241

{

   242

	const PlayerID owner = w->window_number;

   243

	static byte facilities = FACIL_TRAIN | FACIL_TRUCK_STOP | FACIL_BUS_STOP | FACIL_AIRPORT | FACIL_DOCK;

   244

	static uint16 cargo_filter = 0x1FFF;

   245

	plstations_d *sl = &WP(w, plstations_d);

   246

   247

	switch (e->event) {

   248

	case WE_PAINT: {

   249

		/* Set up cargo click-states. Toggle the all-vehicle and all-cargo types button

   250

		* depending on if all types are clicked or not */

   251

		SB(w->click_state, 6, 5, facilities);

   252

		SB(w->click_state, 26, 1, facilities == (FACIL_TRAIN | FACIL_TRUCK_STOP | FACIL_BUS_STOP | FACIL_AIRPORT | FACIL_DOCK));

   253

		SB(w->click_state, 12, NUM_CARGO + 1, cargo_filter);

   254

		SB(w->click_state, 27, 1, cargo_filter == 0x1FFF);

   255

   256

		BuildStationsList(sl, owner, facilities, cargo_filter);

   257

		SortStationsList(sl);

   258

   259

		SetVScrollCount(w, sl->list_length);

   260

   261

		/* draw widgets, with player's name in the caption */

   262

		{

   263

			const Player* p = GetPlayer(owner);

   264

			SetDParam(0, p->name_1);

   265

			SetDParam(1, p->name_2);

   266

			SetDParam(2, w->vscroll.count);

   267

			DrawWindowWidgets(w);

   268

		}

   269

   270

		{

   271

			int max;

   272

			int i;

   273

			int x = 0, y = 0, xb = 2; // offset from top of widget

   274

			static const byte _cargo_legend_colors[NUM_CARGO] = {152, 32, 15, 174, 208, 194, 191, 84, 184, 10, 202, 215};

   275

   276

			/* draw sorting criteria string */

   277

			DrawString(85, 26, _station_sort_listing[sl->sort_type], 0x10);

   278

			/* draw arrow pointing up/down for ascending/descending sorting */

   279

			DoDrawString(sl->flags & SL_ORDER ? DOWNARROW : UPARROW, 69, 26, 0x10);

   280

   281

   282

			x = 90;

   283

			y = 14;

   284

   285

			for (i = 0; i < NUM_CARGO; i++) {

   286

				GfxFillRect(x + 1, y + 2, x + 11, y + 8, _cargo_legend_colors[i]);

   287

				DrawString(x + 3, y + 2, _cargoc.names_short[i], i == 11 ? 15 : 16);

   288

				x += 14;

   289

			}

   290

   291

			DrawString(x + 2, y + 2, STR_ABBREV_NONE, 16);

   292

			x += 14;

   293

			DrawString(x + 2, y + 2, STR_ABBREV_ALL, 16);

   294

			DrawString(72, y + 2, STR_ABBREV_ALL, 16);

   295

   296

			if (w->vscroll.count == 0) { // player has no stations

   297

				DrawString(xb, 40, STR_304A_NONE, 0);

   298

				return;

   299

			}

   300

   301

			max = min(w->vscroll.pos + w->vscroll.cap, sl->list_length);

   302

			y = 40; // start of the list-widget

   303

   304

			for (i = w->vscroll.pos; i < max; ++i) { // do until max number of stations of owner

   305

				const Station* st = sl->sort_list[i];

   306

				uint j;

   307

				int x;

   308

   309

				assert(st->xy);

   310

				assert(st->owner == owner);

   311

   312

				SetDParam(0, st->index);

   313

				SetDParam(1, st->facilities);

   314

				x = DrawString(xb, y, STR_3049_0, 0) + 5;

   315

   316

				// show cargo waiting and station ratings

   317

				for (j = 0; j != NUM_CARGO; j++) {

   318

					uint acc = GB(st->goods[j].waiting_acceptance, 0, 12);

   319

   320

					if (acc != 0) {

   321

						StationsWndShowStationRating(x, y, j, acc, st->goods[j].rating);

   322

						x += 10;

   323

					}

   324

				}

   325

				y += 10;

   326

			}

   327

		}

   328

	} break;

   329

	case WE_CLICK: {

   330

		switch (e->click.widget) {

   331

		case 3: {

   332

			const Station* st;

   333

   334

			uint32 id_v = (e->click.pt.y - 41) / 10;

   335

   336

			if (id_v >= w->vscroll.cap) return; // click out of bounds

   337

   338

			id_v += w->vscroll.pos;

   339

   340

			if (id_v >= sl->list_length) return; // click out of list bound

   341

   342

			st = sl->sort_list[id_v];

   343

			assert(st->owner == owner);

   344

			ScrollMainWindowToTile(st->xy);

   345

			break;

   346

		}

   347

   348

		case 6: /* train */

   349

		case 7: /* truck */

   350

		case 8: /* bus */

   351

		case 9: /* airport */

   352

		case 10: /* dock */

   353

			if (_ctrl_pressed) {

   354

				TOGGLEBIT(facilities, e->click.widget - 6);

   355

			} else {

   356

				facilities = 0;

   357

				SETBIT(facilities, e->click.widget - 6);

   358

			}

   359

			sl->flags |= SL_REBUILD;

   360

			SetWindowDirty(w);

   361

		break;

   362

		case 26:

   363

			facilities = FACIL_TRAIN | FACIL_TRUCK_STOP | FACIL_BUS_STOP | FACIL_AIRPORT | FACIL_DOCK;

   364

			sl->flags |= SL_REBUILD;

   365

			SetWindowDirty(w);

   366

			break;

   367

		case 27:

   368

			cargo_filter = 0x1FFF; /* select everything */

   369

			sl->flags |= SL_REBUILD;

   370

			SetWindowDirty(w);

   371

			break;

   372

		case 28: /*flip sorting method asc/desc*/

   373

			TOGGLEBIT(sl->flags, 0); //DESC-flag

   374

			sl->flags |= SL_RESORT;

   375

			SetWindowDirty(w);

   376

		break;

   377

		case 29: case 30: /* select sorting criteria dropdown menu */

   378

			ShowDropDownMenu(w, _station_sort_listing, sl->sort_type, 30, 0, 0);

   379

		break;

   380

		default:

   381

			if (e->click.widget >= 12 && e->click.widget <= 24) { //change cargo_filter

   382

				if (_ctrl_pressed) {

   383

					TOGGLEBIT(cargo_filter, e->click.widget - 12);

   384

				} else {

   385

					cargo_filter = 0;

   386

					SETBIT(cargo_filter, e->click.widget - 12);

   387

				}

   388

				sl->flags |= SL_REBUILD;

   389

				SetWindowDirty(w);

   390

			}

   391

		}

   392

	} break;

   393

	case WE_DROPDOWN_SELECT: /* we have selected a dropdown item in the list */

   394

		if (sl->sort_type != e->dropdown.index) {

   395

			// value has changed -> resort

   396

			sl->sort_type = e->dropdown.index;

   397

			sl->flags |= SL_RESORT;

   398

		}

   399

		SetWindowDirty(w);

   400

		break;

   401

   402

	case WE_TICK:

   403

		if (--sl->resort_timer == 0) {

   404

			DEBUG(misc, 1) ("Periodic rebuild station list player %d", owner);

   405

			sl->resort_timer = DAY_TICKS * PERIODIC_RESORT_DAYS;

   406

			sl->flags |= VL_REBUILD;

   407

			SetWindowDirty(w);

   408

		}

   409

		break;

   410

   411

	case WE_CREATE: /* set up resort timer */

   412

		sl->sort_list = NULL;

   413

		sl->flags = SL_REBUILD;

   414

		sl->sort_type = 0;

   415

		sl->resort_timer = DAY_TICKS * PERIODIC_RESORT_DAYS;

   416

		break;

   417

   418

	case WE_RESIZE:

   419

		w->vscroll.cap += e->sizing.diff.y / 10;

   420

		break;

   421

	}

   422

}

   423

   424

static const Widget _player_stations_widgets[] = {

   425

{   WWT_CLOSEBOX,   RESIZE_NONE,    14,     0,    10,     0,    13, STR_00C5,          STR_018B_CLOSE_WINDOW},

   426

{    WWT_CAPTION,  RESIZE_RIGHT,    14,    11,   345,     0,    13, STR_3048_STATIONS, STR_018C_WINDOW_TITLE_DRAG_THIS},

   427

{  WWT_STICKYBOX,     RESIZE_LR,    14,   346,   357,     0,    13, 0x0,               STR_STICKY_BUTTON},

   428

{      WWT_PANEL,     RESIZE_RB,    14,     0,   345,    37,   161, 0x0,               STR_3057_STATION_NAMES_CLICK_ON},

   429

{  WWT_SCROLLBAR,    RESIZE_LRB,    14,   346,   357,    25,   149, 0x0,               STR_0190_SCROLL_BAR_SCROLLS_LIST},

   430

{  WWT_RESIZEBOX,   RESIZE_LRTB,    14,   346,   357,   150,   161, 0x0,               STR_RESIZE_BUTTON},

   431

//Index 6

   432

{    WWT_TEXTBTN,   RESIZE_NONE,    14,     0,    13,    14,    24, STR_TRAIN,         STR_USE_CTRL_TO_SELECT_MORE},

   433

{    WWT_TEXTBTN,   RESIZE_NONE,    14,    14,    27,    14,    24, STR_LORRY,         STR_USE_CTRL_TO_SELECT_MORE},

   434

{    WWT_TEXTBTN,   RESIZE_NONE,    14,    28,    41,    14,    24, STR_BUS,           STR_USE_CTRL_TO_SELECT_MORE},

   435

{    WWT_TEXTBTN,   RESIZE_NONE,    14,    42,    55,    14,    24, STR_PLANE,         STR_USE_CTRL_TO_SELECT_MORE},

   436

{    WWT_TEXTBTN,   RESIZE_NONE,    14,    56,    69,    14,    24, STR_SHIP,          STR_USE_CTRL_TO_SELECT_MORE},

   437

//Index 11

   438

{      WWT_PANEL,   RESIZE_NONE,    14,    83,    88,    14,    24, 0x0,               STR_USE_CTRL_TO_SELECT_MORE},

   439

{      WWT_PANEL,   RESIZE_NONE,    14,    89,   102,    14,    24, 0x0,               STR_USE_CTRL_TO_SELECT_MORE},

   440

{      WWT_PANEL,   RESIZE_NONE,    14,   103,   116,    14,    24, 0x0,               STR_USE_CTRL_TO_SELECT_MORE},

   441

{      WWT_PANEL,   RESIZE_NONE,    14,   117,   130,    14,    24, 0x0,               STR_USE_CTRL_TO_SELECT_MORE},

   442

{      WWT_PANEL,   RESIZE_NONE,    14,   131,   144,    14,    24, 0x0,               STR_USE_CTRL_TO_SELECT_MORE},

   443

{      WWT_PANEL,   RESIZE_NONE,    14,   145,   158,    14,    24, 0x0,               STR_USE_CTRL_TO_SELECT_MORE},

   444

{      WWT_PANEL,   RESIZE_NONE,    14,   159,   172,    14,    24, 0x0,               STR_USE_CTRL_TO_SELECT_MORE},

   445

{      WWT_PANEL,   RESIZE_NONE,    14,   173,   186,    14,    24, 0x0,               STR_USE_CTRL_TO_SELECT_MORE},

   446

{      WWT_PANEL,   RESIZE_NONE,    14,   187,   200,    14,    24, 0x0,               STR_USE_CTRL_TO_SELECT_MORE},

   447

{      WWT_PANEL,   RESIZE_NONE,    14,   201,   214,    14,    24, 0x0,               STR_USE_CTRL_TO_SELECT_MORE},

   448

{      WWT_PANEL,   RESIZE_NONE,    14,   215,   228,    14,    24, 0x0,               STR_USE_CTRL_TO_SELECT_MORE},

   449

{      WWT_PANEL,   RESIZE_NONE,    14,   229,   242,    14,    24, 0x0,               STR_USE_CTRL_TO_SELECT_MORE},

   450

{      WWT_PANEL,   RESIZE_NONE,    14,   243,   256,    14,    24, 0x0,               STR_USE_CTRL_TO_SELECT_MORE},

   451

{      WWT_PANEL,   RESIZE_NONE,    14,   257,   270,    14,    24, 0x0,               STR_NO_WAITING_CARGO},

   452

{      WWT_PANEL,  RESIZE_RIGHT,    14,   285,   357,    14,    24, 0x0,               STR_NULL},

   453

   454

//26

   455

{      WWT_PANEL,   RESIZE_NONE,    14,    70,    83,    14,    24, 0x0,               STR_SELECT_ALL_FACILITIES},

   456

{      WWT_PANEL,   RESIZE_NONE,    14,   271,   284,    14,    24, 0x0,               STR_SELECT_ALL_TYPES},

   457

   458

//28

   459

{ WWT_PUSHTXTBTN,   RESIZE_NONE,    14,     0,    80,    25,    36, STR_SORT_BY,       STR_SORT_ORDER_TIP},

   460

{      WWT_PANEL,   RESIZE_NONE,    14,    81,   232,    25,    36, 0x0,               STR_SORT_CRITERIA_TIP},

   461

{    WWT_TEXTBTN,   RESIZE_NONE,    14,   233,   243,    25,    36, STR_0225,          STR_SORT_CRITERIA_TIP},

   462

{      WWT_PANEL,  RESIZE_RIGHT,    14,   244,   345,    25,    36, 0x0,               STR_NULL},

   463

{   WIDGETS_END},

   464

};

   465

   466

static const WindowDesc _player_stations_desc = {

   467

	-1, -1, 358, 162,

   468

	WC_STATION_LIST,0,

   469

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS | WDF_STICKY_BUTTON | WDF_RESIZABLE,

   470

	_player_stations_widgets,

   471

	PlayerStationsWndProc

   472

};

   473

   474

   475

void ShowPlayerStations(PlayerID player)

   476

{

   477

	Window *w;

   478

   479

	w = AllocateWindowDescFront(&_player_stations_desc, player);

   480

	if (w != NULL) {

   481

		w->caption_color = (byte)w->window_number;

   482

		w->vscroll.cap = 12;

   483

		w->resize.step_height = 10;

   484

		w->resize.height = w->height - 10 * 7; // minimum if 5 in the list

   485

	}

   486

}

   487

   488

static const Widget _station_view_expanded_widgets[] = {

   489

{   WWT_CLOSEBOX,   RESIZE_NONE,    14,     0,    10,     0,    13, STR_00C5,          STR_018B_CLOSE_WINDOW},

   490

{    WWT_CAPTION,   RESIZE_NONE,    14,    11,   236,     0,    13, STR_300A_0,        STR_018C_WINDOW_TITLE_DRAG_THIS},

   491

{  WWT_STICKYBOX,   RESIZE_NONE,    14,   237,   248,     0,    13, 0x0,               STR_STICKY_BUTTON},

   492