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

    25

#include "table/sprites.h"

    26

#include "table/strings.h"

    27

    28

struct replaceveh_d {

    29

	byte sel_index[2];

    30

	EngineID sel_engine[2];

    31

	uint16 count[2];

    32

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

    33

	EngineList list[2];

    34

	bool update_left;

    35

	bool update_right;

    36

	bool init_lists;

    37

	GroupID sel_group;

    38

};

    39

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(replaceveh_d));

    40

    41

static RailType _railtype_selected_in_replace_gui;

    42

    43

static bool _rebuild_left_list;

    44

static bool _rebuild_right_list;

    45

    46

static const StringID _rail_types_list[] = {

    47

	STR_RAIL_VEHICLES,

    48

	STR_ELRAIL_VEHICLES,

    49

	STR_MONORAIL_VEHICLES,

    50

	STR_MAGLEV_VEHICLES,

    51

	INVALID_STRING_ID

    52

};

    53

    54

enum ReplaceVehicleWindowWidgets {

    55

	RVW_WIDGET_LEFT_MATRIX = 3,

    56

	RVW_WIDGET_LEFT_SCROLLBAR,

    57

	RVW_WIDGET_RIGHT_MATRIX,

    58

	RVW_WIDGET_RIGHT_SCROLLBAR,

    59

	RVW_WIDGET_LEFT_DETAILS,

    60

	RVW_WIDGET_RIGHT_DETAILS,

    61

    62

	/* Button row */

    63

	RVW_WIDGET_START_REPLACE,

    64

	RVW_WIDGET_INFO_TAB,

    65

	RVW_WIDGET_STOP_REPLACE,

    66

	RVW_WIDGET_RESIZE,

    67

    68

	/* Train only widgets */

    69

	RVW_WIDGET_TRAIN_ENGINEWAGON_TOGGLE,

    70

	RVW_WIDGET_TRAIN_FLUFF_LEFT,

    71

	RVW_WIDGET_TRAIN_RAILTYPE_DROPDOWN,

    72

	RVW_WIDGET_TRAIN_FLUFF_RIGHT,

    73

	RVW_WIDGET_TRAIN_WAGONREMOVE_TOGGLE,

    74

};

    75

    76

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

    77

{

    78

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

    79

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

    80

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

    81

    82

	return r;

    83

}

    84

    85

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

    86

void InitializeVehiclesGuiList()

    87

{

    88

	_railtype_selected_in_replace_gui = RAILTYPE_RAIL;

    89

}

    90

    91

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

    92

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

    93

 * @param id_g The group the engine belongs to

    94

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

    95

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

    96

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

    97

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

    98

 */

    99

void InvalidateAutoreplaceWindow(EngineID e, GroupID id_g)

   100

{

   101

	Player *p = GetPlayer(_local_player);

   102

	VehicleType type = GetEngine(e)->type;

   103

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

   104

   105

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

   106

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

   107

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

   108

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

   109

		_rebuild_left_list = true;

   110

	} else {

   111

		_rebuild_left_list = false;

   112

	}

   113

	_rebuild_right_list = false;

   114

	InvalidateWindowData(WC_REPLACE_VEHICLE, type);

   115

}

   116

   117

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

   118

 * @param type The type of engine

   119

 */

   120

void AddRemoveEngineFromAutoreplaceAndBuildWindows(VehicleType type)

   121

{

   122

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

   123

	_rebuild_right_list = true;

   124

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

   125

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

   126

}

   127

   128

/** Get the default cargo type for an engine

   129

 * @param engine the EngineID to get the cargo for

   130

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

   131

 */

   132

static CargoID EngineCargo(EngineID engine)

   133

{

   134

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

   135

   136

	switch (GetEngine(engine)->type) {

   137

		default: NOT_REACHED();

   138

		case VEH_TRAIN:

   139

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

   140

			return RailVehInfo(engine)->cargo_type;

   141

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

   142

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

   143

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

   144

	}

   145

}

   146

   147

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

   148

 * @param e The EngineID

   149

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

   150

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

   151

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

   152

 */

   153

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

   154

{

   155

	const RailVehicleInfo *rvi = RailVehInfo(e);

   156

   157

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

   158

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

   159

   160

	if (draw_left && show_engines) {

   161

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

   162

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

   163

	} else {

   164

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

   165

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

   166

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

   167

	}

   168

	return true;

   169

}

   170

   171

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

   172

 * @param engine_a one of the EngineIDs

   173

 * @param engine_b the other EngineID

   174

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

   175

 */

   176

static bool EnginesGotCargoInCommon(EngineID engine_a, EngineID engine_b)

   177

{

   178

	CargoID a = EngineCargo(engine_a);

   179

	CargoID b = EngineCargo(engine_b);

   180

   181

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

   182

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

   183

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

   184

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

   185

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

   186

	return false;

   187

}

   188

   189

/** Generate a list

   190

 * @param w Window, that contains the list

   191

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

   192

 */

   193

static void GenerateReplaceVehList(Window *w, bool draw_left)

   194

{

   195

	EngineID selected_engine = INVALID_ENGINE;

   196

	VehicleType type = (VehicleType)w->window_number;

   197

	byte i = draw_left ? 0 : 1;

   198

   199

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

   200

	list->clear();

   201

   202

	const Engine *e;

   203

	FOR_ALL_ENGINES_OF_TYPE(e, type) {

   204

		EngineID eid = e->index;

   205

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

   206

   207

		if (draw_left) {

   208

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

   209

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

   210

   211

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

   212

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

   213

		} else {

   214

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

   215

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

   216

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

   217

   218

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

   219

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

   220

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

   221

		}

   222

   223

		list->push_back(eid);

   224

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

   225

	}

   226

	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)

   227

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

   228

}

   229

   230

/** Generate the lists

   231

 * @param w Window containing the lists

   232

 */

   233

static void GenerateLists(Window *w)

   234

{

   235

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

   236

   237

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

   238

		/* We need to rebuild the left list */

   239

		GenerateReplaceVehList(w, true);

   240

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

   241

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

   242

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

   243

		}

   244

	}

   245

   246

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

   247

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

   248

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

   249

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

   250

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

   251

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

   252

		} else {

   253

			GenerateReplaceVehList(w, false);

   254

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

   255

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

   256

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

   257

			}

   258

		}

   259

	}

   260

	/* Reset the flags about needed updates */

   261

	WP(w, replaceveh_d).update_left  = false;

   262

	WP(w, replaceveh_d).update_right = false;

   263

	WP(w, replaceveh_d).init_lists   = false;

   264

}

   265

   266

   267

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

   268

   269

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

   270

{

   271

	/* Strings for the pulldown menu */

   272

	static const StringID _vehicle_type_names[] = {

   273

		STR_019F_TRAIN,

   274

		STR_019C_ROAD_VEHICLE,

   275

		STR_019E_SHIP,

   276

		STR_019D_AIRCRAFT

   277

	};

   278

   279

	switch (e->event) {

   280

		case WE_CREATE:

   281

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

   282

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

   283

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

   284

			WP(w, replaceveh_d).update_left   = true;

   285

			WP(w, replaceveh_d).update_right  = true;

   286

			WP(w, replaceveh_d).init_lists    = true;

   287

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

   288

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

   289

			break;

   290

   291

		case WE_PAINT: {

   292

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

   293

   294

			Player *p = GetPlayer(_local_player);

   295

			EngineID selected_id[2];

   296

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

   297

   298

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

   299

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

   300

   301

			/* Disable the "Start Replacing" button if:

   302

			 *    Either list is empty

   303

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

   304

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

   305

			w->SetWidgetDisabledState(RVW_WIDGET_START_REPLACE,

   306

										 selected_id[0] == INVALID_ENGINE ||

   307

										 selected_id[1] == INVALID_ENGINE ||

   308

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

   309

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

   310

   311

			/* Disable the "Stop Replacing" button if:

   312

			 *   The left list (existing vehicle) is empty

   313

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

   314

			w->SetWidgetDisabledState(RVW_WIDGET_STOP_REPLACE,

   315

										 selected_id[0] == INVALID_ENGINE ||

   316

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

   317

   318

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

   319

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

   320

   321

			if (w->window_number == VEH_TRAIN) {

   322

				/* set on/off for renew_keep_length */

   323

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

   324

   325

				/* set wagon/engine button */

   326

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

   327

   328

				/* sets the colour of that art thing */

   329

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

   330

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

   331

			}

   332

   333

			if (w->window_number == VEH_TRAIN) {

   334

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

   335

				RailType railtype = _railtype_selected_in_replace_gui;

   336

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

   337

			}

   338

   339

			DrawWindowWidgets(w);

   340

   341

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

   342

			if (selected_id[0] != INVALID_ENGINE) {

   343

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

   344

					SetDParam(0, STR_NOT_REPLACING);

   345

				} else {

   346

					SetDParam(0, STR_ENGINE_NAME);

   347

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

   348

				}

   349

			} else {

   350

				SetDParam(0, STR_NOT_REPLACING_VEHICLE_SELECTED);

   351

			}

   352

   353

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

   354

   355

			/* Draw the lists */

   356

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

   357

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

   358

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

   359

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

   360

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

   361

   362

				/* Do the actual drawing */

   363

				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 ? w->widget[RVW_WIDGET_LEFT_MATRIX].right - 2 : 0, selected_group);

   364

   365

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

   366

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

   367

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

   368

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

   369

   370

					if (text_end > wi->bottom) {

   371

						w->SetDirty();

   372

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

   373

						w->SetDirty();

   374

					}

   375

				}

   376

			}

   377

   378

		} break;   // end of paint

   379

   380

		case WE_CLICK: {

   381

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

   382

				case RVW_WIDGET_TRAIN_ENGINEWAGON_TOGGLE:

   383

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

   384

					WP(w, replaceveh_d).update_left = true;

   385

					WP(w, replaceveh_d).init_lists  = true;

   386

					w->SetDirty();

   387

					break;

   388

   389

				case RVW_WIDGET_TRAIN_RAILTYPE_DROPDOWN: /* Railtype selection dropdown menu */

   390

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

   391

					break;

   392

   393

				case RVW_WIDGET_TRAIN_WAGONREMOVE_TOGGLE: /* toggle renew_keep_length */

   394

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

   395

					break;

   396

   397

				case RVW_WIDGET_START_REPLACE: { /* Start replacing */

   398

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

   399

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

   400

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

   401

				} break;

   402

   403

				case RVW_WIDGET_STOP_REPLACE: { /* Stop replacing */

   404

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

   405

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

   406

				} break;

   407

   408

				case RVW_WIDGET_LEFT_MATRIX:

   409

				case RVW_WIDGET_RIGHT_MATRIX: {

   410

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

   411

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

   412

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

   413

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

   414

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

   415

   416

					if (i < click_scroll_cap) {

   417

						i += click_scroll_pos;

   418

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

   419

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

   420

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

   421

						if (click_side == 0) {

   422

							WP(w, replaceveh_d).update_right = true;

   423

							WP(w, replaceveh_d).init_lists   = true;

   424

						}

   425

						w->SetDirty();

   426

						}

   427

					break;

   428

					}

   429

			}

   430

			break;

   431

		}

   432

   433

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

   434

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

   435

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

   436

			_railtype_selected_in_replace_gui = temp;

   437

			/* Reset scrollbar positions */

   438

			w->vscroll.pos  = 0;

   439

			w->vscroll2.pos = 0;

   440

			/* Rebuild the lists */

   441

			WP(w, replaceveh_d).update_left  = true;

   442

			WP(w, replaceveh_d).update_right = true;

   443

			WP(w, replaceveh_d).init_lists   = true;

   444

			w->SetDirty();

   445

		} break;

   446

   447

		case WE_RESIZE:

   448

		{

   449

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

   450

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

   451

   452

			Widget *widget = w->widget;

   453

   454

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

   455

   456

			if (e->we.sizing.diff.x != 0) {

   457

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

   458

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

   459

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

   460

				 * Instead we use it on the detail panels.

   461

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

   462

				 * to place the lists.

   463

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

   464

				ResizeButtons(w, RVW_WIDGET_LEFT_DETAILS, RVW_WIDGET_RIGHT_DETAILS);

   465

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

   466

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

   467

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

   468

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

   469

			}

   470

		} break;

   471

   472

		case WE_INVALIDATE_DATA:

   473

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

   474

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

   475

			w->SetDirty();

   476

			break;

   477

   478

		case WE_DESTROY:

   479

			WP(w, replaceveh_d).list[0].~EngineList(); // call destructor explicitly

   480

			WP(w, replaceveh_d).list[1].~EngineList();

   481

		break;

   482

	}

   483

}

   484