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 "company_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

#include "company_base.h"

    30

#include "sortlist_type.h"

    31

    32

#include "table/strings.h"

    33

#include "table/sprites.h"

    34

    35

bool _station_show_coverage;

    36

    37

/**

    38

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

    39

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

    40

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

    41

 *

    42

 * @param x coordinate to draw the box at

    43

 * @param y coordinate to draw the box at

    44

 * @param type Cargo type

    45

 * @param amount Cargo amount

    46

 * @param rating ratings data for that particular cargo

    47

 *

    48

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

    49

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

    50

 */

    51

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

    52

{

    53

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

    54

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

    55

    56

	const CargoSpec *cs = GetCargo(type);

    57

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

    58

    59

	int colour = cs->rating_colour;

    60

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

    61

    62

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

    63

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

    64

    65

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

    66

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

    67

	if (w == 0) {

    68

		uint rest = amount / 5;

    69

		if (rest != 0) {

    70

			w += x;

    71

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

    72

		}

    73

	}

    74

    75

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

    76

    77

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

    78

	y += 8;

    79

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

    80

	rating = minu(rating, rating_full) / 16;

    81

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

    82

}

    83

    84

typedef GUIList<const Station*> GUIStationList;

    85

    86

/**

    87

 * The list of stations per company.

    88

 */

    89

class CompanyStationsWindow : public Window

    90

{

    91

protected:

    92

	/* Runtime saved values */

    93

	static Listing last_sorting;

    94

	static byte facilities;               // types of stations of interest

    95

	static bool include_empty;            // whether we should include stations without waiting cargo

    96

	static const uint32 cargo_filter_max;

    97

	static uint32 cargo_filter;           // bitmap of cargo types to include

    98

	static const Station *last_station;

    99

   100

	/* Constants for sorting stations */

   101

	static const StringID sorter_names[];

   102

	static GUIStationList::SortFunction *const sorter_funcs[];

   103

   104

	GUIStationList stations;

   105

   106

   107

	/**

   108

	 * (Re)Build station list

   109

	 *

   110

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

   111

	 */

   112

	void BuildStationsList(const Owner owner)

   113

	{

   114

		if (!this->stations.NeedRebuild()) return;

   115

   116

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

   117

   118

		this->stations.Clear();

   119

   120

		const Station *st;

   121

		FOR_ALL_STATIONS(st) {

   122

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

   123

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

   124

					int num_waiting_cargo = 0;

   125

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

   126

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

   127

							num_waiting_cargo++; // count number of waiting cargo

   128

							if (HasBit(this->cargo_filter, j)) {

   129

								*this->stations.Append() = st;

   130

								break;

   131

							}

   132

						}

   133

					}

   134

					/* stations without waiting cargo */

   135

					if (num_waiting_cargo == 0 && this->include_empty) {

   136

						*this->stations.Append() = st;

   137

					}

   138

				}

   139

			}

   140

		}

   141

   142

		this->stations.Compact();

   143

		this->stations.RebuildDone();

   144

	}

   145

   146

	/** Sort stations by their name */

   147

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

   148

	{

   149

		static char buf_cache[64];

   150

		char buf[64];

   151

   152

		SetDParam(0, (*a)->index);

   153

		GetString(buf, STR_STATION, lastof(buf));

   154

   155

		if (*b != last_station) {

   156

			last_station = *b;

   157

			SetDParam(0, (*b)->index);

   158

			GetString(buf_cache, STR_STATION, lastof(buf_cache));

   159

		}

   160

   161

		return strcmp(buf, buf_cache);

   162

	}

   163

   164

	/** Sort stations by their type */

   165

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

   166

	{

   167

		return (*a)->facilities - (*b)->facilities;

   168

	}

   169

   170

	/** Sort stations by their waiting cargo */

   171

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

   172

	{

   173

		Money diff = 0;

   174

   175

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

   176

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

   177

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

   178

			if (!(*b)->goods[j].cargo.Empty()) diff -= GetTransportedGoodsIncome((*b)->goods[j].cargo.Count(), 20, 50, j);

   179

		}

   180

   181

		return ClampToI32(diff);

   182

	}

   183

   184

	/** Sort stations by their rating */

   185

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

   186

	{

   187

		byte maxr1 = 0;

   188

		byte maxr2 = 0;

   189

   190

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

   191

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

   192

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

   193

		}

   194

   195

		return maxr1 - maxr2;

   196

	}

   197

   198

	/** Sort the stations list */

   199

	void SortStationsList()

   200

	{

   201

		if (!this->stations.Sort()) return;

   202

   203

		/* Reset name sorter sort cache */

   204

		this->last_station = NULL;

   205

   206

		/* Set the modified widget dirty */

   207

		this->InvalidateWidget(SLW_LIST);

   208

	}

   209

   210

public:

   211

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

   212

	{

   213

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

   214

		this->vscroll.cap = 12;

   215

		this->resize.step_height = 10;

   216

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

   217

   218

		/* Add cargo filter buttons */

   219

		uint num_active = 0;

   220

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

   221

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

   222

		}

   223

   224

		this->widget_count += num_active;

   225

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

   226

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

   227

   228

		uint i = 0;

   229

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

   230

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

   231

   232

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

   233

			wi->type     = WWT_PANEL;

   234

			wi->display_flags = RESIZE_NONE;

   235

			wi->color    = COLOUR_GREY;

   236

			wi->left     = 89 + i * 14;

   237

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

   238

			wi->top      = 14;

   239

			wi->bottom   = 24;

   240

			wi->data     = 0;

   241

			wi->tooltips = STR_USE_CTRL_TO_SELECT_MORE;

   242

   243

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

   244

			i++;

   245

		}

   246

   247

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

   248

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

   249

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

   250

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

   251

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

   252

   253

		if (num_active > 15) {

   254

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

   255

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

   256

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

   257

		}

   258

   259

		if (this->cargo_filter == this->cargo_filter_max) this->cargo_filter = _cargo_mask;

   260

   261

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

   262

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

   263

		}

   264

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

   265

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

   266

		this->SetWidgetLoweredState(SLW_NOCARGOWAITING, this->include_empty);

   267

   268

		this->stations.SetListing(this->last_sorting);

   269

		this->stations.SetSortFuncs(this->sorter_funcs);

   270

		this->stations.ForceRebuild();

   271

		this->stations.NeedResort();

   272

		this->SortStationsList();

   273

   274

		this->widget[SLW_SORTDROPBTN].data = this->sorter_names[this->stations.SortType()];

   275

   276

		this->FindWindowPlacementAndResize(desc);

   277

	}

   278

   279

	~CompanyStationsWindow()

   280

	{

   281

		this->last_sorting = this->stations.GetListing();

   282

	}

   283

   284

	virtual void OnPaint()

   285

	{

   286

		const Owner owner = (Owner)this->window_number;

   287

   288

		this->BuildStationsList(owner);

   289

		this->SortStationsList();

   290

   291

		SetVScrollCount(this, this->stations.Length());

   292

   293

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

   294

		SetDParam(0, owner);

   295

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

   296

   297

		this->DrawWidgets();

   298

   299

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

   300

		this->DrawSortButtonState(SLW_SORTBY, this->stations.IsDescSortOrder() ? SBS_DOWN : SBS_UP);

   301

   302

		int cg_ofst;

   303

		int x = 89;

   304

		int y = 14;

   305

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

   306

   307

		uint i = 0;

   308

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

   309

			const CargoSpec *cs = GetCargo(c);

   310

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

   311

   312

			cg_ofst = HasBit(this->cargo_filter, c) ? 2 : 1;

   313

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

   314

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

   315

			x += 14;

   316

			i++;

   317

		}

   318

   319

		x += 6;

   320

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

   321

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

   322

		x += 14;

   323

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

   324

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

   325

   326

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

   327

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

   328

   329

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

   330

			DrawString(xb, 40, STR_304A_NONE, TC_FROMSTRING);

   331

			return;

   332

		}

   333

   334

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

   335

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

   336

   337

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

   338

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

   339

			int x;

   340

   341

			assert(st->xy != 0);

   342

   343

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

   344

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

   345

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

   346

   347

			SetDParam(0, st->index);

   348

			SetDParam(1, st->facilities);

   349

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

   350

   351

			/* show cargo waiting and station ratings */

   352

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

   353

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

   354

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

   355

					x += 20;

   356

				}

   357

			}

   358

			y += 10;

   359

		}

   360

	}

   361

   362

	virtual void OnClick(Point pt, int widget)

   363

	{

   364

		switch (widget) {

   365

			case SLW_LIST: {

   366

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

   367

   368

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

   369

   370

				id_v += this->vscroll.pos;

   371

   372

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

   373

   374

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

   375

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

   376

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

   377

   378

				if (_ctrl_pressed) {

   379

					ShowExtraViewPortWindow(st->xy);

   380

				} else {

   381

					ScrollMainWindowToTile(st->xy);

   382

				}

   383

				break;

   384

			}

   385

   386

			case SLW_TRAIN:

   387

			case SLW_TRUCK:

   388

			case SLW_BUS:

   389

			case SLW_AIRPLANE:

   390

			case SLW_SHIP:

   391

				if (_ctrl_pressed) {

   392

					ToggleBit(this->facilities, widget - SLW_TRAIN);

   393

					this->ToggleWidgetLoweredState(widget);

   394

				} else {

   395

					uint i;

   396

					FOR_EACH_SET_BIT(i, this->facilities) {

   397

						this->RaiseWidget(i + SLW_TRAIN);

   398

					}

   399

					SetBit(this->facilities, widget - SLW_TRAIN);

   400

					this->LowerWidget(widget);

   401

				}

   402

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

   403

				this->stations.ForceRebuild();

   404

				this->SetDirty();

   405

				break;

   406

   407

			case SLW_FACILALL:

   408

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

   409

					this->LowerWidget(i + SLW_TRAIN);

   410

				}

   411

				this->LowerWidget(SLW_FACILALL);

   412

   413

				this->facilities = FACIL_TRAIN | FACIL_TRUCK_STOP | FACIL_BUS_STOP | FACIL_AIRPORT | FACIL_DOCK;

   414

				this->stations.ForceRebuild();

   415

				this->SetDirty();

   416

				break;

   417

   418

			case SLW_CARGOALL: {

   419

				uint i = 0;

   420

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

   421

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

   422

					this->LowerWidget(i + SLW_CARGOSTART);

   423

					i++;

   424

				}

   425

				this->LowerWidget(SLW_NOCARGOWAITING);

   426

				this->LowerWidget(SLW_CARGOALL);

   427

   428

				this->cargo_filter = _cargo_mask;

   429

				this->include_empty = true;

   430

				this->stations.ForceRebuild();

   431

				this->SetDirty();

   432

				break;

   433

			}

   434

   435

			case SLW_SORTBY: // flip sorting method asc/desc

   436

				this->stations.ToggleSortOrder();

   437

				this->flags4 |= WF_TIMEOUT_BEGIN;

   438

				this->LowerWidget(SLW_SORTBY);

   439

				this->SetDirty();

   440

				break;

   441

   442

			case SLW_SORTDROPBTN: // select sorting criteria dropdown menu

   443

				ShowDropDownMenu(this, this->sorter_names, this->stations.SortType(), SLW_SORTDROPBTN, 0, 0);

   444

				break;

   445

   446

			case SLW_NOCARGOWAITING:

   447

				if (_ctrl_pressed) {

   448

					this->include_empty = !this->include_empty;

   449

					this->ToggleWidgetLoweredState(SLW_NOCARGOWAITING);

   450

				} else {

   451

					for (uint i = SLW_CARGOSTART; i < this->widget_count; i++) {

   452

						this->RaiseWidget(i);

   453

					}

   454

   455

					this->cargo_filter = 0;

   456

					this->include_empty = true;

   457

   458

					this->LowerWidget(SLW_NOCARGOWAITING);

   459

				}

   460

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

   461

				this->stations.ForceRebuild();

   462

				this->SetDirty();

   463

				break;

   464

   465

			default:

   466

				if (widget >= SLW_CARGOSTART) { // change cargo_filter

   467

					/* Determine the selected cargo type */

   468

					CargoID c;

   469

					int i = 0;

   470

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

   471

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

   472

						if (widget - SLW_CARGOSTART == i) break;

   473

						i++;

   474

					}

   475

   476

					if (_ctrl_pressed) {

   477

						ToggleBit(this->cargo_filter, c);

   478

						this->ToggleWidgetLoweredState(widget);

   479

					} else {

   480

						for (uint i = SLW_CARGOSTART; i < this->widget_count; i++) {

   481

							this->RaiseWidget(i);

   482

						}

   483

						this->RaiseWidget(SLW_NOCARGOWAITING);

   484

   485

						this->cargo_filter = 0;

   486

						this->include_empty = false;