1

/* $Id$ */

     2

     3

/** @file station_gui.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "debug.h"

     8

#include "functions.h"

     9

#include "strings.h"

    10

#include "table/strings.h"

    11

#include "window.h"

    12

#include "gui.h"

    13

#include "station.h"

    14

#include "gfx.h"

    15

#include "player.h"

    16

#include "economy.h"

    17

#include "town.h"

    18

#include "command.h"

    19

#include "variables.h"

    20

#include "vehicle_gui.h"

    21

#include "date.h"

    22

#include "vehicle.h"

    23

#include "table/sprites.h"

    24

#include "helpers.hpp"

    25

#include "cargotype.h"

    26

    27

enum StationListWidgets {

    28

	STATIONLIST_WIDGET_CLOSEBOX = 0,

    29

	STATIONLIST_WIDGET_LIST = 3,

    30

	STATIONLIST_WIDGET_TRAIN =6,

    31

	STATIONLIST_WIDGET_TRUCK,

    32

	STATIONLIST_WIDGET_BUS,

    33

	STATIONLIST_WIDGET_AIRPLANE,

    34

	STATIONLIST_WIDGET_SHIP,

    35

	STATIONLIST_WIDGET_CARGOSTART = 20,

    36

	STATIONLIST_WIDGET_NOCARGOWAITING = 12,

    37

	STATIONLIST_WIDGET_FACILALL = 14,

    38

	STATIONLIST_WIDGET_CARGOALL,

    39

	STATIONLIST_WIDGET_SORTBY,

    40

	STATIONLIST_WIDGET_SORTCRITERIA,

    41

	STATIONLIST_WIDGET_SORTDROPBTN,

    42

};

    43

    44

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

    45

    46

static StationSortListingTypeFunction StationNameSorter;

    47

static StationSortListingTypeFunction StationTypeSorter;

    48

static StationSortListingTypeFunction StationWaitingSorter;

    49

static StationSortListingTypeFunction StationRatingMaxSorter;

    50

    51

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

    52

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

    53

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

    54

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

    55

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

    56

 * @param x coordinate to draw the box at

    57

 * @param y coordinate to draw the box at

    58

 * @param type Cargo type

    59

 * @param amount Cargo amount

    60

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

    61

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

    62

{

    63

	const CargoSpec *cs = GetCargo(type);

    64

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

    65

    66

	int colour = cs->rating_colour;

    67

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

    68

    69

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

    70

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

    71

    72

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

    73

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

    74

	if (w == 0) {

    75

		uint rest = amount / 5;

    76

		if (rest != 0) {

    77

			w += x;

    78

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

    79

		}

    80

	}

    81

    82

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

    83

    84

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

    85

	y += 8;

    86

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

    87

	rating = minu(rating,  224) / 16;

    88

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

    89

}

    90

    91

const StringID _station_sort_listing[] = {

    92

	STR_SORT_BY_DROPDOWN_NAME,

    93

	STR_SORT_BY_FACILITY,

    94

	STR_SORT_BY_WAITING,

    95

	STR_SORT_BY_RATING_MAX,

    96

	INVALID_STRING_ID

    97

};

    98

    99

static char _bufcache[64];

   100

static const Station* _last_station;

   101

static int _internal_sort_order;

   102

   103

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

   104

{

   105

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

   106

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

   107

	char buf1[64];

   108

	int r;

   109

   110

	SetDParam(0, st1->index);

   111

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

   112

   113

	if (st2 != _last_station) {

   114

		_last_station = st2;

   115

		SetDParam(0, st2->index);

   116

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

   117

	}

   118

   119

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

   120

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

   121

}

   122

   123

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

   124

{

   125

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

   126

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

   127

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

   128

}

   129

   130

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

   131

{

   132

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

   133

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

   134

	int sum1 = 0, sum2 = 0;

   135

   136

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

   137

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

   138

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

   139

	}

   140

   141

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

   142

}

   143

   144

/**

   145

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

   146

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

   147

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

   148

 * @return    The sort order

   149

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

   150

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

   151

 */

   152

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

   153

{

   154

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

   155

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

   156

	byte maxr1 = 0;

   157

	byte maxr2 = 0;

   158

   159

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

   160

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

   161

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

   162

	}

   163

   164

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

   165

}

   166

   167

enum StationListFlags {

   168

	SL_ORDER   = 0x01,

   169

	SL_RESORT  = 0x02,

   170

	SL_REBUILD = 0x04,

   171

};

   172

   173

DECLARE_ENUM_AS_BIT_SET(StationListFlags);

   174

   175

struct plstations_d {

   176

	const Station** sort_list;

   177

	uint16 list_length;

   178

	byte sort_type;

   179

	StationListFlags flags;

   180

	uint16 resort_timer;  //was byte refresh_counter;

   181

};

   182

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(plstations_d));

   183

   184

void RebuildStationLists()

   185

{

   186

	BaseWindow *w = NULL;

   187

   188

	FOR_ALL_WINDOWS(w) {

   189

		if (w->window_class == WC_STATION_LIST) {

   190

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

   191

			w->SetDirty();

   192

		}

   193

	}

   194

}

   195

   196

void ResortStationLists()

   197

{

   198

	BaseWindow *w = NULL;

   199

   200

	FOR_ALL_WINDOWS(w) {

   201

		if (w->window_class == WC_STATION_LIST) {

   202

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

   203

			w->SetDirty();

   204

		}

   205

	}

   206

}

   207

   208

static void BuildStationsList(plstations_d* sl, PlayerID owner, byte facilities, uint32 cargo_filter, bool include_empty)

   209

{

   210

	uint n = 0;

   211

	const Station *st;

   212

   213

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

   214

   215

	/* Create array for sorting */

   216

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

   217

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

   218

   219

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

   220

   221

	FOR_ALL_STATIONS(st) {

   222

		if (st->owner == owner) {

   223

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

   224

				int num_waiting_cargo = 0;

   225

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

   226

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

   227

						num_waiting_cargo++; //count number of waiting cargo

   228

						if (HASBIT(cargo_filter, j)) {

   229

							station_sort[n++] = st;

   230

							break;

   231

						}

   232

					}

   233

				}

   234

				/* stations without waiting cargo */

   235

				if (num_waiting_cargo == 0 && include_empty) {

   236

					station_sort[n++] = st;

   237

				}

   238

			}

   239

		}

   240

	}

   241

   242

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

   243

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

   244

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

   245

	sl->list_length = n;

   246

   247

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

   248

   249

	sl->flags &= ~SL_REBUILD;

   250

	sl->flags |= SL_RESORT;

   251

	free((void*)station_sort);

   252

}

   253

   254

static void SortStationsList(plstations_d *sl)

   255

{

   256

	static StationSortListingTypeFunction* const _station_sorter[] = {

   257

		&StationNameSorter,

   258

		&StationTypeSorter,

   259

		&StationWaitingSorter,

   260

		&StationRatingMaxSorter

   261

	};

   262

   263

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

   264

   265

	_internal_sort_order = sl->flags & SL_ORDER;

   266

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

   267

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

   268

   269

	sl->resort_timer = DAY_TICKS * PERIODIC_RESORT_DAYS;

   270

	sl->flags &= ~SL_RESORT;

   271

}

   272

   273

static const uint32 _cargo_filter_max = ~0;

   274

static uint32 _cargo_filter = _cargo_filter_max;

   275

   276

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

   277

{

   278

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

   279

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

   280

	static Listing station_sort = {0, 0};

   281

	static bool include_empty = true;

   282

   283

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

   284

   285

	switch (e->event) {

   286

		case WE_CREATE: /* set up resort timer */

   287

			if (_cargo_filter == _cargo_filter_max) _cargo_filter = _cargo_mask;

   288

   289

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

   290

				if (HASBIT(facilities, i)) w->LowerWidget(i + STATIONLIST_WIDGET_TRAIN);

   291

			}

   292

   293

			w->SetWidgetLoweredState(STATIONLIST_WIDGET_FACILALL, facilities == (FACIL_TRAIN | FACIL_TRUCK_STOP | FACIL_BUS_STOP | FACIL_AIRPORT | FACIL_DOCK));

   294

			w->SetWidgetLoweredState(STATIONLIST_WIDGET_CARGOALL, _cargo_filter == _cargo_mask && include_empty);

   295

			w->SetWidgetLoweredState(STATIONLIST_WIDGET_NOCARGOWAITING, include_empty);

   296

   297

			sl->sort_list = NULL;

   298

			sl->flags = SL_REBUILD;

   299

			sl->sort_type = station_sort.criteria;

   300

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

   301

			sl->resort_timer = DAY_TICKS * PERIODIC_RESORT_DAYS;

   302

			break;

   303

   304

		case WE_PAINT: {

   305

			BuildStationsList(sl, owner, facilities, _cargo_filter, include_empty);

   306

			SortStationsList(sl);

   307

   308

			SetVScrollCount(w, sl->list_length);

   309

   310

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

   311

			const Player* p = GetPlayer(owner);

   312

			SetDParam(0, p->name_1);

   313

			SetDParam(1, p->name_2);

   314

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

   315

			w->DrawWidgets();

   316

   317

			/* draw sorting criteria string */

   318

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

   319

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

   320

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

   321

   322

			int cg_ofst;

   323

			int x = 89;

   324

			int y = 14;

   325

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

   326

   327

			uint i = 0;

   328

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

   329

				const CargoSpec *cs = GetCargo(c);

   330

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

   331

   332

				cg_ofst = HASBIT(_cargo_filter, c) ? 2 : 1;

   333

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

   334

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

   335

				x += 14;

   336

				i++;

   337

			}

   338

   339

			x += 6;

   340

			cg_ofst = w->IsWidgetLowered(STATIONLIST_WIDGET_NOCARGOWAITING) ? 2 : 1;

   341

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

   342

			x += 14;

   343

			cg_ofst = w->IsWidgetLowered(STATIONLIST_WIDGET_CARGOALL) ? 2 : 1;

   344

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

   345

   346

			cg_ofst = w->IsWidgetLowered(STATIONLIST_WIDGET_FACILALL) ? 2 : 1;

   347

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

   348

   349

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

   350

				DrawString(xb, 40, STR_304A_NONE, 0);

   351

				return;

   352

			}

   353

   354

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

   355

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

   356

   357

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

   358

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

   359

				int x;

   360

   361

				assert(st->xy != 0);

   362

				assert(st->owner == owner);

   363

   364

				SetDParam(0, st->index);

   365

				SetDParam(1, st->facilities);

   366

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

   367

   368

				/* show cargo waiting and station ratings */

   369

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

   370

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

   371

					if (amount != 0) {

   372

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

   373

						x += 20;

   374

					}

   375

				}

   376

				y += 10;

   377

			}

   378

			break;

   379

		}

   380

   381

		case WE_CLICK:

   382

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

   383

				case STATIONLIST_WIDGET_LIST: {

   384

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

   385

   386

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

   387

   388

					id_v += w->vscroll.pos;

   389

   390

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

   391

   392

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

   393

					assert(st->owner == owner);

   394

					ScrollMainWindowToTile(st->xy);

   395

					break;

   396

				}

   397

   398

				case STATIONLIST_WIDGET_TRAIN:

   399

				case STATIONLIST_WIDGET_TRUCK:

   400

				case STATIONLIST_WIDGET_BUS:

   401

				case STATIONLIST_WIDGET_AIRPLANE:

   402

				case STATIONLIST_WIDGET_SHIP:

   403

					if (_ctrl_pressed) {

   404

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

   405

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

   406

					} else {

   407

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

   408

							if (HASBIT(facilities, 0)) w->RaiseWidget(i + STATIONLIST_WIDGET_TRAIN);

   409

						}

   410

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

   411

						w->LowerWidget(e->we.click.widget);

   412

					}

   413

					w->SetWidgetLoweredState(STATIONLIST_WIDGET_FACILALL, facilities == (FACIL_TRAIN | FACIL_TRUCK_STOP | FACIL_BUS_STOP | FACIL_AIRPORT | FACIL_DOCK));

   414

					sl->flags |= SL_REBUILD;

   415

					w->SetDirty();

   416

					break;

   417

   418

				case STATIONLIST_WIDGET_FACILALL:

   419

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

   420

						w->LowerWidget(i + STATIONLIST_WIDGET_TRAIN);

   421

					}

   422

					w->LowerWidget(STATIONLIST_WIDGET_FACILALL);

   423

   424

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

   425

					sl->flags |= SL_REBUILD;

   426

					w->SetDirty();

   427

					break;

   428

   429

				case STATIONLIST_WIDGET_CARGOALL: {

   430

					uint i = 0;

   431

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

   432

						if (!GetCargo(c)->IsValid()) continue;

   433

						w->LowerWidget(i + STATIONLIST_WIDGET_CARGOSTART);

   434

						i++;

   435

					}

   436

					w->LowerWidget(STATIONLIST_WIDGET_NOCARGOWAITING);

   437

					w->LowerWidget(STATIONLIST_WIDGET_CARGOALL);

   438

   439

					_cargo_filter = _cargo_mask;

   440

					include_empty = true;

   441

					sl->flags |= SL_REBUILD;

   442

					w->SetDirty();

   443

					break;

   444

				}

   445

   446

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

   447

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

   448

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

   449

					sl->flags |= SL_RESORT;

   450

					w->flash_timeout = 5;

   451

					w->LowerWidget(STATIONLIST_WIDGET_SORTBY);

   452

					w->SetDirty();

   453

					break;

   454

   455

				case STATIONLIST_WIDGET_SORTCRITERIA:

   456

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

   457

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

   458

					break;

   459

   460

				case STATIONLIST_WIDGET_NOCARGOWAITING:

   461

					if (_ctrl_pressed) {

   462

						include_empty = !include_empty;

   463

						w->ToggleWidgetLoweredState(STATIONLIST_WIDGET_NOCARGOWAITING);

   464

					} else {

   465

						for (uint i = STATIONLIST_WIDGET_CARGOSTART; i < w->widget_count; i++) {

   466

							w->RaiseWidget(i);

   467

						}

   468

   469

						_cargo_filter = 0;

   470

						include_empty = true;

   471

   472

						w->LowerWidget(STATIONLIST_WIDGET_NOCARGOWAITING);

   473

					}

   474

					sl->flags |= SL_REBUILD;

   475

					w->SetWidgetLoweredState(STATIONLIST_WIDGET_CARGOALL, _cargo_filter == _cargo_mask && include_empty);

   476

					w->SetDirty();

   477

					break;

   478

   479

				default:

   480

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

   481

						/* Determine the selected cargo type */

   482

						CargoID c;

   483

						int i = 0;

   484

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

   485

							if (!GetCargo(c)->IsValid()) continue;