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"

    27

    28

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

    29

    30

static StationSortListingTypeFunction StationNameSorter;

    31

static StationSortListingTypeFunction StationTypeSorter;

    32

static StationSortListingTypeFunction StationWaitingSorter;

    33

static StationSortListingTypeFunction StationRatingMaxSorter;

    34

    37

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

    38

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

    40

 * @param x coordinate to draw the box at

    41

 * @param y coordinate to draw the box at

    42

 * @param type Cargo type

    43

 * @param amount Cargo amount

    49

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

    50

{

    54

	const CargoSpec *cs = GetCargo(type);

    55

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

    56

    57

	int colour = cs->rating_colour;

    59

    60

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

    61

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

    62

    63

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

    64

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

    65

	if (w == 0) {

    66

		uint rest = amount / 5;

    67

		if (rest != 0) {

    68

			w += x;

    69

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

    70

		}

    71

	}

    72

    73

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

    74

    75

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

    76

	y += 8;

    77

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

    79

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

    80

}

    81

    82

const StringID _station_sort_listing[] = {

    83

	STR_SORT_BY_DROPDOWN_NAME,

    84

	STR_SORT_BY_FACILITY,

    85

	STR_SORT_BY_WAITING,

    86

	STR_SORT_BY_RATING_MAX,

    87

	INVALID_STRING_ID

    88

};

    89

    90

static char _bufcache[64];

    91

static const Station* _last_station;

    92

static int _internal_sort_order;

    93

    94

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

    95

{

    96

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

    97

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

    98

	char buf1[64];

    99

	int r;

   100

   101

	SetDParam(0, st1->index);

   102

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

   103

   104

	if (st2 != _last_station) {

   105

		_last_station = st2;

   106

		SetDParam(0, st2->index);

   107

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

   108

	}

   109

   110

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

   111

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

   112

}

   113

   114

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

   115

{

   116

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

   117

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

   118

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

   119

}

   120

   121

static const uint32 _cargo_filter_max = ~0;

   122

static uint32 _cargo_filter = _cargo_filter_max;

   123

   124

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

   125

{

   126

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

   127

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

   128

	Money sum1 = 0, sum2 = 0;

   129

   130

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

   131

		if (!HasBit(_cargo_filter, j)) continue;

   132

		if (!st1->goods[j].cargo.Empty()) sum1 += GetTransportedGoodsIncome(st1->goods[j].cargo.Count(), 20, 50, j);

   133

		if (!st2->goods[j].cargo.Empty()) sum2 += GetTransportedGoodsIncome(st2->goods[j].cargo.Count(), 20, 50, j);

   134

	}

   135

   136

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

   137

}

   138

   139

/**

   140

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

   141

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

   142

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

   143

 * @return    The sort order

   144

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

   145

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

   146

 */

   147

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

   148

{

   149

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

   150

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

   151

	byte maxr1 = 0;

   152

	byte maxr2 = 0;

   153

   154

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

   155

		if (HasBit(st1->goods[j].acceptance_pickup, GoodsEntry::PICKUP)) maxr1 = max(maxr1, st1->goods[j].rating);

   156

		if (HasBit(st2->goods[j].acceptance_pickup, GoodsEntry::PICKUP)) maxr2 = max(maxr2, st2->goods[j].rating);

   157

	}

   158

   159

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

   160

}

   161

   163

enum StationListFlags {

   167

};

   168

   169

DECLARE_ENUM_AS_BIT_SET(StationListFlags);

   170

   172

struct plstations_d {

   178

};

   179

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(plstations_d));

   180

   184

void RebuildStationLists()

   185

{

   186

	Window* const *wz;

   187

   188

	FOR_ALL_WINDOWS(wz) {

   189

		Window *w = *wz;

   190

		if (w->window_class == WC_STATION_LIST) {

   191

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

   192

			SetWindowDirty(w);

   193

		}

   194

	}

   195

}

   196

   200

void ResortStationLists()

   201

{

   202

	Window* const *wz;

   203

   204

	FOR_ALL_WINDOWS(wz) {

   205

		Window *w = *wz;

   206

		if (w->window_class == WC_STATION_LIST) {

   207

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

   208

			SetWindowDirty(w);

   209

		}

   210

	}

   211

}

   212

   222

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

   223

{

   224

	uint n = 0;

   225

	const Station *st;

   226

   227

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

   228

   229

	/* Create array for sorting */

   230

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

   231

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

   232

   233

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

   234

   235

	FOR_ALL_STATIONS(st) {

   236

		if (st->owner == owner) {

   237

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

   238

				int num_waiting_cargo = 0;

   239

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

   240

					if (!st->goods[j].cargo.Empty()) {

   241

						num_waiting_cargo++; //count number of waiting cargo

   242

						if (HasBit(cargo_filter, j)) {

   243

							station_sort[n++] = st;

   244

							break;

   245

						}

   246

					}

   247

				}

   248

				/* stations without waiting cargo */

   249

				if (num_waiting_cargo == 0 && include_empty) {

   250

					station_sort[n++] = st;

   251

				}

   252

			}

   253

		}

   254

	}

   255

   256

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

   257

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

   258

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

   259

	sl->list_length = n;

   260

   261

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

   262

   263

	sl->flags &= ~SL_REBUILD;

   264

	sl->flags |= SL_RESORT;

   265

	free((void*)station_sort);

   266

}

   267

   274

static void SortStationsList(plstations_d *sl)

   275

{

   276

	static StationSortListingTypeFunction* const _station_sorter[] = {

   277

		&StationNameSorter,

   278

		&StationTypeSorter,

   279

		&StationWaitingSorter,

   280

		&StationRatingMaxSorter

   281

	};

   282

   283

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

   284

   285

	_internal_sort_order = sl->flags & SL_ORDER;

   286

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

   287

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

   288

   289

	sl->resort_timer = DAY_TICKS * PERIODIC_RESORT_DAYS;

   290

	sl->flags &= ~SL_RESORT;

   291

}

   292

   299

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

   300

{

   301

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

   302

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

   303

	static Listing station_sort = {0, 0};

   304

	static bool include_empty = true;

   305

   306

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

   307

   308

	switch (e->event) {

   310

			if (_cargo_filter == _cargo_filter_max) _cargo_filter = _cargo_mask;

   311

   312

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

   314

			}

   318

   319

			sl->sort_list = NULL;

   320

			sl->flags = SL_REBUILD;

   321

			sl->sort_type = station_sort.criteria;

   322

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

   325

			sl->resort_timer = DAY_TICKS * PERIODIC_RESORT_DAYS;

   326

			break;

   327

   328

		case WE_PAINT: {

   329

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

   330

			SortStationsList(sl);

   331

   332

			SetVScrollCount(w, sl->list_length);

   333

   334

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

   335

			SetDParam(0, owner);

   336

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

   337

			DrawWindowWidgets(w);

   338

   339

			/* draw sorting criteria string */

   340

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

   341

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

   342

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

   343

   344

			int cg_ofst;

   345

			int x = 89;

   346

			int y = 14;

   347

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

   348

   349

			uint i = 0;

   350

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

   351

				const CargoSpec *cs = GetCargo(c);

   352

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

   353

   354

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

   355

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

   356

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

   357

				x += 14;

   358

				i++;

   359

			}

   360

   361

			x += 6;

   363

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

   364

			x += 14;

   366

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

   367

   369

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

   370

   371

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

   372

				DrawString(xb, 40, STR_304A_NONE, TC_FROMSTRING);

   373

				return;

   374

			}

   375

   376

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

   377

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

   378

   379

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

   380

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

   381

				int x;

   382

   383

				assert(st->xy != 0);

   384

				assert(st->owner == owner);

   385

   386

				SetDParam(0, st->index);

   387

				SetDParam(1, st->facilities);

   388

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

   389

   390

				/* show cargo waiting and station ratings */

   391

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

   392

					if (!st->goods[j].cargo.Empty()) {

   393

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

   394

						x += 20;

   395

					}

   396

				}

   397

				y += 10;

   398

			}

   399

			break;

   400

		}

   401

   402

		case WE_CLICK:

   403

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

   405

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

   406

   407

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

   408

   409

					id_v += w->vscroll.pos;

   410

   411

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

   412

   413

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

   414

					assert(st->owner == owner);

   415

					ScrollMainWindowToTile(st->xy);

   416

					break;

   417

				}

   418

   424

					if (_ctrl_pressed) {

   426

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

   427

					} else {

   428

						uint i;

   429

						FOR_EACH_SET_BIT(i, facilities) {

   431

						}

   433

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

   434

					}

   436

					sl->flags |= SL_REBUILD;

   437

					SetWindowDirty(w);

   438

					break;

   439

   441

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

   443

					}

   445

   446

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

   447

					sl->flags |= SL_REBUILD;

   448

					SetWindowDirty(w);

   449

					break;

   450

   452

					uint i = 0;

   453

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

   454

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

   456

						i++;

   457

					}

   460

   461

					_cargo_filter = _cargo_mask;

   462

					include_empty = true;

   463

					sl->flags |= SL_REBUILD;

   464

					SetWindowDirty(w);

   465

					break;

   466

				}

   467

   469

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

   470

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

   471

					sl->flags |= SL_RESORT;

   472

					w->flags4 |= 5 << WF_TIMEOUT_SHL;

   474

					SetWindowDirty(w);

   475

					break;

   476

   480

					break;

   481