1

/* $Id$ */

     2

     3

/** @file autoreplace_gui.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "debug.h"

     8

#include "gui.h"

     9

#include "command_func.h"

    10

#include "variables.h"

    11

#include "vehicle_gui.h"

    12

#include "newgrf_engine.h"

    13

#include "group.h"

    14

#include "rail.h"

    15

#include "strings_func.h"

    16

#include "window_func.h"

    17

#include "vehicle_func.h"

    18

#include "autoreplace_func.h"

    19

#include "gfx_func.h"

    20

#include "player_func.h"

    21

#include "widgets/dropdown_func.h"

    22

    23

#include "table/sprites.h"

    24

#include "table/strings.h"

    25

    26

static RailType _railtype_selected_in_replace_gui;

    27

    28

static bool _rebuild_left_list;

    29

static bool _rebuild_right_list;

    30

    31

static const StringID _rail_types_list[] = {

    32

	STR_RAIL_VEHICLES,

    33

	STR_ELRAIL_VEHICLES,

    34

	STR_MONORAIL_VEHICLES,

    35

	STR_MAGLEV_VEHICLES,

    36

	INVALID_STRING_ID

    37

};

    38

    39

enum ReplaceVehicleWindowWidgets {

    40

	RVW_WIDGET_LEFT_DETAILS = 3,

    41

	RVW_WIDGET_START_REPLACE,

    42

	RVW_WIDGET_INFO_TAB,

    43

	RVW_WIDGET_STOP_REPLACE,

    44

	RVW_WIDGET_LEFT_MATRIX,

    45

	RVW_WIDGET_LEFT_SCROLLBAR,

    46

	RVW_WIDGET_RIGHT_MATRIX,

    47

	RVW_WIDGET_RIGHT_SCROLLBAR,

    48

	RVW_WIDGET_RIGHT_DETAILS,

    49

    50

	RVW_WIDGET_TRAIN_ENGINEWAGON_TOGGLE,

    51

	RVW_WIDGET_TRAIN_FLUFF_LEFT,

    52

	RVW_WIDGET_TRAIN_RAILTYPE_DROPDOWN,

    53

	RVW_WIDGET_TRAIN_FLUFF_RIGHT,

    54

	RVW_WIDGET_TRAIN_WAGONREMOVE_TOGGLE,

    55

};

    56

    57

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

    58

{

    59

	const EngineID va = *(const EngineID*)a;

    60

	const EngineID vb = *(const EngineID*)b;

    61

	int r = ListPositionOfEngine(va) - ListPositionOfEngine(vb);

    62

    63

	return r;

    64

}

    65

    66

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

    67

void InitializeVehiclesGuiList()

    68

{

    69

	_railtype_selected_in_replace_gui = RAILTYPE_RAIL;

    70

}

    71

    72

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

    73

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

    74

 * @param id_g The group the engine belongs to

    75

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

    76

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

    77

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

    78

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

    79

 */

    80

void InvalidateAutoreplaceWindow(EngineID e, GroupID id_g)

    81

{

    82

	Player *p = GetPlayer(_local_player);

    83

	byte type = GetEngine(e)->type;

    84

	uint num_engines = GetGroupNumEngines(_local_player, id_g, e);

    85

    86

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

    87

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

    88

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

    89

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

    90

		_rebuild_left_list = true;

    91

	} else {

    92

		_rebuild_left_list = false;

    93

	}

    94

	_rebuild_right_list = false;

    95

	InvalidateWindowData(WC_REPLACE_VEHICLE, type);

    96

}

    97

    98

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

    99

 * @param type The type of engine

   100

 */

   101

void AddRemoveEngineFromAutoreplaceAndBuildWindows(VehicleType type)

   102

{

   103

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

   104

	_rebuild_right_list = true;

   105

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

   106

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

   107

}

   108

   109

/** Get the default cargo type for an engine

   110

 * @param engine the EngineID to get the cargo for

   111

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

   112

 */

   113

static CargoID EngineCargo(EngineID engine)

   114

{

   115

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

   116

   117

	switch (GetEngine(engine)->type) {

   118

		default: NOT_REACHED();

   119

		case VEH_TRAIN:

   120

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

   121

			return RailVehInfo(engine)->cargo_type;

   122

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

   123

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

   124

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

   125

	}

   126

}

   127

   128

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

   129

 * @param e The EngineID

   130

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

   131

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

   132

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

   133

 */

   134

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

   135

{

   136

	const RailVehicleInfo *rvi = RailVehInfo(e);

   137

   138

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

   139

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

   140

   141

	if (draw_left && show_engines) {

   142

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

   143

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

   144

	} else {

   145

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

   146

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

   147

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

   148

	}

   149

	return true;

   150

}

   151

   152

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

   153

 * @param engine_a one of the EngineIDs

   154

 * @param engine_b the other EngineID

   155

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

   156

 */

   157

static bool EnginesGotCargoInCommon(EngineID engine_a, EngineID engine_b)

   158

{

   159

	CargoID a = EngineCargo(engine_a);

   160

	CargoID b = EngineCargo(engine_b);

   161

   162

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

   163

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

   164

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

   165

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

   166

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

   167

	return false;

   168

}

   169

   170

/** Generate a list

   171

 * @param w Window, that contains the list

   172

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

   173

 */

   174

static void GenerateReplaceVehList(Window *w, bool draw_left)

   175

{

   176

	EngineID e;

   177

	EngineID selected_engine = INVALID_ENGINE;

   178

	byte type = w->window_number;

   179

	byte i = draw_left ? 0 : 1;

   180

   181

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

   182

	EngList_RemoveAll(list);

   183

   184

	FOR_ALL_ENGINEIDS_OF_TYPE(e, type) {

   185

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

   186

   187

		if (draw_left) {

   188

			const GroupID selected_group = WP(w, replaceveh_d).sel_group;

   189

			const uint num_engines = GetGroupNumEngines(_local_player, selected_group, e);

   190

   191

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

   192

			if (num_engines == 0 && EngineReplacementForPlayer(GetPlayer(_local_player), e, selected_group) == INVALID_ENGINE) continue;

   193

		} else {

   194

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

   195

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

   196

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

   197

   198

			/* Road vehicles can't be replaced by trams and vice-versa */

   199

			if (type == VEH_ROAD && HasBit(EngInfo(WP(w, replaceveh_d).sel_engine[0])->misc_flags, EF_ROAD_TRAM) != HasBit(EngInfo(e)->misc_flags, EF_ROAD_TRAM)) continue;

   200

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

   201

		}

   202

   203

		EngList_Add(list, e);

   204

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

   205

	}

   206

	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)

   207

	if (type == VEH_TRAIN) EngList_Sort(list, &TrainEngineNumberSorter);

   208

}

   209

   210

/** Generate the lists

   211

 * @param w Window containing the lists

   212

 */

   213

static void GenerateLists(Window *w)

   214

{

   215

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

   216

   217

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

   218

		/* We need to rebuild the left list */

   219

		GenerateReplaceVehList(w, true);

   220

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

   221

		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) {

   222

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

   223

		}

   224

	}

   225

   226

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

   227

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

   228

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

   229

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

   230

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

   231

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

   232

		} else {

   233

			GenerateReplaceVehList(w, false);

   234

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

   235

			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) {

   236

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

   237

			}

   238

		}

   239

	}

   240

	/* Reset the flags about needed updates */

   241

	WP(w, replaceveh_d).update_left  = false;

   242

	WP(w, replaceveh_d).update_right = false;

   243

	WP(w, replaceveh_d).init_lists   = false;

   244

}

   245

   246

   247

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

   248

   249

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

   250

{

   251

	/* Strings for the pulldown menu */

   252

	static const StringID _vehicle_type_names[] = {

   253

		STR_019F_TRAIN,

   254

		STR_019C_ROAD_VEHICLE,

   255

		STR_019E_SHIP,

   256

		STR_019D_AIRCRAFT

   257

	};

   258

   259

	switch (e->event) {

   260

		case WE_CREATE:

   261

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

   262

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

   263

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

   264

			WP(w, replaceveh_d).update_left   = true;

   265

			WP(w, replaceveh_d).update_right  = true;

   266

			WP(w, replaceveh_d).init_lists    = true;

   267

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

   268

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

   269

			break;

   270

   271

		case WE_PAINT: {

   272

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

   273

   274

			Player *p = GetPlayer(_local_player);

   275

			EngineID selected_id[2];

   276

			const GroupID selected_group = WP(w, replaceveh_d).sel_group;

   277

   278

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

   279

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

   280

   281

			/* Disable the "Start Replacing" button if:

   282

			 *    Either list is empty

   283

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

   284

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

   285

			w->SetWidgetDisabledState(RVW_WIDGET_START_REPLACE,

   286

										 selected_id[0] == INVALID_ENGINE ||

   287

										 selected_id[1] == INVALID_ENGINE ||

   288

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

   289

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

   290

   291

			/* Disable the "Stop Replacing" button if:

   292

			 *   The left list (existing vehicle) is empty

   293

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

   294

			w->SetWidgetDisabledState(RVW_WIDGET_STOP_REPLACE,

   295

										 selected_id[0] == INVALID_ENGINE ||

   296

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

   297

   298

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

   299

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

   300

   301

			if (w->window_number == VEH_TRAIN) {

   302

				/* set on/off for renew_keep_length */

   303

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

   304

   305

				/* set wagon/engine button */

   306

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

   307

   308

				/* sets the colour of that art thing */

   309

				w->widget[RVW_WIDGET_TRAIN_FLUFF_LEFT].color  = _player_colors[_local_player];

   310

				w->widget[RVW_WIDGET_TRAIN_FLUFF_RIGHT].color = _player_colors[_local_player];

   311

			}

   312

   313

			if (w->window_number == VEH_TRAIN) {

   314

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

   315

				RailType railtype = _railtype_selected_in_replace_gui;

   316

				w->widget[RVW_WIDGET_TRAIN_RAILTYPE_DROPDOWN].data = _rail_types_list[railtype];

   317

			}

   318

   319

			DrawWindowWidgets(w);

   320

   321

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

   322

			if (selected_id[0] != INVALID_ENGINE) {

   323

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

   324

					SetDParam(0, STR_NOT_REPLACING);

   325

				} else {

   326

					SetDParam(0, STR_ENGINE_NAME);

   327

					SetDParam(1, EngineReplacementForPlayer(p, selected_id[0], selected_group));

   328

				}

   329

			} else {

   330

				SetDParam(0, STR_NOT_REPLACING_VEHICLE_SELECTED);

   331

			}

   332

   333

			DrawString(145, w->widget[RVW_WIDGET_INFO_TAB].top + 1, STR_02BD, TC_BLACK);

   334

   335

			/* Draw the lists */

   336

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

   337

				uint widget     = (i == 0) ? RVW_WIDGET_LEFT_MATRIX : RVW_WIDGET_RIGHT_MATRIX;

   338

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

   339

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

   340

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

   341

   342

				/* Do the actual drawing */

   343

				DrawEngineList((VehicleType)w->window_number, w->widget[widget].left + 2, w->widget[widget].top + 1, list, start, end, WP(w, replaceveh_d).sel_engine[i], i == 0, selected_group);

   344

   345

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

   346

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

   347

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

   355

				}

   356

			}

   357

   358

		} break;   // end of paint

   359

   360

		case WE_CLICK: {

   361

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

   362

				case RVW_WIDGET_TRAIN_ENGINEWAGON_TOGGLE:

   363

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

   364

					WP(w, replaceveh_d).update_left = true;

   365

					WP(w, replaceveh_d).init_lists  = true;

   366

					SetWindowDirty(w);

   367

					break;

   368

   369

				case RVW_WIDGET_TRAIN_RAILTYPE_DROPDOWN: /* Railtype selection dropdown menu */

   370

					ShowDropDownMenu(w, _rail_types_list, _railtype_selected_in_replace_gui, RVW_WIDGET_TRAIN_RAILTYPE_DROPDOWN, 0, ~GetPlayer(_local_player)->avail_railtypes);

   371

					break;

   372

   373

				case RVW_WIDGET_TRAIN_WAGONREMOVE_TOGGLE: /* toggle renew_keep_length */

   374

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

   375

					break;

   376

   377

				case RVW_WIDGET_START_REPLACE: { /* Start replacing */

   378

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

   379

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

   380

					DoCommandP(0, 3 + (WP(w, replaceveh_d).sel_group << 16) , veh_from + (veh_to << 16), NULL, CMD_SET_AUTOREPLACE);

   381

				} break;

   382

   383

				case RVW_WIDGET_STOP_REPLACE: { /* Stop replacing */

   384

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

   385

					DoCommandP(0, 3 + (WP(w, replaceveh_d).sel_group << 16), veh_from + (INVALID_ENGINE << 16), NULL, CMD_SET_AUTOREPLACE);

   386

				} break;

   387

   388

				case RVW_WIDGET_LEFT_MATRIX:

   389

				case RVW_WIDGET_RIGHT_MATRIX: {

   390

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

   391

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

   392

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

   393

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

   394

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

   395

   396

					if (i < click_scroll_cap) {

   397

						i += click_scroll_pos;

   398

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

   399

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

   400

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

   401

						if (click_side == 0) {

   402

							WP(w, replaceveh_d).update_right = true;

   403

							WP(w, replaceveh_d).init_lists   = true;

   404

						}

   405

						SetWindowDirty(w);

   406

						}

   407

					break;

   408

					}

   409

			}

   410

			break;

   411

		}

   412

   413

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

   414

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

   415

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

   416

			_railtype_selected_in_replace_gui = temp;

   417

			/* Reset scrollbar positions */

   418

			w->vscroll.pos  = 0;

   419

			w->vscroll2.pos = 0;

   420

			/* Rebuild the lists */

   421

			WP(w, replaceveh_d).update_left  = true;

   422

			WP(w, replaceveh_d).update_right = true;

   423

			WP(w, replaceveh_d).init_lists   = true;

   424

			SetWindowDirty(w);

   425

		} break;

   426

   427

		case WE_RESIZE:

   428

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

   429

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

   430

   431

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

   432

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

   433

			break;

   434

   435

		case WE_INVALIDATE_DATA:

   436

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

   437

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

   438

			SetWindowDirty(w);

   439

			break;

   440

   441

		case WE_DESTROY:

   442

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

   443

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

   444

		break;

   445

	}

   446

}

   447

   448

static const Widget _replace_rail_vehicle_widgets[] = {

   449

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

   450

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

   451

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

   452

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

   453

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

   454

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

   455

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

   456

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

   457

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

   458

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

   459

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

   460

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

   461

// train specific stuff

   462

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

   463

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

   464

{   WWT_DROPDOWN,     RESIZE_TB,    14,   154,   289,   240,   251, 0x0,            STR_REPLACE_HELP_RAILTYPE},

   465

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

   466

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

   467

// end of train specific stuff

   468

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

   469

{   WIDGETS_END},

   470

};

   471

   472

static const Widget _replace_road_vehicle_widgets[] = {

   473

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

   474

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

   475

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

   476

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

   477

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

   478

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

   479

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

   480

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

   481

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

   482

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

   483

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

   484

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

   485

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

   486

{   WIDGETS_END},

   487

};