1

/* $Id$ */

     2

     3

/** @file station_gui.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "debug.h"

     8

#include "gui.h"

     9

#include "window_gui.h"

    10

#include "textbuf_gui.h"

    11

#include "station.h"

    12

#include "player_func.h"

    13

#include "economy_func.h"

    14

#include "town.h"

    15

#include "command_func.h"

    16

#include "variables.h"

    17

#include "vehicle_gui.h"

    18

#include "cargotype.h"

    19

#include "station_gui.h"

    20

#include "station.h"

    21

#include "strings_func.h"

    22

#include "core/alloc_func.hpp"

    23

#include "window_func.h"

    24

#include "viewport_func.h"

    25

#include "gfx_func.h"

    26

#include "widgets/dropdown_func.h"

    27

    28

#include "table/strings.h"

    29

#include "table/sprites.h"

    30

    31

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

    32

    33

static StationSortListingTypeFunction StationNameSorter;

    34

static StationSortListingTypeFunction StationTypeSorter;

    35

static StationSortListingTypeFunction StationWaitingSorter;

    36

static StationSortListingTypeFunction StationRatingMaxSorter;

    37

    38

bool _station_show_coverage;

    39

    40

/**

    41

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

    42

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

    43

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

    44

 *

    45

 * @param x coordinate to draw the box at

    46

 * @param y coordinate to draw the box at

    47

 * @param type Cargo type

    48

 * @param amount Cargo amount

    49

 * @param rating ratings data for that particular cargo

    50

 *

    51

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

    52

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

    53

 */

    54

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

    55

{

    56

	static const uint units_full  = 576; ///< number of units to show station as 'full'

    57

	static const uint rating_full = 224; ///< rating needed so it is shown as 'full'

    58

    59

	const CargoSpec *cs = GetCargo(type);

    60

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

    61

    62

	int colour = cs->rating_colour;

    63

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

    64

    65

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

    66

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

    67

    68

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

    69

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

    70

	if (w == 0) {

    71

		uint rest = amount / 5;

    72

		if (rest != 0) {

    73

			w += x;

    74

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

    75

		}

    76

	}

    77

    78

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

    79

    80

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

    81

	y += 8;

    82

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

    83

	rating = minu(rating, rating_full) / 16;

    84

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

    85

}

    86

    87

const StringID _station_sort_listing[] = {

    88

	STR_SORT_BY_DROPDOWN_NAME,

    89

	STR_SORT_BY_FACILITY,

    90

	STR_SORT_BY_WAITING,

    91

	STR_SORT_BY_RATING_MAX,

    92

	INVALID_STRING_ID

    93

};

    94

    95

static char _bufcache[64];

    96

static const Station* _last_station;

    97

static int _internal_sort_order;

    98

    99

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

   100

{

   101

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

   102

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

   103

	char buf1[64];

   104

	int r;

   105

   106

	SetDParam(0, st1->index);

   107

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

   108

   109

	if (st2 != _last_station) {

   110

		_last_station = st2;

   111

		SetDParam(0, st2->index);

   112

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

   113

	}

   114

   115

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

   116

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

   117

}

   118

   119

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

   120

{

   121

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

   122

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

   123

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

   124

}

   125

   126

static const uint32 _cargo_filter_max = ~0;

   127

static uint32 _cargo_filter = _cargo_filter_max;

   128

   129

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

   130

{

   131

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

   132

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

   133

	Money sum1 = 0, sum2 = 0;

   134

   135

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

   136

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

   137

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

   138

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

   139

	}

   140

   141

	return (_internal_sort_order & 1) ? ClampToI32(sum2 - sum1) : ClampToI32(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 (HasBit(st1->goods[j].acceptance_pickup, GoodsEntry::PICKUP)) maxr1 = max(maxr1, st1->goods[j].rating);

   161

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

   162

	}

   163

   164

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

   165

}

   166

   167

/** Flags for station list */

   168

enum StationListFlags {

   169

	SL_ORDER   = 1 << 0, ///< Order - ascending (=0), descending (=1)

   170

	SL_RESORT  = 1 << 1, ///< Resort the list

   171

	SL_REBUILD = 1 << 2, ///< Rebuild the list

   172

};

   173

   174

DECLARE_ENUM_AS_BIT_SET(StationListFlags);

   175

   176

/** Information about station list */

   177

struct plstations_d {

   178

	const Station** sort_list; ///< Pointer to list of stations

   179

	uint16 list_length;        ///< Number of stations in list

   180

	uint16 resort_timer;       ///< Tick counter to resort the list

   181

	byte sort_type;            ///< Sort type - name, waiting, ...

   182

	byte flags;                ///< Flags - SL_ORDER, SL_RESORT, SL_REBUILD

   183

};

   184

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(plstations_d));

   185

   186

/**

   187

 * Set the 'SL_REBUILD' flag for all station lists

   188

 */

   189

void RebuildStationLists()

   190

{

   191

	Window* const *wz;

   192

   193

	FOR_ALL_WINDOWS(wz) {

   194

		Window *w = *wz;

   195

		if (w->window_class == WC_STATION_LIST) {

   196

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

   197

			SetWindowDirty(w);

   198

		}

   199

	}

   200

}

   201

   202

/**

   203

 * Set the 'SL_RESORT' flag for all station lists

   204

 */

   205

void ResortStationLists()

   206

{

   207

	Window* const *wz;

   208

   209

	FOR_ALL_WINDOWS(wz) {

   210

		Window *w = *wz;

   211

		if (w->window_class == WC_STATION_LIST) {

   212

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

   213

			SetWindowDirty(w);

   214

		}

   215

	}

   216

}

   217

   218

/**

   219

 * Rebuild station list if the SL_REBUILD flag is set

   220

 *

   221

 * @param sl pointer to plstations_d (station list and flags)

   222

 * @param owner player whose stations are to be in list

   223

 * @param facilities types of stations of interest

   224

 * @param cargo_filter bitmap of cargo types to include

   225

 * @param include_empty whether we should include stations without waiting cargo

   226

 */

   227

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

   228

{

   229

	uint n = 0;

   230

	const Station *st;

   231

   232

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

   233

   234

	/* Create array for sorting */

   235

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

   236

   237

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

   238

   239

	FOR_ALL_STATIONS(st) {

   240

		if (st->owner == owner || (st->owner == OWNER_NONE && !st->IsBuoy() && HasStationInUse(st->index, owner))) {

   241

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

   242

				int num_waiting_cargo = 0;

   243

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

   244

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

   245

						num_waiting_cargo++; //count number of waiting cargo

   246

						if (HasBit(cargo_filter, j)) {

   247

							station_sort[n++] = st;

   248

							break;

   249

						}

   250

					}

   251

				}

   252

				/* stations without waiting cargo */

   253

				if (num_waiting_cargo == 0 && include_empty) {

   254

					station_sort[n++] = st;

   255

				}

   256

			}

   257

		}

   258

	}

   259

   260

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

   261

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

   262

	sl->list_length = n;

   263

   264

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

   265

   266

	sl->flags &= ~SL_REBUILD;

   267

	sl->flags |= SL_RESORT;

   268

	free((void*)station_sort);

   269

}

   270

   271

   272

/**

   273

 * Sort station list if the SL_RESORT flag is set

   274

 *

   275

 * @param sl pointer to plstations_d (station list and flags)

   276

 */

   277

static void SortStationsList(plstations_d *sl)

   278

{

   279

	static StationSortListingTypeFunction* const _station_sorter[] = {

   280

		&StationNameSorter,

   281

		&StationTypeSorter,

   282

		&StationWaitingSorter,

   283

		&StationRatingMaxSorter

   284

	};

   285

   286

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

   287

   288

	_internal_sort_order = sl->flags & SL_ORDER;

   289

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

   290

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

   291

   292

	sl->resort_timer = DAY_TICKS * PERIODIC_RESORT_DAYS;

   293

	sl->flags &= ~SL_RESORT;

   294

}

   295

   296

/**

   297

 * Fuction called when any WindowEvent occurs for PlayerStations window

   298

 *

   299

 * @param w pointer to the PlayerStations window

   300

 * @param e pointer to window event

   301

 */

   302

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

   303

{

   304

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

   305

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

   306

	static Listing station_sort = {0, 0};

   307

	static bool include_empty = true;

   308

   309

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

   310

   311

	switch (e->event) {

   312

		case WE_CREATE:

   313

			if (_cargo_filter == _cargo_filter_max) _cargo_filter = _cargo_mask;

   314

   315

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

   316

				if (HasBit(facilities, i)) w->LowerWidget(i + SLW_TRAIN);

   317

			}

   318

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

   319

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

   320

			w->SetWidgetLoweredState(SLW_NOCARGOWAITING, include_empty);

   321

   322

			sl->sort_list = NULL;

   323

			sl->flags = SL_REBUILD;

   324

			sl->sort_type = station_sort.criteria;

   325

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

   326

   327

			/* set up resort timer */

   328

			sl->resort_timer = DAY_TICKS * PERIODIC_RESORT_DAYS;

   329

			break;

   330

   331

		case WE_PAINT: {

   332

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

   333

			SortStationsList(sl);

   334

   335

			SetVScrollCount(w, sl->list_length);

   336

   337

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

   338

			SetDParam(0, owner);

   339

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

   340

   341

			/* Set text of sort by dropdown */

   342

			w->widget[SLW_SORTDROPBTN].data = _station_sort_listing[sl->sort_type];

   343

   344

			DrawWindowWidgets(w);

   345

   346

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

   347

			DrawSortButtonState(w, SLW_SORTBY, sl->flags & SL_ORDER ? SBS_DOWN : SBS_UP);

   348

   349

			int cg_ofst;

   350

			int x = 89;

   351

			int y = 14;

   352

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

   353

   354

			uint i = 0;

   355

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

   356

				const CargoSpec *cs = GetCargo(c);

   357

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

   358

   359

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

   360

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

   361

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

   362

				x += 14;

   363

				i++;

   364

			}

   365

   366

			x += 6;

   367

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

   368

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

   369

			x += 14;

   370

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

   371

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

   372

   373

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

   374

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

   375

   376

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

   377

				DrawString(xb, 40, STR_304A_NONE, TC_FROMSTRING);

   378

				return;

   379

			}

   380

   381

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

   382

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

   383

   384

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

   385

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

   386

				int x;

   387

   388

				assert(st->xy != 0);

   389

   390

 				/* Do not do the complex check HasStationInUse here, it may be even false

   391

				 * when the order had been removed and the station list hasn't been removed yet */

   392

				assert(st->owner == owner || (st->owner == OWNER_NONE && !st->IsBuoy()));

   393

   394

				SetDParam(0, st->index);

   395

				SetDParam(1, st->facilities);

   396

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

   397

   398

				/* show cargo waiting and station ratings */

   399

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

   400

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

   401

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

   402

						x += 20;

   403

					}

   404

				}

   405

				y += 10;

   406

			}

   407

			break;

   408

		}

   409

   410

		case WE_CLICK:

   411

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

   412

				case SLW_LIST: {

   413

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

   414

   415

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

   416

   417

					id_v += w->vscroll.pos;

   418

   419

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

   420

   421

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

   422

					/* do not check HasStationInUse - it is slow and may be invalid */

   423

					assert(st->owner == owner || (st->owner == OWNER_NONE && !st->IsBuoy()));

   424

					ScrollMainWindowToTile(st->xy);

   425

					break;

   426

				}

   427

   428

				case SLW_TRAIN:

   429

				case SLW_TRUCK:

   430

				case SLW_BUS:

   431

				case SLW_AIRPLANE:

   432

				case SLW_SHIP:

   433

					if (_ctrl_pressed) {

   434

						ToggleBit(facilities, e->we.click.widget - SLW_TRAIN);

   435

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

   436

					} else {

   437

						uint i;

   438

						FOR_EACH_SET_BIT(i, facilities) {

   439

							w->RaiseWidget(i + SLW_TRAIN);

   440

						}

   441

						SetBit(facilities, e->we.click.widget - SLW_TRAIN);

   442

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

   443

					}

   444

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

   445

					sl->flags |= SL_REBUILD;

   446

					SetWindowDirty(w);

   447

					break;

   448

   449

				case SLW_FACILALL:

   450

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

   451

						w->LowerWidget(i + SLW_TRAIN);

   452

					}

   453

					w->LowerWidget(SLW_FACILALL);

   454

   455

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

   456

					sl->flags |= SL_REBUILD;

   457

					SetWindowDirty(w);

   458

					break;

   459

   460

				case SLW_CARGOALL: {

   461

					uint i = 0;

   462

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

   463

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

   464

						w->LowerWidget(i + SLW_CARGOSTART);

   465

						i++;

   466

					}

   467

					w->LowerWidget(SLW_NOCARGOWAITING);

   468

					w->LowerWidget(SLW_CARGOALL);

   469

   470

					_cargo_filter = _cargo_mask;

   471

					include_empty = true;

   472

					sl->flags |= SL_REBUILD;

   473

					SetWindowDirty(w);

   474

					break;

   475

				}

   476

   477

				case SLW_SORTBY: // flip sorting method asc/desc

   478

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

   479

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

   480

					sl->flags |= SL_RESORT;

   481

					w->flags4 |= 5 << WF_TIMEOUT_SHL;