1

/* $Id$ */

     2

     3

/** @file station_gui.cpp The GUI for stations. */

     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_base.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_func.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

#include "newgrf_cargo.h"

    28

#include "string_func.h"

    29

    30

#include "table/strings.h"

    31

#include "table/sprites.h"

    32

    33

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

    34

    35

static StationSortListingTypeFunction StationNameSorter;

    36

static StationSortListingTypeFunction StationTypeSorter;

    37

static StationSortListingTypeFunction StationWaitingSorter;

    38

static StationSortListingTypeFunction StationRatingMaxSorter;

    39

    40

bool _station_show_coverage;

    41

    42

/**

    43

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

    44

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

    45

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

    46

 *

    47

 * @param x coordinate to draw the box at

    48

 * @param y coordinate to draw the box at

    49

 * @param type Cargo type

    50

 * @param amount Cargo amount

    51

 * @param rating ratings data for that particular cargo

    52

 *

    53

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

    54

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

    55

 */

    56

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

    57

{

    58

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

    59

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

    60

    61

	const CargoSpec *cs = GetCargo(type);

    62

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

    63

    64

	int colour = cs->rating_colour;

    65

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

    66

    67

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

    68

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

    69

    70

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

    71

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

    72

	if (w == 0) {

    73

		uint rest = amount / 5;

    74

		if (rest != 0) {

    75

			w += x;

    76

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

    77

		}

    78

	}

    79

    80

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

    81

    82

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

    83

	y += 8;

    84

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

    85

	rating = minu(rating, rating_full) / 16;

    86

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

    87

}

    88

    89

const StringID _station_sort_listing[] = {

    90

	STR_SORT_BY_DROPDOWN_NAME,

    91

	STR_SORT_BY_FACILITY,

    92

	STR_SORT_BY_WAITING,

    93

	STR_SORT_BY_RATING_MAX,

    94

	INVALID_STRING_ID

    95

};

    96

    97

static char _bufcache[64];

    98

static const Station *_last_station;

    99

static int _internal_sort_order;

   100

   101

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

   102

{

   103

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

   104

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

   105

	char buf1[64];

   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

	int 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 const uint32 _cargo_filter_max = UINT32_MAX;

   128

static uint32 _cargo_filter = _cargo_filter_max;

   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

	Money sum1 = 0, sum2 = 0;

   135

   136

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

   137

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

   138

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

   139

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

   140

	}

   141

   142

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

   143

}

   144

   145

/**

   146

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

   147

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

   148

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

   149

 * @return    The sort order

   150

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

   151

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

   152

 */

   153

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

   154

{

   155

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

   156

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

   157

	byte maxr1 = 0;

   158

	byte maxr2 = 0;

   159

   160

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

   161

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

   162

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

   163

	}

   164

   165

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

   166

}

   167

   168

typedef GUIList<const Station*> GUIStationList;

   169

   170

/**

   171

 * Rebuild station list if the VL_REBUILD flag is set

   172

 *

   173

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

   174

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

   175

 * @param facilities types of stations of interest

   176

 * @param cargo_filter bitmap of cargo types to include

   177

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

   178

 */

   179

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

   180

{

   181

	uint n = 0;

   182

	const Station *st;

   183

   184

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

   185

   186

	/* Create array for sorting */

   187

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

   188

   189

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

   190

   191

	FOR_ALL_STATIONS(st) {

   192

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

   193

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

   194

				int num_waiting_cargo = 0;

   195

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

   196

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

   197

						num_waiting_cargo++; //count number of waiting cargo

   198

						if (HasBit(cargo_filter, j)) {

   199

							station_sort[n++] = st;

   200

							break;

   201

						}

   202

					}

   203

				}

   204

				/* stations without waiting cargo */

   205

				if (num_waiting_cargo == 0 && include_empty) {

   206

					station_sort[n++] = st;

   207

				}

   208

			}

   209

		}

   210

	}

   211

   212

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

   213

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

   214

	sl->list_length = n;

   215

   216

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

   217

   218

	sl->flags &= ~VL_REBUILD;

   219

	sl->flags |= VL_RESORT;

   220

	free((void*)station_sort);

   221

}

   222

   223

   224

/**

   225

 * Sort station list if the VL_RESORT flag is set

   226

 *

   227

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

   228

 */

   229

static void SortStationsList(GUIStationList *sl)

   230

{

   231

	static StationSortListingTypeFunction *const _station_sorter[] = {

   232

		&StationNameSorter,

   233

		&StationTypeSorter,

   234

		&StationWaitingSorter,

   235

		&StationRatingMaxSorter

   236

	};

   237

   238

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

   239

   240

	_internal_sort_order = sl->flags & VL_DESC;

   241

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

   242

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

   243

   244

	sl->resort_timer = DAY_TICKS * PERIODIC_RESORT_DAYS;

   245

	sl->flags &= ~VL_RESORT;

   246

}

   247

   248

/**

   249

 * The list of stations per player.

   250

 */

   251

struct PlayerStationsWindow : public Window, public GUIStationList

   252

{

   253

	static Listing station_sort;

   254

	static byte facilities;

   255

	static bool include_empty;

   256

   257

	PlayerStationsWindow(const WindowDesc *desc, WindowNumber window_number) : Window(desc, window_number)

   258

	{

   259

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

   260

		this->vscroll.cap = 12;

   261

		this->resize.step_height = 10;

   262

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

   263

   264

		/* Add cargo filter buttons */

   265

		uint num_active = 0;

   266

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

   267

			if (GetCargo(c)->IsValid()) num_active++;

   268

		}

   269

   270

		this->widget_count += num_active;

   271

		this->widget = ReallocT(this->widget, this->widget_count + 1);

   272

		this->widget[this->widget_count].type = WWT_LAST;

   273

   274

		uint i = 0;

   275

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

   276

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

   277

   278

			Widget *wi = &this->widget[SLW_CARGOSTART + i];

   279

			wi->type     = WWT_PANEL;

   280

			wi->display_flags = RESIZE_NONE;

   281

			wi->color    = 14;

   282

			wi->left     = 89 + i * 14;

   283

			wi->right    = wi->left + 13;

   284

			wi->top      = 14;

   285

			wi->bottom   = 24;

   286

			wi->data     = 0;

   287

			wi->tooltips = STR_USE_CTRL_TO_SELECT_MORE;

   288

   289

			if (HasBit(_cargo_filter, c)) this->LowerWidget(SLW_CARGOSTART + i);

   290

			i++;

   291

		}

   292

   293

		this->widget[SLW_NOCARGOWAITING].left += num_active * 14;

   294

		this->widget[SLW_NOCARGOWAITING].right += num_active * 14;

   295

		this->widget[SLW_CARGOALL].left += num_active * 14;

   296

		this->widget[SLW_CARGOALL].right += num_active * 14;

   297

		this->widget[SLW_PAN_RIGHT].left += num_active * 14;

   298

   299

		if (num_active > 15) {

   300

			/* Resize and fix the minimum width, if necessary */

   301

			ResizeWindow(this, (num_active - 15) * 14, 0);

   302

			this->resize.width = this->width;

   303

		}

   304

   305

		if (_cargo_filter == _cargo_filter_max) _cargo_filter = _cargo_mask;

   306

   307

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

   308

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

   309

		}

   310

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

   311

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

   312

		this->SetWidgetLoweredState(SLW_NOCARGOWAITING, include_empty);

   313

   314

		this->sort_list = NULL;

   315

		this->flags = VL_REBUILD;

   316

		this->sort_type = station_sort.criteria;

   317

		if (station_sort.order) this->flags |= VL_DESC;

   318

   319

		/* set up resort timer */

   320

		this->resort_timer = DAY_TICKS * PERIODIC_RESORT_DAYS;

   323

	}

   324

   325

	virtual void OnPaint()

   326

	{

   327

		PlayerID owner = (PlayerID)this->window_number;

   328

   329

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

   330

		SortStationsList(this);

   331

   332

		SetVScrollCount(this, this->list_length);

   333

   334

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

   335

		SetDParam(0, owner);

   336

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

   337

   338

		/* Set text of sort by dropdown */

   339

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

   340

   341

		this->DrawWidgets();

   342

   343

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

   344

		this->DrawSortButtonState(SLW_SORTBY, this->flags & VL_DESC ? SBS_DOWN : SBS_UP);

   345

   346

		int cg_ofst;

   347

		int x = 89;

   348

		int y = 14;

   349

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

   350

   351

		uint i = 0;

   352

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

   353

			const CargoSpec *cs = GetCargo(c);

   354

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

   355

   356

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

   357

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

   358

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

   359

			x += 14;

   360

			i++;

   361

		}

   362

   363

		x += 6;

   364

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

   365

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

   366

		x += 14;

   367

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

   368

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

   369

   370

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

   371

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

   372

   373

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

   374

			DrawString(xb, 40, STR_304A_NONE, TC_FROMSTRING);

   375

			return;

   376

		}

   377

   378

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

   379

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

   380

   381

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

   382

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

   383

			int x;

   384

   385

			assert(st->xy != 0);

   386

   387

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

   388

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

   389

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

   390

   391

			SetDParam(0, st->index);

   392

			SetDParam(1, st->facilities);

   393

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

   394

   395

			/* show cargo waiting and station ratings */

   396

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

   397

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

   398

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

   399

					x += 20;

   400

				}

   401

			}

   402

			y += 10;

   403

		}

   404

	}

   405

   406

	virtual void OnClick(Point pt, int widget)

   407

	{

   408

		switch (widget) {

   409

			case SLW_LIST: {

   410

				uint32 id_v = (pt.y - 41) / 10;

   411

   412

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

   413

   414

				id_v += this->vscroll.pos;

   415

   416

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

   417

   418

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

   419

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

   420

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

   421

   422

				if (_ctrl_pressed) {

   423

					ShowExtraViewPortWindow(st->xy);

   424

				} else {

   425

					ScrollMainWindowToTile(st->xy);

   426

				}

   427

				break;

   428

			}

   429

   430

			case SLW_TRAIN:

   431

			case SLW_TRUCK:

   432

			case SLW_BUS:

   433

			case SLW_AIRPLANE:

   434

			case SLW_SHIP:

   435

				if (_ctrl_pressed) {

   436

					ToggleBit(facilities, widget - SLW_TRAIN);

   437

					this->ToggleWidgetLoweredState(widget);

   438

				} else {

   439

					uint i;

   440

					FOR_EACH_SET_BIT(i, facilities) {

   441

						this->RaiseWidget(i + SLW_TRAIN);

   442

					}

   443

					SetBit(facilities, widget - SLW_TRAIN);

   444

					this->LowerWidget(widget);

   445

				}

   446

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

   447

				this->flags |= VL_REBUILD;

   448

				this->SetDirty();

   449

				break;

   450

   451

			case SLW_FACILALL:

   452

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

   453

					this->LowerWidget(i + SLW_TRAIN);

   454

				}

   455

				this->LowerWidget(SLW_FACILALL);

   456

   457

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

   458

				this->flags |= VL_REBUILD;

   459

				this->SetDirty();

   460

				break;

   461

   462

			case SLW_CARGOALL: {

   463

				uint i = 0;

   464

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

   465

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

   466

					this->LowerWidget(i + SLW_CARGOSTART);

   467

					i++;

   468

				}

   469

				this->LowerWidget(SLW_NOCARGOWAITING);

   470

				this->LowerWidget(SLW_CARGOALL);

   471

   472

				_cargo_filter = _cargo_mask;

   473

				include_empty = true;

   474

				this->flags |= VL_REBUILD;

   475

				this->SetDirty();

   476

				break;

   477

			}

   478

   479

			case SLW_SORTBY: // flip sorting method asc/desc

   480

				this->flags ^= VL_DESC; //DESC-flag

   481

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

   482

				this->flags |= VL_RESORT;

   483

				this->flags4 |= 5 << WF_TIMEOUT_SHL;

   484

				this->LowerWidget(SLW_SORTBY);

   485

				this->SetDirty();

   486

				break;

   487