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

#include "vehicle.h"

    21

    22

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

    23

    24

static StationSortListingTypeFunction StationNameSorter;

    25

static StationSortListingTypeFunction StationTypeSorter;

    26

static StationSortListingTypeFunction StationWaitingSorter;

    27

static StationSortListingTypeFunction StationRatingMaxSorter;

    28

    29

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

    30

{

    31

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

    32

	int color = _rating_colors[type];

    33

	uint w;

    34

    35

	if (acceptance > 575) acceptance = 575;

    36

    37

	acceptance = (acceptance + 7) / 8;

    38

    39

	/* draw cargo */

    40

	w = acceptance / 8;

    41

	if (w != 0) {

    42

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

    43

		x += w;

    44

	}

    45

    46

	w = acceptance % 8;

    47

	if (w != 0) {

    48

		if (w == 7) w--;

    49

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

    50

	}

    51

    52

	x -= acceptance / 8;

    53

    54

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

    55

    56

	/* draw green/red ratings bar */

    57

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

    58

    59

	rating >>= 5;

    60

    61

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

    62

}

    63

    64

const StringID _station_sort_listing[] = {

    65

	STR_SORT_BY_DROPDOWN_NAME,

    66

	STR_SORT_BY_FACILITY,

    67

	STR_SORT_BY_WAITING,

    68

	STR_SORT_BY_RATING_MAX,

    69

	INVALID_STRING_ID

    70

};

    71

    72

static char _bufcache[64];

    73

static const Station* _last_station;

    74

static int _internal_sort_order;

    75

    76

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

    77

{

    78

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

    79

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

    80

	char buf1[64];

    81

	int r;

    82

    83

	SetDParam(0, st1->index);

    84

	GetString(buf1, STR_STATION);

    85

    86

	if (st2 != _last_station) {

    87

		_last_station = st2;

    88

		SetDParam(0, st2->index);

    89

		GetString(_bufcache, STR_STATION);

    90

	}

    91

    92

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

    93

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

    94

}

    95

    96

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

    97

{

    98

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

    99

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

   100

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

   101

}

   102

   103

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

   104

{

   105

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

   106

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

   107

	int sum1 = 0, sum2 = 0;

   108

	int j;

   109

   110

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

   111

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

   112

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

   113

	}

   114

   115

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

   116

}

   117

   118

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

   119

{

   120

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

   121

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

   122

	byte maxr1 = 0;

   123

	byte maxr2 = 0;

   124

	int j;

   125

   126

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

   127

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

   128

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

   129

	}

   130

   131

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

   132

}

   133

   134

typedef enum StationListFlags {

   135

	SL_ORDER   = 0x01,

   136

	SL_RESORT  = 0x02,

   137

	SL_REBUILD = 0x04,

   138

} StationListFlags;

   139

   140

typedef struct plstations_d {

   141

	const Station** sort_list;

   142

	uint16 list_length;

   143

	byte sort_type;

   144

	StationListFlags flags;

   145

	uint16 resort_timer;  //was byte refresh_counter;

   146

} plstations_d;

   147

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(plstations_d));

   148

   149

void RebuildStationLists(void)

   150

{

   151

	Window *w;

   152

   153

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

   154

		if (w->window_class == WC_STATION_LIST) {

   155

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

   156

			SetWindowDirty(w);

   157

		}

   158

	}

   159

}

   160

   161

void ResortStationLists(void)

   162

{

   163

	Window *w;

   164

   165

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

   166

		if (w->window_class == WC_STATION_LIST) {

   167

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

   168

			SetWindowDirty(w);

   169

		}

   170

	}

   171

}

   172

   173

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

   174

{

   175

	uint n = 0;

   176

	uint i, j;

   177

	const Station** station_sort;

   178

	const Station *st;

   179

   180

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

   181

   182

	/* Create array for sorting */

   183

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

   184

	if (station_sort == NULL)

   185

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

   186

   187

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

   188

   189

	FOR_ALL_STATIONS(st) {

   190

		if (st->owner == owner) {

   191

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

   192

				int num_waiting_cargo = 0;

   193

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

   194

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

   195

						num_waiting_cargo++; //count number of waiting cargo

   196

						if (HASBIT(cargo_filter, j)) {

   197

							station_sort[n++] = st;

   198

							break;

   199

						}

   200

					}

   201

				}

   202

				//stations without waiting cargo

   203

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

   204

					station_sort[n++] = st;

   205

				}

   206

			}

   207

		}

   208

	}

   209

   210

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

   211

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

   212

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

   213

	sl->list_length = n;

   214

   215

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

   216

   217

	sl->flags &= ~SL_REBUILD;

   218

	sl->flags |= SL_RESORT;

   219

	free((void*)station_sort);

   220

}

   221

   222

static void SortStationsList(plstations_d *sl)

   223

{

   224

	static StationSortListingTypeFunction* const _station_sorter[] = {

   225

		&StationNameSorter,

   226

		&StationTypeSorter,

   227

		&StationWaitingSorter,

   228

		&StationRatingMaxSorter

   229

	};

   230

   231

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

   232

   233

	_internal_sort_order = sl->flags & SL_ORDER;

   234

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

   235

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

   236

   237

	sl->resort_timer = DAY_TICKS * PERIODIC_RESORT_DAYS;

   238

	sl->flags &= ~SL_RESORT;

   239

}

   240

   241

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

   242

{

   243

	const PlayerID owner = w->window_number;

   244

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

   245

	static uint16 cargo_filter = 0x1FFF;

   246

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

   247

   248

	switch (e->event) {

   249

	case WE_PAINT: {

   250

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

   251

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

   252

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

   253

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

   254

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

   255

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

   256

   257

		BuildStationsList(sl, owner, facilities, cargo_filter);

   258

		SortStationsList(sl);

   259

   260

		SetVScrollCount(w, sl->list_length);

   261

   262

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

   263

		{

   264

			const Player* p = GetPlayer(owner);

   265

			SetDParam(0, p->name_1);

   266

			SetDParam(1, p->name_2);

   267

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

   268

			DrawWindowWidgets(w);

   269

		}

   270

   271

		{

   272

			int max;

   273

			int i;

   274

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

   275

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

   276

   277

			/* draw sorting criteria string */

   278

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

   279

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

   280

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

   281

   282

   283

			x = 90;

   284

			y = 14;

   285

   286

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

   287

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

   288

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

   289

				x += 14;

   290

			}

   291

   292

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

   293

			x += 14;

   294

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

   295

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

   296

   297

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

   298

				DrawString(xb, 40, STR_304A_NONE, 0);

   299

				return;

   300

			}

   301

   302

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

   303

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

   304

   305

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

   306

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

   307

				uint j;

   308

				int x;

   309

   310

				assert(st->xy);

   311

				assert(st->owner == owner);

   312

   313

				SetDParam(0, st->index);

   314

				SetDParam(1, st->facilities);

   315

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

   316

   317

				// show cargo waiting and station ratings

   318

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

   319

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

   320

   321

					if (acc != 0) {

   322

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

   323

						x += 10;

   324

					}

   325

				}

   326

				y += 10;

   327

			}

   328

		}

   329

	} break;

   330

	case WE_CLICK: {

   331

		switch (e->we.click.widget) {

   332

		case 3: {

   333

			const Station* st;

   334

   335

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

   336

   337

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

   338

   339

			id_v += w->vscroll.pos;

   340

   341

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

   342

   343

			st = sl->sort_list[id_v];

   344

			assert(st->owner == owner);

   345

			ScrollMainWindowToTile(st->xy);

   346

			break;

   347

		}

   348

   349

		case 6: /* train */

   350

		case 7: /* truck */

   351

		case 8: /* bus */

   352

		case 9: /* airport */

   353

		case 10: /* dock */

   354

			if (_ctrl_pressed) {

   355

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

   356

			} else {

   357

				facilities = 0;

   358

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

   359

			}

   360

			sl->flags |= SL_REBUILD;

   361

			SetWindowDirty(w);

   362

		break;

   363

		case 26:

   364

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

   365

			sl->flags |= SL_REBUILD;

   366

			SetWindowDirty(w);

   367

			break;

   368

		case 27:

   369

			cargo_filter = 0x1FFF; /* select everything */

   370

			sl->flags |= SL_REBUILD;

   371

			SetWindowDirty(w);

   372

			break;

   373

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

   374

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

   375

			sl->flags |= SL_RESORT;

   376

			SetWindowDirty(w);

   377

		break;

   378

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

   379

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

   380

		break;

   381

		default:

   382

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

   383

				if (_ctrl_pressed) {

   384

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

   385

				} else {

   386

					cargo_filter = 0;

   387

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

   388

				}

   389

				sl->flags |= SL_REBUILD;

   390

				SetWindowDirty(w);

   391

			}

   392

		}

   393

	} break;

   394

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

   395

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

   396

			// value has changed -> resort

   397

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

   398

			sl->flags |= SL_RESORT;

   399

		}

   400

		SetWindowDirty(w);

   401

		break;

   402

   403

	case WE_TICK:

   404

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

   405

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

   406

			sl->resort_timer = DAY_TICKS * PERIODIC_RESORT_DAYS;

   407

			sl->flags |= VL_REBUILD;

   408

			SetWindowDirty(w);

   409

		}

   410

		break;

   411

   412

	case WE_CREATE: /* set up resort timer */

   413

		sl->sort_list = NULL;

   414

		sl->flags = SL_REBUILD;

   415

		sl->sort_type = 0;

   416

		sl->resort_timer = DAY_TICKS * PERIODIC_RESORT_DAYS;

   417

		break;

   418

   419

	case WE_RESIZE:

   420

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

   421

		break;

   422

	}

   423

}

   424

   425

static const Widget _player_stations_widgets[] = {

   426

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

   427

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

   428

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

   429

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

   430

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

   431

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

   432

//Index 6

   433

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

   434

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

   435

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

   436

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

   437

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

   438

//Index 11

   439

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

   440

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

   441

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

   442

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

   443

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

   444

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

   445

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

   446

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

   447

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

   448

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

   449

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

   450

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

   451

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

   452

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

   453

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

   454

   455

//26

   456

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

   457

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

   458

   459

//28

   460

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

   461

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

   462

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

   463

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

   464

{   WIDGETS_END},

   465

};

   466

   467

static const WindowDesc _player_stations_desc = {

   468

	-1, -1, 358, 162,

   469

	WC_STATION_LIST,0,

   470

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

   471

	_player_stations_widgets,

   472

	PlayerStationsWndProc

   473

};

   474

   475

   476

void ShowPlayerStations(PlayerID player)

   477

{

   478

	Window *w;

   479

   480

	w = AllocateWindowDescFront(&_player_stations_desc, player);

   481

	if (w != NULL) {

   482

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

   483

		w->vscroll.cap = 12;

   484

		w->resize.step_height = 10;

   485

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

   486

	}

   487

}

   488

   489

static const Widget _station_view_expanded_widgets[] = {

   490

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