1

/* $Id$ */

     2

     3

/** @file autoreplace_gui.cpp GUI for autoreplace handling. */

     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

#include "engine_func.h"

    23

#include "engine_base.h"

    24

#include "window_gui.h"

    25

#include "engine_gui.h"

    26

    27

#include "table/sprites.h"

    28

#include "table/strings.h"

    29

    30

void DrawEngineList(VehicleType type, int x, int r, int y, const GUIEngineList *eng_list, uint16 min, uint16 max, EngineID selected_id, int count_location, GroupID selected_group);

    31

    32

static const StringID _rail_types_list[] = {

    33

	STR_RAIL_VEHICLES,

    34

	STR_ELRAIL_VEHICLES,

    35

	STR_MONORAIL_VEHICLES,

    36

	STR_MAGLEV_VEHICLES,

    37

	INVALID_STRING_ID

    38

};

    39

    40

enum ReplaceVehicleWindowWidgets {

    41

	RVW_WIDGET_LEFT_MATRIX = 3,

    42

	RVW_WIDGET_LEFT_SCROLLBAR,

    43

	RVW_WIDGET_RIGHT_MATRIX,

    44

	RVW_WIDGET_RIGHT_SCROLLBAR,

    45

	RVW_WIDGET_LEFT_DETAILS,

    46

	RVW_WIDGET_RIGHT_DETAILS,

    47

    48

	/* Button row */

    49

	RVW_WIDGET_START_REPLACE,

    50

	RVW_WIDGET_INFO_TAB,

    51

	RVW_WIDGET_STOP_REPLACE,

    52

	RVW_WIDGET_RESIZE,

    53

    54

	/* Train only widgets */

    55

	RVW_WIDGET_TRAIN_ENGINEWAGON_TOGGLE,

    56

	RVW_WIDGET_TRAIN_FLUFF_LEFT,

    57

	RVW_WIDGET_TRAIN_RAILTYPE_DROPDOWN,

    58

	RVW_WIDGET_TRAIN_FLUFF_RIGHT,

    59

	RVW_WIDGET_TRAIN_WAGONREMOVE_TOGGLE,

    60

};

    61

    62

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

    63

{

    64

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

    65

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

    66

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

    67

    68

	return r;

    69

}

    70

    71

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

    72

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

    73

 * @param id_g The group the engine belongs to

    74

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

    75

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

    76

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

    77

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

    78

 */

    79

void InvalidateAutoreplaceWindow(EngineID e, GroupID id_g)

    80

{

    81

	Player *p = GetPlayer(_local_player);

    82

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

    83

    84

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

    85

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

    86

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

    87

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

    88

		InvalidateWindowData(WC_REPLACE_VEHICLE, GetEngine(e)->type, true);

    89

	}

    90

}

    91

    92

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

    93

 * @param type The type of engine

    94

 */

    95

void AddRemoveEngineFromAutoreplaceAndBuildWindows(VehicleType type)

    96

{

    97

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

    98

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

    99

}

   100

   101

/**

   102

 * Window for the autoreplacing of vehicles.

   103

 */

   104

class ReplaceVehicleWindow : public Window {

   105

	byte sel_index[2];

   106

	EngineID sel_engine[2];

   107

	uint16 count[2];

   108

	bool wagon_btnstate; ///< true means engine is selected

   109

	GUIEngineList list[2];

   110

	bool update_left;

   111

	bool update_right;

   112

	bool init_lists;

   113

	GroupID sel_group;

   114

	static RailType sel_railtype;

   115

   116

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

   117

	 * @param e The EngineID

   118

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

   119

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

   120

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

   121

	 */

   122

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

   123

	{

   124

		const RailVehicleInfo *rvi = RailVehInfo(e);

   125

   126

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

   127

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

   128

   129

		if (draw_left && show_engines) {

   130

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

   131

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

   132

		}

   133

		return true;

   134

	}

   135

   136

   137

	/** Generate a list

   138

	 * @param w Window, that contains the list

   139

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

   140

	 */

   141

	void GenerateReplaceVehList(Window *w, bool draw_left)

   142

	{

   143

		EngineID selected_engine = INVALID_ENGINE;

   144

		VehicleType type = (VehicleType)this->window_number;

   145

		byte i = draw_left ? 0 : 1;

   146

   147

		GUIEngineList *list = &this->list[i];

   148

		list->Clear();

   149

   150

		const Engine *e;

   151

		FOR_ALL_ENGINES_OF_TYPE(e, type) {

   152

			EngineID eid = e->index;

   153

			if (type == VEH_TRAIN && !GenerateReplaceRailList(eid, draw_left, this->wagon_btnstate)) continue; // special rules for trains

   154

   155

			if (draw_left) {

   156

				const GroupID selected_group = this->sel_group;

   157

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

   158

   159

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

   160

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

   161

			} else {

   162

				if (!CheckAutoreplaceValidity(this->sel_engine[0], eid, _local_player)) continue;

   163

			}

   164

   165

			*list->Append() = eid;

   166

			if (eid == this->sel_engine[i]) selected_engine = eid; // The selected engine is still in the list

   167

		}

   168

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

   169

		EngList_Sort(list, &EngineNumberSorter);

   170

	}

   171

   172

	/** Generate the lists */

   173

	void GenerateLists()

   174

	{

   175

		EngineID e = this->sel_engine[0];

   176

   177

		if (this->update_left == true) {

   178

			/* We need to rebuild the left list */

   179

			GenerateReplaceVehList(this, true);

   180

			SetVScrollCount(this, this->list[0].Length());

   181

			if (this->init_lists && this->sel_engine[0] == INVALID_ENGINE && this->list[0].Length() != 0) {

   182

				this->sel_engine[0] = this->list[0][0];

   183

			}

   184

		}

   185

   186

		if (this->update_right || e != this->sel_engine[0]) {

   187

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

   188

			if (this->sel_engine[0] == INVALID_ENGINE) {

   189

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

   190

				this->list[1].Clear();

   191

				this->sel_engine[1] = INVALID_ENGINE;

   192

			} else {

   193

				GenerateReplaceVehList(this, false);

   194

				SetVScroll2Count(this, this->list[1].Length());

   195

				if (this->init_lists && this->sel_engine[1] == INVALID_ENGINE && this->list[1].Length() != 0) {

   196

					this->sel_engine[1] = this->list[1][0];

   197

				}

   198

			}

   199

		}

   200

		/* Reset the flags about needed updates */

   201

		this->update_left  = false;

   202

		this->update_right = false;

   203

		this->init_lists   = false;

   204

	}

   205

   206

public:

   207

	ReplaceVehicleWindow(const WindowDesc *desc, VehicleType vehicletype, GroupID id_g) : Window(desc, vehicletype)

   208

	{

   209

		this->wagon_btnstate = true; // start with locomotives (all other vehicles will not read this bool)

   210

		this->update_left   = true;

   211

		this->update_right  = true;

   212

		this->init_lists    = true;

   213

		this->sel_engine[0] = INVALID_ENGINE;

   214

		this->sel_engine[1] = INVALID_ENGINE;

   215

   216

		this->resize.step_height = GetVehicleListHeight(vehicletype);

   217

		this->vscroll.cap = this->resize.step_height == 14 ? 8 : 4;

   218

   219

		Widget *widget = this->widget;

   220

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

   221

   222

		if (vehicletype == VEH_TRAIN) {

   223

			this->wagon_btnstate = true;

   224

			/* The train window is bigger so we will move some of the widgets to fit the new size.

   225

			* We will start by moving the resize button to the lower right corner.                 */

   226

			widget[RVW_WIDGET_RESIZE].top         = widget[RVW_WIDGET_TRAIN_ENGINEWAGON_TOGGLE].top;

   227

			widget[RVW_WIDGET_RESIZE].bottom      = widget[RVW_WIDGET_TRAIN_ENGINEWAGON_TOGGLE].bottom;

   228

			widget[RVW_WIDGET_STOP_REPLACE].right = widget[RVW_WIDGET_RESIZE].right;

   229

   230

			/* The detail panel is one line taller for trains so we will move some of the widgets one line (10 pixels) down. */

   231

			widget[RVW_WIDGET_LEFT_DETAILS].bottom  += 10;

   232

			widget[RVW_WIDGET_RIGHT_DETAILS].bottom += 10;

   233

			for (int i = RVW_WIDGET_START_REPLACE; i < RVW_WIDGET_RESIZE; i++) {

   234

				widget[i].top    += 10;

   235

				widget[i].bottom += 10;

   236

			}

   237

		} else {

   238

			/* Since it's not a train we will hide the train only widgets. */

   239

			this->SetWidgetsHiddenState(true,

   240

									RVW_WIDGET_TRAIN_ENGINEWAGON_TOGGLE,

   241

									RVW_WIDGET_TRAIN_FLUFF_LEFT,

   242

									RVW_WIDGET_TRAIN_RAILTYPE_DROPDOWN,

   243

									RVW_WIDGET_TRAIN_FLUFF_RIGHT,

   244

									RVW_WIDGET_TRAIN_WAGONREMOVE_TOGGLE,

   245

									WIDGET_LIST_END);

   246

		}

   247

   248

		ResizeWindow(this, 0, this->resize.step_height * this->vscroll.cap);

   249

   250

		/* Set the minimum window size to the current window size */

   251

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

   252

		this->resize.height = this->height;

   253

   254

		this->caption_color = _local_player;

   255

		this->sel_group = id_g;

   256

		this->vscroll2.cap = this->vscroll.cap;   // these two are always the same

   257

   258

		this->FindWindowPlacementAndResize(desc);

   259

	}

   260

   261

	virtual void OnPaint()

   262

	{

   263

		static const StringID _vehicle_type_names[] = {

   264

			STR_019F_TRAIN,

   265

			STR_019C_ROAD_VEHICLE,

   266

			STR_019E_SHIP,

   267

			STR_019D_AIRCRAFT

   268

		};

   269

   270

		if (this->update_left || this->update_right) this->GenerateLists();

   271

   272

		Player *p = GetPlayer(_local_player);

   273

		EngineID selected_id[2];

   274

		const GroupID selected_group = this->sel_group;

   275

   276

		selected_id[0] = this->sel_engine[0];

   277

		selected_id[1] = this->sel_engine[1];

   278

   279

		/* Disable the "Start Replacing" button if:

   280

		 *    Either list is empty

   281

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

   282

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

   283

		this->SetWidgetDisabledState(RVW_WIDGET_START_REPLACE,

   284

										selected_id[0] == INVALID_ENGINE ||

   285

										selected_id[1] == INVALID_ENGINE ||

   286

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

   287

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

   288

   289

		/* Disable the "Stop Replacing" button if:

   290

		 *   The left list (existing vehicle) is empty

   291

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

   292

		this->SetWidgetDisabledState(RVW_WIDGET_STOP_REPLACE,

   293

										selected_id[0] == INVALID_ENGINE ||

   294

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

   295

   296

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

   297

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

   298

   299

		if (this->window_number == VEH_TRAIN) {

   300

			/* set on/off for renew_keep_length */

   301

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

   302

   303

			/* set wagon/engine button */

   304

			SetDParam(2, this->wagon_btnstate ? STR_ENGINES : STR_WAGONS);

   305

   306

			/* sets the colour of that art thing */

   307

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

   308

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

   309

		}

   310

   311

		if (this->window_number == VEH_TRAIN) {

   312

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

   313

			this->widget[RVW_WIDGET_TRAIN_RAILTYPE_DROPDOWN].data = _rail_types_list[sel_railtype];

   314

		}

   315

   316

		this->DrawWidgets();

   317

   318

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

   319

		if (selected_id[0] != INVALID_ENGINE) {

   320

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

   321

				SetDParam(0, STR_NOT_REPLACING);

   322

			} else {

   323

				SetDParam(0, STR_ENGINE_NAME);

   324

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

   325

			}

   326

		} else {

   327

			SetDParam(0, STR_NOT_REPLACING_VEHICLE_SELECTED);

   328

		}

   329

   330

		DrawStringTruncated(this->widget[RVW_WIDGET_INFO_TAB].left + 6, this->widget[RVW_WIDGET_INFO_TAB].top + 1, STR_02BD, TC_BLACK, this->GetWidgetWidth(RVW_WIDGET_INFO_TAB) - 12);

   331

   332

		/* Draw the lists */

   333

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

   334

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

   335

			GUIEngineList *list = &this->list[i]; // which list to draw

   336

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

   337

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

   338

   339

			/* Do the actual drawing */

   340

			DrawEngineList((VehicleType)this->window_number, this->widget[widget].left + 2, this->widget[widget].right, this->widget[widget].top + 1, list, start, end, this->sel_engine[i], i == 0 ? this->widget[RVW_WIDGET_LEFT_MATRIX].right - 2 : 0, selected_group);

   341

   342

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

   343

			if (this->sel_engine[i] != INVALID_ENGINE) {

   344

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

   345

				int text_end = DrawVehiclePurchaseInfo(wi->left + 2, wi->top + 1, wi->right - wi->left - 2, this->sel_engine[i]);

   346

   347

				if (text_end > wi->bottom) {

   348

					this->SetDirty();

   349

					ResizeWindowForWidget(this, i == 0 ? RVW_WIDGET_LEFT_DETAILS : RVW_WIDGET_RIGHT_DETAILS, 0, text_end - wi->bottom);

   350

					this->SetDirty();

   351

				}

   352

			}

   353

		}

   354

	}

   355

   356

	virtual void OnClick(Point pt, int widget)

   357

	{

   358

		switch (widget) {

   359

			case RVW_WIDGET_TRAIN_ENGINEWAGON_TOGGLE:

   360

				this->wagon_btnstate = !(this->wagon_btnstate);

   361

				this->update_left = true;

   362

				this->init_lists  = true;

   363

				this->SetDirty();

   364

				break;

   365

   366

			case RVW_WIDGET_TRAIN_RAILTYPE_DROPDOWN: /* Railtype selection dropdown menu */

   367

				ShowDropDownMenu(this, _rail_types_list, sel_railtype, RVW_WIDGET_TRAIN_RAILTYPE_DROPDOWN, 0, ~GetPlayer(_local_player)->avail_railtypes);

   368

				break;

   369

   370

			case RVW_WIDGET_TRAIN_WAGONREMOVE_TOGGLE: /* toggle renew_keep_length */

   371

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

   372

				break;

   373

   374

			case RVW_WIDGET_START_REPLACE: { /* Start replacing */

   375

				EngineID veh_from = this->sel_engine[0];

   376

				EngineID veh_to = this->sel_engine[1];

   377

				DoCommandP(0, 3 + (this->sel_group << 16) , veh_from + (veh_to << 16), NULL, CMD_SET_AUTOREPLACE);

   378

				this->SetDirty();

   379

			} break;

   380

   381

			case RVW_WIDGET_STOP_REPLACE: { /* Stop replacing */

   382

				EngineID veh_from = this->sel_engine[0];

   383

				DoCommandP(0, 3 + (this->sel_group << 16), veh_from + (INVALID_ENGINE << 16), NULL, CMD_SET_AUTOREPLACE);

   384

				this->SetDirty();

   385

			} break;

   386

   387

			case RVW_WIDGET_LEFT_MATRIX:

   388

			case RVW_WIDGET_RIGHT_MATRIX: {

   389

				uint i = (pt.y - 14) / this->resize.step_height;

   390

				uint16 click_scroll_pos = widget == RVW_WIDGET_LEFT_MATRIX ? this->vscroll.pos : this->vscroll2.pos;

   391

				uint16 click_scroll_cap = widget == RVW_WIDGET_LEFT_MATRIX ? this->vscroll.cap : this->vscroll2.cap;

   392

				byte click_side         = widget == RVW_WIDGET_LEFT_MATRIX ? 0 : 1;

   393

				size_t engine_count     = this->list[click_side].Length();

   394

   395

				if (i < click_scroll_cap) {

   396

					i += click_scroll_pos;

   397

					EngineID e = engine_count > i ? this->list[click_side][i] : INVALID_ENGINE;

   398

					if (e == this->sel_engine[click_side]) break; // we clicked the one we already selected

   399

					this->sel_engine[click_side] = e;

   400

					if (click_side == 0) {

   401

						this->update_right = true;

   402

						this->init_lists   = true;

   403

					}

   404

					this->SetDirty();

   405

					}

   406

				break;

   407

				}

   408

		}

   409

	}

   410

   411

	virtual void OnDropdownSelect(int widget, int index)

   412

	{

   413

		RailType temp = (RailType)index;

   414

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

   415

		sel_railtype = temp;

   416

		/* Reset scrollbar positions */

   417

		this->vscroll.pos  = 0;

   418

		this->vscroll2.pos = 0;

   419

		/* Rebuild the lists */

   420

		this->update_left  = true;

   421

		this->update_right = true;

   422

		this->init_lists   = true;

   423

		this->SetDirty();

   424

	}

   425

   426

	virtual void OnResize(Point new_size, Point delta) {

   427

		this->vscroll.cap  += delta.y / (int)this->resize.step_height;

   428

		this->vscroll2.cap += delta.y / (int)this->resize.step_height;

   429

   430

		Widget *widget = this->widget;

   431

   432

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

   433

   434

		if (delta.x != 0) {

   435

			/* We changed the width of the window so we have to resize the lists.

   436

				* Because ResizeButtons() makes each widget the same size it can't be used on the lists

   437

				* because then the lists would have the same size as the scrollbars.

   438

				* Instead we use it on the detail panels.

   439

				* Afterwards we use the new location of the detail panels (the middle of the window)

   440

				* to place the lists.

   441

				* This way the lists will have equal size while keeping the width of the scrollbars unchanged. */

   442

			ResizeButtons(this, RVW_WIDGET_LEFT_DETAILS, RVW_WIDGET_RIGHT_DETAILS);

   443

			widget[RVW_WIDGET_RIGHT_MATRIX].left    = widget[RVW_WIDGET_RIGHT_DETAILS].left;

   444

			widget[RVW_WIDGET_LEFT_SCROLLBAR].right = widget[RVW_WIDGET_LEFT_DETAILS].right;

   445

			widget[RVW_WIDGET_LEFT_SCROLLBAR].left  = widget[RVW_WIDGET_LEFT_SCROLLBAR].right - 11;

   446

			widget[RVW_WIDGET_LEFT_MATRIX].right    = widget[RVW_WIDGET_LEFT_SCROLLBAR].left - 1;

   447

		}

   448

	}

   449

   450

	virtual void OnInvalidateData(int data)

   451

	{

   452

		if (data != 0) {

   453

			this->update_left = true;

   454

		} else {

   455

			this->update_right = true;

   456

		}

   457

	}

   458

};

   459

   460

static const Widget _replace_vehicle_widgets[] = {

   461

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

   462

{    WWT_CAPTION,  RESIZE_RIGHT,  COLOUR_GREY,    11,   443,     0,    13, STR_REPLACE_VEHICLES_WHITE,      STR_018C_WINDOW_TITLE_DRAG_THIS},

   463

{  WWT_STICKYBOX,     RESIZE_LR,  COLOUR_GREY,   444,   455,     0,    13, STR_NULL,                        STR_STICKY_BUTTON},

   464

   465

{     WWT_MATRIX, RESIZE_BOTTOM,  COLOUR_GREY,     0,   215,    14,    13, 0x1,                             STR_REPLACE_HELP_LEFT_ARRAY},

   466

{  WWT_SCROLLBAR, RESIZE_BOTTOM,  COLOUR_GREY,   216,   227,    14,    13, STR_NULL,                        STR_0190_SCROLL_BAR_SCROLLS_LIST},

   467

{     WWT_MATRIX,    RESIZE_LRB,  COLOUR_GREY,   228,   443,    14,    13, 0x1,                             STR_REPLACE_HELP_RIGHT_ARRAY},

   468

{ WWT_SCROLL2BAR,    RESIZE_LRB,  COLOUR_GREY,   444,   455,    14,    13, STR_NULL,                        STR_0190_SCROLL_BAR_SCROLLS_LIST},

   469

{      WWT_PANEL,     RESIZE_TB,  COLOUR_GREY,     0,   227,    14,   105, 0x0,                             STR_NULL},

   470

{      WWT_PANEL,    RESIZE_RTB,  COLOUR_GREY,   228,   455,    14,   105, 0x0,                             STR_NULL},

   471

   472

{ WWT_PUSHTXTBTN,     RESIZE_TB,  COLOUR_GREY,     0,   138,   106,   117, STR_REPLACE_VEHICLES_START,      STR_REPLACE_HELP_START_BUTTON},

   473

{      WWT_PANEL,    RESIZE_RTB,  COLOUR_GREY,   139,   305,   106,   117, 0x0,                             STR_REPLACE_HELP_REPLACE_INFO_TAB},

   474

{ WWT_PUSHTXTBTN,   RESIZE_LRTB,  COLOUR_GREY,   306,   443,   106,   117, STR_REPLACE_VEHICLES_STOP,       STR_REPLACE_HELP_STOP_BUTTON},

   475

{  WWT_RESIZEBOX,   RESIZE_LRTB,  COLOUR_GREY,   444,   455,   106,   117, STR_NULL,                        STR_RESIZE_BUTTON},

   476

   477

{ WWT_PUSHTXTBTN,     RESIZE_TB,  COLOUR_GREY,     0,   138,   128,   139, STR_REPLACE_ENGINE_WAGON_SELECT, STR_REPLACE_ENGINE_WAGON_SELECT_HELP},

   478

{      WWT_PANEL,     RESIZE_TB,  COLOUR_GREY,   139,   153,   128,   139, 0x0,                             STR_NULL},

   479

{   WWT_DROPDOWN,    RESIZE_RTB,  COLOUR_GREY,   154,   289,   128,   139, 0x0,                             STR_REPLACE_HELP_RAILTYPE},

   480

{      WWT_PANEL,   RESIZE_LRTB,  COLOUR_GREY,   290,   305,   128,   139, 0x0,                             STR_NULL},

   481

{ WWT_PUSHTXTBTN,   RESIZE_LRTB,  COLOUR_GREY,   306,   443,   128,   139, STR_REPLACE_REMOVE_WAGON,        STR_REPLACE_REMOVE_WAGON_HELP},

   482

{   WIDGETS_END},

   483

};

   484

   485

static const WindowDesc _replace_rail_vehicle_desc = {

   486

	WDP_AUTO, WDP_AUTO, 456, 140, 456, 140,

   487

	WC_REPLACE_VEHICLE, WC_NONE,

   488

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