1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "debug.h"

     6

#include "functions.h"

     7

#include "strings.h"

     8

#include "table/strings.h"

     9

#include "window.h"

    10

#include "gui.h"

    11

#include "station.h"

    12

#include "gfx.h"

    13

#include "player.h"

    14

#include "economy.h"

    15

#include "town.h"

    16

#include "command.h"

    17

#include "variables.h"

    18

#include "vehicle_gui.h"

    19

#include "date.h"

    20

#include "vehicle.h"

    21

    22

enum StationListWidgets {

    23

	STATIONLIST_WIDGET_CLOSEBOX = 0,

    24

	STATIONLIST_WIDGET_LIST = 3,

    25

	STATIONLIST_WIDGET_TRAIN =6,

    26

	STATIONLIST_WIDGET_TRUCK,

    27

	STATIONLIST_WIDGET_BUS,

    28

	STATIONLIST_WIDGET_AIRPLANE,

    29

	STATIONLIST_WIDGET_SHIP,

    30

	STATIONLIST_WIDGET_CARGOSTART = 12,

    31

	STATIONLIST_WIDGET_NOCARGOWAITING = 24,

    32

	STATIONLIST_WIDGET_FACILALL = 26,

    33

	STATIONLIST_WIDGET_CARGOALL,

    34

	STATIONLIST_WIDGET_SORTBY,

    35

	STATIONLIST_WIDGET_SORTCRITERIA,

    36

	STATIONLIST_WIDGET_SORTDROPBTN,

    37

	CARGO_ALL_SELECTED = 0x1FFF,

    38

};

    39

    40

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

    41

    42

static StationSortListingTypeFunction StationNameSorter;

    43

static StationSortListingTypeFunction StationTypeSorter;

    44

static StationSortListingTypeFunction StationWaitingSorter;

    45

static StationSortListingTypeFunction StationRatingMaxSorter;

    46

    47

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

    48

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

    49

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

    50

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

    51

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

    52

 * @param x,y X/Y coordinate to draw the box at

    53

 * @param type Cargo type

    54

 * @param amount Cargo amount

    55

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

    56

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

    57

{

    58

	int colour = _cargo_colours[type];

    59

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

    60

    61

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

    62

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

    63

    64

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

    65

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

    66

	if (w == 0) {

    67

		uint rest = amount / 5;

    68

		if (rest != 0) {

    69

			w += x;

    70

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

    71

		}

    72

	}

    73

    74

	DrawString(x + 1, y, _cargoc.names_short[type], 0x10);

    75

    76

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

    77

	y += 8;

    78

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

    79

	rating = minu(rating,  224) / 16;

    80

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

    81

}

    82

    83

const StringID _station_sort_listing[] = {

    84

	STR_SORT_BY_DROPDOWN_NAME,

    85

	STR_SORT_BY_FACILITY,

    86

	STR_SORT_BY_WAITING,

    87

	STR_SORT_BY_RATING_MAX,

    88

	INVALID_STRING_ID

    89

};

    90

    91

static char _bufcache[64];

    92

static const Station* _last_station;

    93

static int _internal_sort_order;

    94

    95

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

    96

{

    97

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

    98

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

    99

	char buf1[64];

   100

	int r;

   101

   102

	SetDParam(0, st1->index);

   103

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

   104

   105

	if (st2 != _last_station) {

   106

		_last_station = st2;

   107

		SetDParam(0, st2->index);

   108

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

   109

	}

   110

   111

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

   112

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

   113

}

   114

   115

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

   116

{

   117

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

   118

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

   119

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

   120

}

   121

   122

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

   123

{

   124

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

   125

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

   126

	int sum1 = 0, sum2 = 0;

   127

	int j;

   128

   129

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

   130

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

   131

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

   132

	}

   133

   134

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

   135

}

   136

   137

/**

   138

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

   139

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

   140

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

   141

 * @return    The sort order

   142

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

   143

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

   144

 */

   145

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

   146

{

   147

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

   148

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

   149

	byte maxr1 = 0;

   150

	byte maxr2 = 0;

   151

	int j;

   152

   153

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

   154

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

   155

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

   156

	}

   157

   158

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

   159

}

   160

   161

typedef enum StationListFlags {

   162

	SL_ORDER   = 0x01,

   163

	SL_RESORT  = 0x02,

   164

	SL_REBUILD = 0x04,

   165

} StationListFlags;

   166

   167

typedef struct plstations_d {

   168

	const Station** sort_list;

   169

	uint16 list_length;

   170

	byte sort_type;

   171

	StationListFlags flags;

   172

	uint16 resort_timer;  //was byte refresh_counter;

   173

} plstations_d;

   174

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(plstations_d));

   175

   176

void RebuildStationLists(void)

   177

{

   178

	Window* const *wz;

   179

   180

	FOR_ALL_WINDOWS(wz) {

   181

		Window *w = *wz;

   182

		if (w->window_class == WC_STATION_LIST) {

   183

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

   184

			SetWindowDirty(w);

   185

		}

   186

	}

   187

}

   188

   189

void ResortStationLists(void)

   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_RESORT;

   197

			SetWindowDirty(w);

   198

		}

   199

	}

   200

}

   201

   202

static void BuildStationsList(plstations_d* sl, PlayerID owner, byte facilities, uint16 cargo_filter)

   203

{

   204

	uint n = 0;

   205

	uint i, j;

   206

	const Station** station_sort;

   207

	const Station *st;

   208

   209

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

   210

   211

	/* Create array for sorting */

   212

	station_sort = malloc((GetMaxStationIndex() + 1) * sizeof(station_sort[0]));

   213

	if (station_sort == NULL)

   214

		error("Could not allocate memory for the station-sorting-list");

   215

   216

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

   217

   218

	FOR_ALL_STATIONS(st) {

   219

		if (st->owner == owner) {

   220

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

   221

				int num_waiting_cargo = 0;

   222

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

   223

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

   224

						num_waiting_cargo++; //count number of waiting cargo

   225

						if (HASBIT(cargo_filter, j)) {

   226

							station_sort[n++] = st;

   227

							break;

   228

						}

   229

					}

   230

				}

   231

				//stations without waiting cargo

   232

				if (num_waiting_cargo == 0 && HASBIT(cargo_filter, NUM_CARGO)) {

   233

					station_sort[n++] = st;

   234

				}

   235

			}

   236

		}

   237

	}

   238

   239

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

   240

	sl->sort_list = malloc(n * sizeof(sl->sort_list[0]));

   241

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

   242

	sl->list_length = n;

   243

   244

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

   245

   246

	sl->flags &= ~SL_REBUILD;

   247

	sl->flags |= SL_RESORT;

   248

	free((void*)station_sort);

   249

}

   250

   251

static void SortStationsList(plstations_d *sl)

   252

{

   253

	static StationSortListingTypeFunction* const _station_sorter[] = {

   254

		&StationNameSorter,

   255

		&StationTypeSorter,

   256

		&StationWaitingSorter,

   257

		&StationRatingMaxSorter

   258

	};

   259

   260

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

   261

   262

	_internal_sort_order = sl->flags & SL_ORDER;

   263

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

   264

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

   265

   266

	sl->resort_timer = DAY_TICKS * PERIODIC_RESORT_DAYS;

   267

	sl->flags &= ~SL_RESORT;

   268

}

   269

   270

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

   271

{

   272

	const PlayerID owner = w->window_number;

   273

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

   274

	static uint16 cargo_filter = CARGO_ALL_SELECTED;

   275

	static Listing station_sort = {0, 0};

   276

   277

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

   278

   279

	switch (e->event) {

   280

	case WE_CREATE: { /* set up resort timer */

   281

		int i;

   282

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

   283

			if (HASBIT(facilities, i)) LowerWindowWidget(w, i + STATIONLIST_WIDGET_TRAIN);

   284

		}

   285

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

   286

			if (HASBIT(cargo_filter, i)) LowerWindowWidget(w, i + STATIONLIST_WIDGET_CARGOSTART);

   287

		}

   288

		SetWindowWidgetLoweredState(w, STATIONLIST_WIDGET_FACILALL, facilities == (FACIL_TRAIN | FACIL_TRUCK_STOP | FACIL_BUS_STOP | FACIL_AIRPORT | FACIL_DOCK));

   289

		SetWindowWidgetLoweredState(w, STATIONLIST_WIDGET_CARGOALL, cargo_filter == CARGO_ALL_SELECTED);

   290

		SetWindowWidgetLoweredState(w, STATIONLIST_WIDGET_NOCARGOWAITING, HASBIT(cargo_filter, STATIONLIST_WIDGET_NOCARGOWAITING - NUM_CARGO));

   291

   292

		sl->sort_list = NULL;

   293

		sl->flags = SL_REBUILD;

   294

		sl->sort_type = station_sort.criteria;

   295

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

   296

		sl->resort_timer = DAY_TICKS * PERIODIC_RESORT_DAYS;

   297

		break;

   298

	}

   299

   300

	case WE_PAINT: {

   301

		BuildStationsList(sl, owner, facilities, cargo_filter);

   302

		SortStationsList(sl);

   303

   304

		SetVScrollCount(w, sl->list_length);

   305

   306

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

   307

		{

   308

			const Player* p = GetPlayer(owner);

   309

			SetDParam(0, p->name_1);

   310

			SetDParam(1, p->name_2);

   311

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

   312

			DrawWindowWidgets(w);

   313

		}

   314

   315

		{

   316

			int max;

   317

			int i, cg_ofst;

   318

			int x = 0, y = 0, xb = 2; // offset from top of widget

   319

   320

			/* draw sorting criteria string */

   321

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

   322

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

   323

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

   324

   325

   326

			x = 89;

   327

			y = 14;

   328

   329

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

   330

				cg_ofst = IsWindowWidgetLowered(w, i + STATIONLIST_WIDGET_CARGOSTART) ? 2 : 1;

   331

   332

				GfxFillRect(x + cg_ofst, y + cg_ofst, x + cg_ofst + 10 , y + cg_ofst + 7, _cargo_colours[i]);

   333

				DrawStringCentered(x + 6 + cg_ofst, y + cg_ofst, _cargoc.names_short[i], 0x10);

   334

				x += 14;

   335

			}

   336

   337

			x += 6;

   338

			cg_ofst = IsWindowWidgetLowered(w, STATIONLIST_WIDGET_NOCARGOWAITING) ? 2 : 1;

   339

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

   340

			x += 14;

   341

			cg_ofst = IsWindowWidgetLowered(w, STATIONLIST_WIDGET_CARGOALL) ? 2 : 1;

   342

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

   343

   344

			cg_ofst = IsWindowWidgetLowered(w, STATIONLIST_WIDGET_FACILALL) ? 2 : 1;

   345

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

   346

   347

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

   348

				DrawString(xb, 40, STR_304A_NONE, 0);

   349

				return;

   350

			}

   351

   352

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

   353

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

   354

   355

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

   356

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

   357

				CargoID j;

   358

				int x;

   359

   360

				assert(st->xy != 0);

   361

				assert(st->owner == owner);

   362

   363

				SetDParam(0, st->index);

   364

				SetDParam(1, st->facilities);

   365

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

   366

   367

				// show cargo waiting and station ratings

   368

				for (j = 0; j != NUM_CARGO; j++) {

   369

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

   370

   371

					if (amount != 0) {

   372

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

   373

						x += 20;

   374

					}

   375

				}

   376

				y += 10;

   377

			}

   378

		}

   379

	} break;

   380

   381

	case WE_CLICK: {

   382

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

   383

		case STATIONLIST_WIDGET_LIST: {

   384

			const Station* st;

   385

   386

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

   387

   388

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

   389

   390

			id_v += w->vscroll.pos;

   391

   392

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

   393

   394

			st = sl->sort_list[id_v];

   395

			assert(st->owner == owner);

   396

			ScrollMainWindowToTile(st->xy);

   397

			break;

   398

		}

   399

   400

		case STATIONLIST_WIDGET_TRAIN:

   401

		case STATIONLIST_WIDGET_TRUCK:

   402

		case STATIONLIST_WIDGET_BUS:

   403

		case STATIONLIST_WIDGET_AIRPLANE:

   404

		case STATIONLIST_WIDGET_SHIP:

   405

			if (_ctrl_pressed) {

   406

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

   407

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

   408

			} else {

   409

				int i;

   410

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

   411

					if (HASBIT(facilities, 0)) RaiseWindowWidget(w, i + STATIONLIST_WIDGET_TRAIN);

   412

				}

   413

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

   414

				LowerWindowWidget(w, e->we.click.widget);

   415

			}

   416

			SetWindowWidgetLoweredState(w, STATIONLIST_WIDGET_FACILALL, facilities == (FACIL_TRAIN | FACIL_TRUCK_STOP | FACIL_BUS_STOP | FACIL_AIRPORT | FACIL_DOCK));

   417

			sl->flags |= SL_REBUILD;

   418

			SetWindowDirty(w);

   419

		break;

   420

   421

		case STATIONLIST_WIDGET_FACILALL: {

   422

			int i;

   423

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

   424

				LowerWindowWidget(w, i + STATIONLIST_WIDGET_TRAIN);

   425

			}

   426

			LowerWindowWidget(w, STATIONLIST_WIDGET_FACILALL);

   427

   428

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

   429

			sl->flags |= SL_REBUILD;

   430

			SetWindowDirty(w);

   431

			break;

   432

		}

   433

		case STATIONLIST_WIDGET_CARGOALL: {

   434

			int i;

   435

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

   436

				LowerWindowWidget(w, i + STATIONLIST_WIDGET_CARGOSTART);

   437

			}

   438

			LowerWindowWidget(w, STATIONLIST_WIDGET_NOCARGOWAITING);

   439

			LowerWindowWidget(w, STATIONLIST_WIDGET_CARGOALL);

   440

   441

			cargo_filter = CARGO_ALL_SELECTED;

   442

			sl->flags |= SL_REBUILD;

   443

			SetWindowDirty(w);

   444

			break;

   445

		}

   446

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

   447

			TOGGLEBIT(sl->flags, 0); //DESC-flag

   448

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

   449

			sl->flags |= SL_RESORT;

   450

			w->flags4 |= 5 << WF_TIMEOUT_SHL;

   451

			LowerWindowWidget(w, STATIONLIST_WIDGET_SORTBY);

   452

			SetWindowDirty(w);

   453

		break;

   454

   455

		case STATIONLIST_WIDGET_SORTCRITERIA:

   456

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

   457

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

   458

		break;

   459

   460

		default:

   461

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

   462

				if (_ctrl_pressed) {

   463

					TOGGLEBIT(cargo_filter, e->we.click.widget - STATIONLIST_WIDGET_CARGOSTART);

   464

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

   465

				} else {

   466

					int i;

   467

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

   468

						if (HASBIT(cargo_filter, 0)) RaiseWindowWidget(w, i + STATIONLIST_WIDGET_CARGOSTART);

   469

					}

   470

					SETBIT(cargo_filter, e->we.click.widget - STATIONLIST_WIDGET_CARGOSTART);

   471

					LowerWindowWidget(w, e->we.click.widget);

   472

				}

   473

				sl->flags |= SL_REBUILD;

   474

				SetWindowWidgetLoweredState(w, STATIONLIST_WIDGET_CARGOALL, cargo_filter == CARGO_ALL_SELECTED);

   475

				SetWindowDirty(w);

   476

			}

   477

		}

   478

	} break;

   479

   480

	case WE_DROPDOWN_SELECT: /* we have selected a dropdown item in the list */

   481

		if (sl->sort_type != e->we.dropdown.index) {

   482

			// value has changed -> resort

   483

			sl->sort_type = e->we.dropdown.index;

   484

			station_sort.criteria = sl->sort_type;

   485

			sl->flags |= SL_RESORT;