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

#include "table/sprites.h"

    22

#include "helpers.hpp"

    23

#include "cargotype.h"

    24

    25

enum StationListWidgets {

    26

	STATIONLIST_WIDGET_CLOSEBOX = 0,

    27

	STATIONLIST_WIDGET_LIST = 3,

    28

	STATIONLIST_WIDGET_TRAIN =6,

    29

	STATIONLIST_WIDGET_TRUCK,

    30

	STATIONLIST_WIDGET_BUS,

    31

	STATIONLIST_WIDGET_AIRPLANE,

    32

	STATIONLIST_WIDGET_SHIP,

    33

	STATIONLIST_WIDGET_CARGOSTART = 12,

    34

	STATIONLIST_WIDGET_NOCARGOWAITING = 24,

    35

	STATIONLIST_WIDGET_FACILALL = 26,

    36

	STATIONLIST_WIDGET_CARGOALL,

    37

	STATIONLIST_WIDGET_SORTBY,

    38

	STATIONLIST_WIDGET_SORTCRITERIA,

    39

	STATIONLIST_WIDGET_SORTDROPBTN,

    40

};

    41

    42

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

    43

    44

static StationSortListingTypeFunction StationNameSorter;

    45

static StationSortListingTypeFunction StationTypeSorter;

    46

static StationSortListingTypeFunction StationWaitingSorter;

    47

static StationSortListingTypeFunction StationRatingMaxSorter;

    48

    49

/** Draw small boxes of cargo amount and ratings data at the given

    50

 * coordinates. If amount exceeds 576 units, it is shown 'full', same

    51

 * goes for the rating: at above 90% orso (224) it is also 'full'

    52

 * Each cargo-bar is 16 pixels wide and 6 pixels high

    53

 * Each rating 14 pixels wide and 1 pixel high and is 1 pixel below the cargo-bar

    54

 * @param x,y X/Y coordinate to draw the box at

    55

 * @param type Cargo type

    56

 * @param amount Cargo amount

    57

 * @param rating ratings data for that particular cargo */

    58

static void StationsWndShowStationRating(int x, int y, CargoID type, uint amount, byte rating)

    59

{

    60

	const CargoSpec *cs = GetCargo(type);

    61

	if (!cs->IsValid()) return;

    62

    63

	int colour = cs->rating_colour;

    64

	uint w = (minu(amount, 576) + 5) / 36;

    65

    66

	/* Draw total cargo (limited) on station (fits into 16 pixels) */

    67

	if (w != 0) GfxFillRect(x, y, x + w - 1, y + 6, colour);

    68

    69

	/* Draw a one pixel-wide bar of additional cargo meter, useful

    70

	 * for stations with only a small amount (<=30) */

    71

	if (w == 0) {

    72

		uint rest = amount / 5;

    73

		if (rest != 0) {

    74

			w += x;

    75

			GfxFillRect(w, y + 6 - rest, w, y + 6, colour);

    76

		}

    77

	}

    78

    79

	DrawString(x + 1, y, cs->abbrev, 0x10);

    80

    81

	/* Draw green/red ratings bar (fits into 14 pixels) */

    82

	y += 8;

    83

	GfxFillRect(x + 1, y, x + 14, y, 0xB8);

    84

	rating = minu(rating,  224) / 16;

    85

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

    86

}

    87

    88

const StringID _station_sort_listing[] = {

    89

	STR_SORT_BY_DROPDOWN_NAME,

    90

	STR_SORT_BY_FACILITY,

    91

	STR_SORT_BY_WAITING,

    92

	STR_SORT_BY_RATING_MAX,

    93

	INVALID_STRING_ID

    94

};

    95

    96

static char _bufcache[64];

    97

static const Station* _last_station;

    98

static int _internal_sort_order;

    99

   100

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

   101

{

   102

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

   103

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

   104

	char buf1[64];

   105

	int r;

   106

   107

	SetDParam(0, st1->index);

   108

	GetString(buf1, STR_STATION, lastof(buf1));

   109

   110

	if (st2 != _last_station) {

   111

		_last_station = st2;

   112

		SetDParam(0, st2->index);

   113

		GetString(_bufcache, STR_STATION, lastof(_bufcache));

   114

	}

   115

   116

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

   117

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

   118

}

   119

   120

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

   121

{

   122

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

   123

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

   124

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

   125

}

   126

   127

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

   128

{

   129

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

   130

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

   131

	int sum1 = 0, sum2 = 0;

   132

   133

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

   134

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

   135

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

   136

	}

   137

   138

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

   139

}

   140

   141

/**

   142

 * qsort-compatible version of sorting two stations by maximum rating

   143

 * @param a   First object to be sorted, must be of type (const Station *)

   144

 * @param b   Second object to be sorted, must be of type (const Station *)

   145

 * @return    The sort order

   146

 * @retval >0 a should come before b in the list

   147

 * @retval <0 b should come before a in the list

   148

 */

   149

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

   150

{

   151

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

   152

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

   153

	byte maxr1 = 0;

   154

	byte maxr2 = 0;

   155

   156

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

   157

		if (st1->goods[j].enroute_from != INVALID_STATION) maxr1 = max(maxr1, st1->goods[j].rating);

   158

		if (st2->goods[j].enroute_from != INVALID_STATION) maxr2 = max(maxr2, st2->goods[j].rating);

   159

	}

   160

   161

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

   162

}

   163

   164

enum StationListFlags {

   165

	SL_ORDER   = 0x01,

   166

	SL_RESORT  = 0x02,

   167

	SL_REBUILD = 0x04,

   168

};

   169

   170

DECLARE_ENUM_AS_BIT_SET(StationListFlags);

   171

   172

struct plstations_d {

   173

	const Station** sort_list;

   174

	uint16 list_length;

   175

	byte sort_type;

   176

	StationListFlags flags;

   177

	uint16 resort_timer;  //was byte refresh_counter;

   178

};

   179

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(plstations_d));

   180

   181

void RebuildStationLists()

   182

{

   183

	Window* const *wz;

   184

   185

	FOR_ALL_WINDOWS(wz) {

   186

		Window *w = *wz;

   187

		if (w->window_class == WC_STATION_LIST) {

   188

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

   189

			SetWindowDirty(w);

   190

		}

   191

	}

   192

}

   193

   194

void ResortStationLists()

   195

{

   196

	Window* const *wz;

   197

   198

	FOR_ALL_WINDOWS(wz) {

   199

		Window *w = *wz;

   200

		if (w->window_class == WC_STATION_LIST) {

   201

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

   202

			SetWindowDirty(w);

   203

		}

   204

	}

   205

}

   206

   207

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

   208

{

   209

	uint n = 0;

   210

	const Station *st;

   211

   212

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

   213

   214

	/* Create array for sorting */

   215

	const Station** station_sort = MallocT<const Station*>(GetMaxStationIndex() + 1);

   216

	if (station_sort == NULL) error("Could not allocate memory for the station-sorting-list");

   217

   218

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

   219

   220

	FOR_ALL_STATIONS(st) {

   221

		if (st->owner == owner) {

   222

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

   223

				int num_waiting_cargo = 0;

   224

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

   225

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

   226

						num_waiting_cargo++; //count number of waiting cargo

   227

						if (HASBIT(cargo_filter, j)) {

   228

							station_sort[n++] = st;

   229

							break;

   230

						}

   231

					}

   232

				}

   233

				//stations without waiting cargo

   234

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

   235

					station_sort[n++] = st;

   236

				}

   237

			}

   238

		}

   239

	}

   240

   241

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

   242

	sl->sort_list = MallocT<const Station*>(n);

   243

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

   244

	sl->list_length = n;

   245

   246

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

   247

   248

	sl->flags &= ~SL_REBUILD;

   249

	sl->flags |= SL_RESORT;

   250

	free((void*)station_sort);

   251

}

   252

   253

static void SortStationsList(plstations_d *sl)

   254

{

   255

	static StationSortListingTypeFunction* const _station_sorter[] = {

   256

		&StationNameSorter,

   257

		&StationTypeSorter,

   258

		&StationWaitingSorter,

   259

		&StationRatingMaxSorter

   260

	};

   261

   262

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

   263

   264

	_internal_sort_order = sl->flags & SL_ORDER;

   265

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

   266

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

   267

   268

	sl->resort_timer = DAY_TICKS * PERIODIC_RESORT_DAYS;

   269

	sl->flags &= ~SL_RESORT;

   270

}

   271

   272

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

   273

{

   274

	static const uint16 CARGO_ALL_SELECTED = 0x1FFF;

   275

   276

	const PlayerID owner = (PlayerID)w->window_number;

   277

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

   278

	static uint16 cargo_filter = CARGO_ALL_SELECTED;

   279

	static Listing station_sort = {0, 0};

   280

   281

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

   282

   283

	switch (e->event) {

   284

		case WE_CREATE: /* set up resort timer */

   285

			for (uint i = 0; i < 5; i++) {

   286

				if (HASBIT(facilities, i)) LowerWindowWidget(w, i + STATIONLIST_WIDGET_TRAIN);

   287

			}

   288

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

   289

				if (HASBIT(cargo_filter, i)) LowerWindowWidget(w, i + STATIONLIST_WIDGET_CARGOSTART);

   290

			}

   291

			SetWindowWidgetLoweredState(w, STATIONLIST_WIDGET_FACILALL, facilities == (FACIL_TRAIN | FACIL_TRUCK_STOP | FACIL_BUS_STOP | FACIL_AIRPORT | FACIL_DOCK));

   292

			SetWindowWidgetLoweredState(w, STATIONLIST_WIDGET_CARGOALL, cargo_filter == CARGO_ALL_SELECTED);

   293

			SetWindowWidgetLoweredState(w, STATIONLIST_WIDGET_NOCARGOWAITING, HASBIT(cargo_filter, STATIONLIST_WIDGET_NOCARGOWAITING - NUM_CARGO));

   294

   295

			sl->sort_list = NULL;

   296

			sl->flags = SL_REBUILD;

   297

			sl->sort_type = station_sort.criteria;

   298

			if (station_sort.order) sl->flags |= SL_ORDER;

   299

			sl->resort_timer = DAY_TICKS * PERIODIC_RESORT_DAYS;

   300

			break;

   301

   302

		case WE_PAINT: {

   303

			BuildStationsList(sl, owner, facilities, cargo_filter);

   304

			SortStationsList(sl);

   305

   306

			SetVScrollCount(w, sl->list_length);

   307

   308

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

   309

			const Player* p = GetPlayer(owner);

   310

			SetDParam(0, p->name_1);

   311

			SetDParam(1, p->name_2);

   312

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

   313

			DrawWindowWidgets(w);

   314

   315

			/* draw sorting criteria string */

   316

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

   317

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

   318

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

   319

   320

			int cg_ofst;

   321

			int x = 89;

   322

			int y = 14;

   323

			int xb = 2; // offset from left of widget

   324

   325

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

   326

				const CargoSpec *cs = GetCargo(i);

   327

				if (cs->IsValid()) {

   328

					cg_ofst = IsWindowWidgetLowered(w, i + STATIONLIST_WIDGET_CARGOSTART) ? 2 : 1;

   329

					GfxFillRect(x + cg_ofst, y + cg_ofst, x + cg_ofst + 10 , y + cg_ofst + 7, cs->rating_colour);

   330

					DrawStringCentered(x + 6 + cg_ofst, y + cg_ofst, cs->abbrev, 0x10);

   331

				}

   332

				x += 14;

   333

			}

   334

   335

			x += 6;

   336

			cg_ofst = IsWindowWidgetLowered(w, STATIONLIST_WIDGET_NOCARGOWAITING) ? 2 : 1;

   337

			DrawStringCentered(x + cg_ofst, y + cg_ofst, STR_ABBREV_NONE, 16);

   338

			x += 14;

   339

			cg_ofst = IsWindowWidgetLowered(w, STATIONLIST_WIDGET_CARGOALL) ? 2 : 1;

   340

			DrawStringCentered(x + cg_ofst, y + cg_ofst, STR_ABBREV_ALL, 16);

   341

   342

			cg_ofst = IsWindowWidgetLowered(w, STATIONLIST_WIDGET_FACILALL) ? 2 : 1;

   343

			DrawString(71 + cg_ofst, y + cg_ofst, STR_ABBREV_ALL, 16);

   344

   345

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

   346

				DrawString(xb, 40, STR_304A_NONE, 0);

   347

				return;

   348

			}

   349

   350

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

   351

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

   352

   353

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

   354

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

   355

				int x;

   356

   357

				assert(st->xy != 0);

   358

				assert(st->owner == owner);

   359

   360

				SetDParam(0, st->index);

   361

				SetDParam(1, st->facilities);

   362

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

   363

   364

				// show cargo waiting and station ratings

   365

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

   366

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

   367

					if (amount != 0) {

   368

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

   369

						x += 20;

   370

					}

   371

				}

   372

				y += 10;

   373

			}

   374

			break;

   375

		}

   376

   377

		case WE_CLICK:

   378

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

   379

				case STATIONLIST_WIDGET_LIST: {

   380

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

   381

   382

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

   383

   384

					id_v += w->vscroll.pos;

   385

   386

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

   387

   388

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

   389

					assert(st->owner == owner);

   390

					ScrollMainWindowToTile(st->xy);

   391

					break;

   392

				}

   393

   394

				case STATIONLIST_WIDGET_TRAIN:

   395

				case STATIONLIST_WIDGET_TRUCK:

   396

				case STATIONLIST_WIDGET_BUS:

   397

				case STATIONLIST_WIDGET_AIRPLANE:

   398

				case STATIONLIST_WIDGET_SHIP:

   399

					if (_ctrl_pressed) {

   400

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

   401

						ToggleWidgetLoweredState(w, e->we.click.widget);

   402

					} else {

   403

						for (uint i = 0; facilities != 0; i++, facilities >>= 1) {

   404

							if (HASBIT(facilities, 0)) RaiseWindowWidget(w, i + STATIONLIST_WIDGET_TRAIN);

   405

						}

   406

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

   407

						LowerWindowWidget(w, e->we.click.widget);

   408

					}

   409

					SetWindowWidgetLoweredState(w, STATIONLIST_WIDGET_FACILALL, facilities == (FACIL_TRAIN | FACIL_TRUCK_STOP | FACIL_BUS_STOP | FACIL_AIRPORT | FACIL_DOCK));

   410

					sl->flags |= SL_REBUILD;

   411

					SetWindowDirty(w);

   412

					break;

   413

   414

				case STATIONLIST_WIDGET_FACILALL:

   415

					for (uint i = 0; i < 5; i++) {

   416

						LowerWindowWidget(w, i + STATIONLIST_WIDGET_TRAIN);

   417

					}

   418

					LowerWindowWidget(w, STATIONLIST_WIDGET_FACILALL);

   419

   420

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

   421

					sl->flags |= SL_REBUILD;

   422

					SetWindowDirty(w);

   423

					break;

   424

   425

				case STATIONLIST_WIDGET_CARGOALL:

   426

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

   427

						LowerWindowWidget(w, i + STATIONLIST_WIDGET_CARGOSTART);

   428

					}

   429

					LowerWindowWidget(w, STATIONLIST_WIDGET_NOCARGOWAITING);

   430

					LowerWindowWidget(w, STATIONLIST_WIDGET_CARGOALL);

   431

   432

					cargo_filter = CARGO_ALL_SELECTED;

   433

					sl->flags |= SL_REBUILD;

   434

					SetWindowDirty(w);

   435

					break;

   436

   437

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

   438

					sl->flags ^= SL_ORDER; //DESC-flag

   439

					station_sort.order = GB(sl->flags, 0, 1);

   440

					sl->flags |= SL_RESORT;

   441

					w->flags4 |= 5 << WF_TIMEOUT_SHL;

   442

					LowerWindowWidget(w, STATIONLIST_WIDGET_SORTBY);

   443

					SetWindowDirty(w);

   444

					break;

   445

   446

				case STATIONLIST_WIDGET_SORTCRITERIA:

   447

				case STATIONLIST_WIDGET_SORTDROPBTN: /* select sorting criteria dropdown menu */

   448

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

   449

					break;

   450

   451

				default:

   452

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

   453

						if (_ctrl_pressed) {

   454

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

   455

							ToggleWidgetLoweredState(w, e->we.click.widget);

   456

						} else {

   457

							for (uint i = 0; cargo_filter != 0; i++, cargo_filter >>= 1) {

   458

								if (HASBIT(cargo_filter, 0)) RaiseWindowWidget(w, i + STATIONLIST_WIDGET_CARGOSTART);

   459

							}

   460

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

   461

							LowerWindowWidget(w, e->we.click.widget);

   462

						}

   463

						sl->flags |= SL_REBUILD;

   464

						SetWindowWidgetLoweredState(w, STATIONLIST_WIDGET_CARGOALL, cargo_filter == CARGO_ALL_SELECTED);

   465

						SetWindowDirty(w);

   466

					}

   467

					break;

   468

			}

   469

			break;

   470

   471

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

   472

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

   473

				// value has changed -> resort

   474

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

   475

				station_sort.criteria = sl->sort_type;

   476

				sl->flags |= SL_RESORT;

   477

			}

   478

			SetWindowDirty(w);

   479

			break;

   480

   481

		case WE_TICK:

   482

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

   483

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

   484

				sl->resort_timer = DAY_TICKS * PERIODIC_RESORT_DAYS;

   485

				sl->flags |= SL_REBUILD;

   486

				SetWindowDirty(w);

   487

			}