1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "debug.h"

     6

#include "functions.h"

     7

#include "table/sprites.h"

     8

#include "table/strings.h"

     9

#include "window.h"

    10

#include "gui.h"

    11

#include "command.h"

    12

#include "variables.h"

    13

#include "vehicle_gui.h"

    14

#include "newgrf_engine.h"

    15

    16

    17

static RailType _railtype_selected_in_replace_gui;

    18

    19

static bool _rebuild_left_list;

    20

static bool _rebuild_right_list;

    21

    22

static const StringID _rail_types_list[] = {

    23

	STR_RAIL_VEHICLES,

    24

	STR_ELRAIL_VEHICLES,

    25

	STR_MONORAIL_VEHICLES,

    26

	STR_MAGLEV_VEHICLES,

    27

	INVALID_STRING_ID

    28

};

    29

    30

/* General Vehicle GUI based procedures that are independent of vehicle types */

    31

void InitializeVehiclesGuiList(void)

    32

{

    33

	_railtype_selected_in_replace_gui = RAILTYPE_RAIL;

    34

}

    35

    36

/** Rebuild the left autoreplace list if an engine is removed or added

    37

 * @param e Engine to check if it is removed or added

    38

 *  Note: this function only works if it is called either

    39

 *   - when a new vehicle is build, but before it's counted in num_engines

    40

 *   - when a vehicle is deleted and after it's substracted from num_engines

    41

 *   - when not changing the count (used when changing replace orders)

    42

 */

    43

void InvalidateAutoreplaceWindow(EngineID e)

    44

{

    45

	Player *p = GetPlayer(_local_player);

    46

	byte type = GetEngine(e)->type;

    47

    48

	if (p->num_engines[e] == 0) {

    49

		/* We don't have any of this engine type.

    50

		 * Either we just sold the last one, we build a new one or we stopped replacing it.

    51

		 * In all cases, we need to update the left list */

    52

		_rebuild_left_list = true;

    53

	} else {

    54

		_rebuild_left_list = false;

    55

	}

    56

	_rebuild_right_list = false;

    57

	InvalidateWindowData(WC_REPLACE_VEHICLE, type);

    58

}

    59

    60

/** When an engine is made buildable or is removed from being buildable, add/remove it from the build/autoreplace lists

    61

 * @param type The type of engine

    62

 */

    63

void AddRemoveEngineFromAutoreplaceAndBuildWindows(byte type)

    64

{

    65

	_rebuild_left_list = false; // left list is only for the vehicles the player owns and is not related to being buildable

    66

	_rebuild_right_list = true;

    67

	InvalidateWindowData(WC_REPLACE_VEHICLE, type); // Update the autoreplace window

    68

	InvalidateWindowClassesData(WC_BUILD_VEHICLE); // The build windows needs updating as well

    69

}

    70

    71

/** Get the default cargo type for an engine

    72

 * @param engine the EngineID to get the cargo for

    73

 * @return the cargo type carried by the engine (CT_INVALID if engine got no cargo capacity)

    74

 */

    75

static CargoID EngineCargo(EngineID engine)

    76

{

    77

	if (engine == INVALID_ENGINE) return CT_INVALID; // surely INVALID_ENGINE can't carry anything but CT_INVALID

    78

    79

	switch (GetEngine(engine)->type) {

    80

		default: NOT_REACHED();

    81

		case VEH_Train:

    82

			if (RailVehInfo(engine)->capacity == 0) return CT_INVALID; // no capacity -> can't carry cargo

    83

			return RailVehInfo(engine)->cargo_type;

    84

		case VEH_Road:       return RoadVehInfo(engine)->cargo_type;

    85

		case VEH_Ship:       return ShipVehInfo(engine)->cargo_type;

    86

		case VEH_Aircraft:   return CT_PASSENGERS; // all planes are build with passengers by default

    87

	}

    88

}

    89

    90

/** Figure out if an engine should be added to a list

    91

 * @param e The EngineID

    92

 * @param draw_left If true, then the left list is drawn (the engines specific to the railtype you selected)

    93

 * @param show_engines if truem then locomotives are drawn, else wagons (never both)

    94

 * @return true if the engine should be in the list (based on this check)

    95

 */

    96

static bool GenerateReplaceRailList(EngineID e, bool draw_left, bool show_engines)

    97

{

    98

	const RailVehicleInfo *rvi = RailVehInfo(e);

    99

   100

	/* Ensure that the wagon/engine selection fits the engine. */

   101

	if ((rvi->railveh_type == RAILVEH_WAGON) == show_engines) return false;

   102

   103

	if (draw_left && show_engines) {

   104

		/* Ensure that the railtype is specific to the selected one */

   105

		if (rvi->railtype != _railtype_selected_in_replace_gui) return false;

   106

	} else {

   107

		/* Ensure that it's a compatible railtype to the selected one (like electric <-> diesel)

   108

		 * The vehicle do not have to have power on the railtype in question, only able to drive (pulled if needed) */

   109

		if (!IsCompatibleRail(rvi->railtype, _railtype_selected_in_replace_gui)) return false;

   110

	}

   111

	return true;

   112

}

   113

   114

/** Figure out if two engines got at least one type of cargo in common (refitting if needed)

   115

 * @param engine_a one of the EngineIDs

   116

 * @param engine_b the other EngineID

   117

 * @return true if they can both carry the same type of cargo (or at least one of them got no capacity at all)

   118

 */

   119

static bool EnginesGotCargoInCommon(EngineID engine_a, EngineID engine_b)

   120

{

   121

	CargoID a = EngineCargo(engine_a);

   122

	CargoID b = EngineCargo(engine_b);

   123

   124

	 /* we should always be able to refit to/from locomotives without capacity

   125

	  * Because of that, CT_INVALID shoudl always return true */

   126

	if (a == CT_INVALID || b == CT_INVALID || a == b) return true; // they carry no ro the same type by default

   127

	if (EngInfo(engine_a)->refit_mask & EngInfo(engine_b)->refit_mask) return true; // both can refit to the same

   128

	if (CanRefitTo(engine_a, b) || CanRefitTo(engine_b, a)) return true; // one can refit to what the other one carries

   129

	return false;

   130

}

   131

   132

/** Generate a list

   133

 * @param w Window, that contains the list

   134

 * @param draw_left true if generating the left list, otherwise false

   135

 */

   136

static void GenerateReplaceVehList(Window *w, bool draw_left)

   137

{

   138

	Player *p = GetPlayer(_local_player);

   139

	EngineID e;

   140

	EngineID selected_engine = INVALID_ENGINE;

   141

	byte type = w->window_number;

   142

	byte i = draw_left ? 0 : 1;

   143

   144

	EngineList *list = &WP(w, replaceveh_d).list[i];

   145

	EngList_RemoveAll(list);

   146

   147

	FOR_ALL_ENGINEIDS_OF_TYPE(e, type) {

   148

		if (type == VEH_Train && !GenerateReplaceRailList(e, draw_left, WP(w, replaceveh_d).wagon_btnstate)) continue; // special rules for trains

   149

   150

		if (draw_left) {

   151

			/* Skip drawing the engines we don't have any of and haven't set for replacement */

   152

			if (p->num_engines[e] == 0 && EngineReplacementForPlayer(GetPlayer(_local_player), e) == INVALID_ENGINE) continue;

   153

		} else {

   154

			/* This is for engines we can replace to and they should depend on what we selected to replace from */

   155

			if (!IsEngineBuildable(e, type, _local_player)) continue; // we need to be able to build the engine

   156

			if (!EnginesGotCargoInCommon(e, WP(w, replaceveh_d).sel_engine[0])) continue; // the engines needs to be able to carry the same cargo

   157

			if (e == WP(w, replaceveh_d).sel_engine[0]) continue; // we can't replace an engine into itself (that would be autorenew)

   158

		}

   159

   160

		EngList_Add(list, e);

   161

		if (e == WP(w, replaceveh_d).sel_engine[i]) selected_engine = e; // The selected engine is still in the list

   162

	}

   163

	WP(w, replaceveh_d).sel_engine[i] = selected_engine; // update which engine we selected (the same or none, if it's not in the list anymore)

   164

}

   165

   166

/** Generate the lists

   167

 * @param w Window containing the lists

   168

 */

   169

static void GenerateLists(Window *w)

   170

{

   171

	EngineID e = WP(w, replaceveh_d).sel_engine[0];

   172

   173

	if (WP(w, replaceveh_d).update_left == true) {

   174

		/* We need to rebuild the left list */

   175

		GenerateReplaceVehList(w, true);

   176

		SetVScrollCount(w, EngList_Count(&WP(w, replaceveh_d).list[0]));

   177

		if (WP(w, replaceveh_d).init_lists && WP(w, replaceveh_d).sel_engine[0] == INVALID_ENGINE && EngList_Count(&WP(w, replaceveh_d).list[0]) != 0) {

   178

			WP(w, replaceveh_d).sel_engine[0] = WP(w, replaceveh_d).list[0][0];

   179

		}

   180

	}

   181

   182

	if (WP(w, replaceveh_d).update_right || e != WP(w, replaceveh_d).sel_engine[0]) {

   183

		/* Either we got a request to rebuild the right list or the left list selected a different engine */

   184

		if (WP(w, replaceveh_d).sel_engine[0] == INVALID_ENGINE) {

   185

			/* Always empty the right list when nothing is selected in the left list */

   186

			EngList_RemoveAll(&WP(w, replaceveh_d).list[1]);

   187

			WP(w, replaceveh_d).sel_engine[1] = INVALID_ENGINE;

   188

		} else {

   189

			GenerateReplaceVehList(w, false);

   190

			SetVScroll2Count(w, EngList_Count(&WP(w, replaceveh_d).list[1]));

   191

			if (WP(w, replaceveh_d).init_lists && WP(w, replaceveh_d).sel_engine[1] == INVALID_ENGINE && EngList_Count(&WP(w, replaceveh_d).list[1]) != 0) {

   192

				WP(w, replaceveh_d).sel_engine[1] = WP(w, replaceveh_d).list[1][0];

   193

			}

   194

		}

   195

	}

   196

	/* Reset the flags about needed updates */

   197

	WP(w, replaceveh_d).update_left  = false;

   198

	WP(w, replaceveh_d).update_right = false;

   199

	WP(w, replaceveh_d).init_lists   = false;

   200

}

   201

   202

   203

void DrawEngineList(byte type, int x, int y, const EngineList eng_list, uint16 min, uint16 max, EngineID selected_id, bool show_count);

   204

   205

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

   206

{

   207

	/* Strings for the pulldown menu */

   208

	static const StringID _vehicle_type_names[] = {

   209

		STR_019F_TRAIN,

   210

		STR_019C_ROAD_VEHICLE,

   211

		STR_019E_SHIP,

   212

		STR_019D_AIRCRAFT

   213

	};

   214

   215

	switch (e->event) {

   216

		case WE_CREATE:

   217

			WP(w, replaceveh_d).wagon_btnstate = true; // start with locomotives (all other vehicles will not read this bool)

   218

			EngList_Create(&WP(w, replaceveh_d).list[0]);

   219

			EngList_Create(&WP(w, replaceveh_d).list[1]);

   220

			WP(w, replaceveh_d).update_left   = true;

   221

			WP(w, replaceveh_d).update_right  = true;

   222

			WP(w, replaceveh_d).init_lists    = true;

   223

			WP(w, replaceveh_d).sel_engine[0] = INVALID_ENGINE;

   224

			WP(w, replaceveh_d).sel_engine[1] = INVALID_ENGINE;

   225

			break;

   226

   227

		case WE_PAINT: {

   228

			if (WP(w, replaceveh_d).update_left || WP(w, replaceveh_d).update_right) GenerateLists(w);

   229

   230

			Player *p = GetPlayer(_local_player);

   231

			EngineID selected_id[2];

   232

   233

			selected_id[0] = WP(w, replaceveh_d).sel_engine[0];

   234

			selected_id[1] = WP(w, replaceveh_d).sel_engine[1];

   235

   236

			/* Disable the "Start Replacing" button if:

   237

			 *    Either list is empty

   238

			 * or The selected replacement engine has a replacement (to prevent loops)

   239

			 * or The right list (new replacement) has the existing replacement vehicle selected */

   240

			SetWindowWidgetDisabledState(w, 4,

   241

										 selected_id[0] == INVALID_ENGINE ||

   242

										 selected_id[1] == INVALID_ENGINE ||

   243

										 EngineReplacementForPlayer(p, selected_id[1]) != INVALID_ENGINE ||

   244

										 EngineReplacementForPlayer(p, selected_id[0]) == selected_id[1]);

   245

   246

			/* Disable the "Stop Replacing" button if:

   247

			 *   The left list (existing vehicle) is empty

   248

			 *   or The selected vehicle has no replacement set up */

   249

			SetWindowWidgetDisabledState(w, 6,

   250

										 selected_id[0] == INVALID_ENGINE ||

   251

										 !EngineHasReplacementForPlayer(p, selected_id[0]));

   252

   253

			/* now the actual drawing of the window itself takes place */

   254

			SetDParam(0, _vehicle_type_names[w->window_number]);

   255

   256

			if (w->window_number == VEH_Train) {

   257

				/* set on/off for renew_keep_length */

   258

				SetDParam(1, p->renew_keep_length ? STR_CONFIG_PATCHES_ON : STR_CONFIG_PATCHES_OFF);

   259

   260

				/* set wagon/engine button */

   261

				SetDParam(2, WP(w, replaceveh_d).wagon_btnstate ? STR_ENGINES : STR_WAGONS);

   262

			}

   263

   264

			w->widget[13].color = _player_colors[_local_player]; // sets the colour of that art thing

   265

			w->widget[16].color = _player_colors[_local_player]; // sets the colour of that art thing

   266

   268

   269

   270

			if (w->window_number == VEH_Train) {

   271

				/* Draw the selected railtype in the pulldown menu */

   272

				RailType railtype = _railtype_selected_in_replace_gui;

   273

				DrawString(157, w->widget[14].top + 1, _rail_types_list[railtype], 0x10);

   274

			}

   275

   276

			/* sets up the string for the vehicle that is being replaced to */

   277

			if (selected_id[0] != INVALID_ENGINE) {

   278

				if (!EngineHasReplacementForPlayer(p, selected_id[0])) {

   279

					SetDParam(0, STR_NOT_REPLACING);

   280

				} else {

   281

					SetDParam(0, GetCustomEngineName(EngineReplacementForPlayer(p, selected_id[0])));

   282

				}

   283

			} else {

   284

				SetDParam(0, STR_NOT_REPLACING_VEHICLE_SELECTED);

   285

			}

   286

   287

			DrawString(145, w->widget[5].top + 1, STR_02BD, 0x10);

   288

   289

			/* Draw the lists */

   290

			for(byte i = 0; i < 2; i++) {

   291

				uint16 x        = i == 0 ? 2 : 230; // at what X offset

   292

				EngineList list = WP(w, replaceveh_d).list[i]; // which list to draw

   293

				EngineID start  = i == 0 ? w->vscroll.pos : w->vscroll2.pos; // what is the offset for the start (scrolling)

   294

				EngineID end    = min((i == 0 ? w->vscroll.cap : w->vscroll2.cap) + start, EngList_Count(&list));

   295

   296

				/* Do the actual drawing */

   297

				DrawEngineList(w->window_number, x, 15, list, start, end, WP(w, replaceveh_d).sel_engine[i], i == 0);

   298

   299

				/* Also draw the details if an engine is selected */

   300

				if (WP(w, replaceveh_d).sel_engine[i] != INVALID_ENGINE) {

   301

					const Widget *wi = &w->widget[i == 0 ? 3 : 11];

   302

					DrawVehiclePurchaseInfo(wi->left + 2, wi->top + 1, wi->right - wi->left - 2, WP(w, replaceveh_d).sel_engine[i]);

   303

				}

   304

			}

   305

   306

		} break;   // end of paint

   307

   308

		case WE_CLICK: {

   309

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

   310

				case 12:

   311

					WP(w, replaceveh_d).wagon_btnstate = !(WP(w, replaceveh_d).wagon_btnstate);

   312

					WP(w, replaceveh_d).update_left = true;

   313

					WP(w, replaceveh_d).init_lists  = true;

   314

					w->SetDirty();

   315

					break;

   316

   317

				case 14:

   318

				case 15: /* Railtype selection dropdown menu */

   320

					break;

   321

   322

				case 17: /* toggle renew_keep_length */

   323

					DoCommandP(0, 5, GetPlayer(_local_player)->renew_keep_length ? 0 : 1, NULL, CMD_SET_AUTOREPLACE);

   324

					break;

   325

   326

				case 4: { /* Start replacing */

   327

					EngineID veh_from = WP(w, replaceveh_d).sel_engine[0];

   328

					EngineID veh_to = WP(w, replaceveh_d).sel_engine[1];

   329

					DoCommandP(0, 3, veh_from + (veh_to << 16), NULL, CMD_SET_AUTOREPLACE);

   330

				} break;

   331

   332

				case 6: { /* Stop replacing */

   333

					EngineID veh_from = WP(w, replaceveh_d).sel_engine[0];

   334

					DoCommandP(0, 3, veh_from + (INVALID_ENGINE << 16), NULL, CMD_SET_AUTOREPLACE);

   335

				} break;

   336

   337

				case 7:

   338

				case 9: {

   339

					uint i = (e->we.click.pt.y - 14) / w->resize.step_height;

   340

					uint16 click_scroll_pos = e->we.click.widget == 7 ? w->vscroll.pos : w->vscroll2.pos;

   341

					uint16 click_scroll_cap = e->we.click.widget == 7 ? w->vscroll.cap : w->vscroll2.cap;

   342

					byte click_side         = e->we.click.widget == 7 ? 0 : 1;

   343

					uint16 engine_count     = EngList_Count(&WP(w, replaceveh_d).list[click_side]);

   344

   345

					if (i < click_scroll_cap) {

   346

						i += click_scroll_pos;

   347

						EngineID e = engine_count > i ? WP(w, replaceveh_d).list[click_side][i] : INVALID_ENGINE;

   348

						if (e == WP(w, replaceveh_d).sel_engine[click_side]) break; // we clicked the one we already selected

   349

						WP(w, replaceveh_d).sel_engine[click_side] = e;

   350

						if (click_side == 0) {

   351

							WP(w, replaceveh_d).update_right = true;

   352

							WP(w, replaceveh_d).init_lists   = true;

   353

						}

   354

						w->SetDirty();

   355

						}

   356

					break;

   357

					}

   358

			}

   359

			break;

   360

		}

   361

   362

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

   363

			RailType temp = (RailType)e->we.dropdown.index;

   364

			if (temp == _railtype_selected_in_replace_gui) break; // we didn't select a new one. No need to change anything

   365

			_railtype_selected_in_replace_gui = temp;

   366

			/* Reset scrollbar positions */

   367

			w->vscroll.pos  = 0;

   368

			w->vscroll2.pos = 0;

   369

			/* Rebuild the lists */

   370

			WP(w, replaceveh_d).update_left  = true;

   371

			WP(w, replaceveh_d).update_right = true;

   372

			WP(w, replaceveh_d).init_lists   = true;

   373

			w->SetDirty();

   374

		} break;

   375

   376

		case WE_RESIZE:

   377

			w->vscroll.cap  += e->we.sizing.diff.y / (int)w->resize.step_height;

   378

			w->vscroll2.cap += e->we.sizing.diff.y / (int)w->resize.step_height;

   379

   380

			w->widget[7].data = (w->vscroll.cap  << 8) + 1;

   381

			w->widget[9].data = (w->vscroll2.cap << 8) + 1;

   382

			break;

   383

   384

		case WE_INVALIDATE_DATA:

   385

			if (_rebuild_left_list) WP(w, replaceveh_d).update_left = true;

   386

			if (_rebuild_right_list) WP(w, replaceveh_d).update_right = true;

   387

			w->SetDirty();

   388

			break;

   389

   390

		case WE_DESTROY:

   391

			EngList_RemoveAll(&WP(w, replaceveh_d).list[0]);

   392

			EngList_RemoveAll(&WP(w, replaceveh_d).list[1]);

   393

		break;

   394

	}

   395

}

   396

   397

static const Widget _replace_rail_vehicle_widgets[] = {

   398

{   WWT_CLOSEBOX,   RESIZE_NONE,    14,     0,    10,     0,    13, STR_00C5,       STR_018B_CLOSE_WINDOW},

   399

{    WWT_CAPTION,   RESIZE_NONE,    14,    11,   443,     0,    13, STR_REPLACE_VEHICLES_WHITE, STR_018C_WINDOW_TITLE_DRAG_THIS},

   400

{  WWT_STICKYBOX,   RESIZE_NONE,    14,   444,   455,     0,    13, STR_NULL,       STR_STICKY_BUTTON},

   401

{      WWT_PANEL,     RESIZE_TB,    14,     0,   227,   126,   227, 0x0,            STR_NULL},

   402

{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,     0,   138,   240,   251, STR_REPLACE_VEHICLES_START, STR_REPLACE_HELP_START_BUTTON},

   403

{      WWT_PANEL,     RESIZE_TB,    14,   139,   316,   228,   239, 0x0,            STR_REPLACE_HELP_REPLACE_INFO_TAB},

   404

{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,   306,   443,   240,   251, STR_REPLACE_VEHICLES_STOP,  STR_REPLACE_HELP_STOP_BUTTON},

   405

{     WWT_MATRIX, RESIZE_BOTTOM,    14,     0,   215,    14,   125, 0x801,          STR_REPLACE_HELP_LEFT_ARRAY},

   406

{  WWT_SCROLLBAR, RESIZE_BOTTOM,    14,   216,   227,    14,   125, STR_NULL,       STR_0190_SCROLL_BAR_SCROLLS_LIST},

   407

{     WWT_MATRIX, RESIZE_BOTTOM,    14,   228,   443,    14,   125, 0x801,          STR_REPLACE_HELP_RIGHT_ARRAY},

   408

{ WWT_SCROLL2BAR, RESIZE_BOTTOM,    14,   444,   455,    14,   125, STR_NULL,       STR_0190_SCROLL_BAR_SCROLLS_LIST},

   409

{      WWT_PANEL,     RESIZE_TB,    14,   228,   455,   126,   227, 0x0,            STR_NULL},

   410

// train specific stuff

   411

{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,     0,   138,   228,   239, STR_REPLACE_ENGINE_WAGON_SELECT,       STR_REPLACE_ENGINE_WAGON_SELECT_HELP},  // widget 12

   412

{      WWT_PANEL,     RESIZE_TB,    14,   139,   153,   240,   251, 0x0,            STR_NULL},

   413

{      WWT_PANEL,     RESIZE_TB,    14,   154,   277,   240,   251, 0x0,            STR_REPLACE_HELP_RAILTYPE},

   414

{    WWT_TEXTBTN,     RESIZE_TB,    14,   278,   289,   240,   251, STR_0225,       STR_REPLACE_HELP_RAILTYPE},

   415

{      WWT_PANEL,     RESIZE_TB,    14,   290,   305,   240,   251, 0x0,            STR_NULL},

   416

{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,   317,   455,   228,   239, STR_REPLACE_REMOVE_WAGON,       STR_REPLACE_REMOVE_WAGON_HELP},

   417

// end of train specific stuff

   418

{  WWT_RESIZEBOX,     RESIZE_TB,    14,   444,   455,   240,   251, STR_NULL,       STR_RESIZE_BUTTON},

   419

{   WIDGETS_END},

   420

};

   421

   422

static const Widget _replace_road_vehicle_widgets[] = {

   423

{   WWT_CLOSEBOX,   RESIZE_NONE,    14,     0,    10,     0,    13, STR_00C5,                    STR_018B_CLOSE_WINDOW},

   424

{    WWT_CAPTION,   RESIZE_NONE,    14,    11,   443,     0,    13, STR_REPLACE_VEHICLES_WHITE,  STR_018C_WINDOW_TITLE_DRAG_THIS},

   425

{  WWT_STICKYBOX,   RESIZE_NONE,    14,   444,   455,     0,    13, STR_NULL,                    STR_STICKY_BUTTON},

   426

{      WWT_PANEL,     RESIZE_TB,    14,     0,   227,   126,   217, 0x0,                         STR_NULL},

   427

{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,     0,   138,   218,   229, STR_REPLACE_VEHICLES_START,  STR_REPLACE_HELP_START_BUTTON},

   428

{      WWT_PANEL,     RESIZE_TB,    14,   139,   305,   218,   229, 0x0,                         STR_REPLACE_HELP_REPLACE_INFO_TAB},

   429

{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,   306,   443,   218,   229, STR_REPLACE_VEHICLES_STOP,   STR_REPLACE_HELP_STOP_BUTTON},

   430

{     WWT_MATRIX, RESIZE_BOTTOM,    14,     0,   215,    14,   125, 0x801,                       STR_REPLACE_HELP_LEFT_ARRAY},

   431

{  WWT_SCROLLBAR, RESIZE_BOTTOM,    14,   216,   227,    14,   125, STR_NULL,                    STR_0190_SCROLL_BAR_SCROLLS_LIST},

   432

{     WWT_MATRIX, RESIZE_BOTTOM,    14,   228,   443,    14,   125, 0x801,                       STR_REPLACE_HELP_RIGHT_ARRAY},

   433

{ WWT_SCROLL2BAR, RESIZE_BOTTOM,    14,   444,   455,    14,   125, STR_NULL,                    STR_0190_SCROLL_BAR_SCROLLS_LIST},

   434

{      WWT_PANEL,     RESIZE_TB,    14,   228,   455,   126,   217, 0x0,                         STR_NULL},

   435

{  WWT_RESIZEBOX,     RESIZE_TB,    14,   444,   455,   218,   229, STR_NULL,                    STR_RESIZE_BUTTON},

   436

{   WIDGETS_END},

   437

};

   438

   439

static const Widget _replace_ship_aircraft_vehicle_widgets[] = {

   440

{   WWT_CLOSEBOX,   RESIZE_NONE,    14,     0,    10,     0,    13, STR_00C5,                    STR_018B_CLOSE_WINDOW},

   441

{    WWT_CAPTION,   RESIZE_NONE,    14,    11,   443,     0,    13, STR_REPLACE_VEHICLES_WHITE,  STR_018C_WINDOW_TITLE_DRAG_THIS},

   442

{  WWT_STICKYBOX,   RESIZE_NONE,    14,   444,   455,     0,    13, STR_NULL,                    STR_STICKY_BUTTON},

   443

{      WWT_PANEL,     RESIZE_TB,    14,     0,   227,   110,   201, 0x0,                         STR_NULL},

   444

{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,     0,   138,   202,   213, STR_REPLACE_VEHICLES_START,  STR_REPLACE_HELP_START_BUTTON},

   445

{      WWT_PANEL,     RESIZE_TB,    14,   139,   305,   202,   213, 0x0,                         STR_REPLACE_HELP_REPLACE_INFO_TAB},

   446

{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,   306,   443,   202,   213, STR_REPLACE_VEHICLES_STOP,   STR_REPLACE_HELP_STOP_BUTTON},

   447

{     WWT_MATRIX, RESIZE_BOTTOM,    14,     0,   215,    14,   109, 0x401,                       STR_REPLACE_HELP_LEFT_ARRAY},

   448

{  WWT_SCROLLBAR, RESIZE_BOTTOM,    14,   216,   227,    14,   109, STR_NULL,                    STR_0190_SCROLL_BAR_SCROLLS_LIST},

   449

{     WWT_MATRIX, RESIZE_BOTTOM,    14,   228,   443,    14,   109, 0x401,                       STR_REPLACE_HELP_RIGHT_ARRAY},

   450

{ WWT_SCROLL2BAR, RESIZE_BOTTOM,    14,   444,   455,    14,   109, STR_NULL,                    STR_0190_SCROLL_BAR_SCROLLS_LIST},

   451

{      WWT_PANEL,     RESIZE_TB,    14,   228,   455,   110,   201, 0x0,                         STR_NULL},

   452

{  WWT_RESIZEBOX,     RESIZE_TB,    14,   444,   455,   202,   213, STR_NULL,                    STR_RESIZE_BUTTON},

   453

{   WIDGETS_END},

   454

};

   455

   456

static const WindowDesc _replace_rail_vehicle_desc = {

   457

	WDP_AUTO, WDP_AUTO, 456, 252,

   458

	WC_REPLACE_VEHICLE, WC_NONE,

   459

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS | WDF_STICKY_BUTTON | WDF_RESIZABLE,

   460

	_replace_rail_vehicle_widgets,

   461

	ReplaceVehicleWndProc

   462

};

   463

   464

static const WindowDesc _replace_road_vehicle_desc = {

   465

	WDP_AUTO, WDP_AUTO, 456, 230,

   466

	WC_REPLACE_VEHICLE, WC_NONE,

   467

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS | WDF_STICKY_BUTTON | WDF_RESIZABLE,

   468

	_replace_road_vehicle_widgets,

   469

	ReplaceVehicleWndProc

   470

};

   471

   472

static const WindowDesc _replace_ship_aircraft_vehicle_desc = {

   473

	WDP_AUTO, WDP_AUTO, 456, 214,

   474

	WC_REPLACE_VEHICLE, WC_NONE,

   475

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS | WDF_STICKY_BUTTON | WDF_RESIZABLE,

   476

	_replace_ship_aircraft_vehicle_widgets,

   477

	ReplaceVehicleWndProc

   478

};

   479

   480

   481

void ShowReplaceVehicleWindow(byte vehicletype)

   482

{

   483

	Window *w;

   484

   485

	DeleteWindowById(WC_REPLACE_VEHICLE, vehicletype);

   486

   487

	switch (vehicletype) {

   488

		case VEH_Train:

   489

			w = AllocateWindowDescFront(&_replace_rail_vehicle_desc, vehicletype);

   490

			w->vscroll.cap  = 8;

   491

			w->resize.step_height = 14;