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

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

    29

    30

static const StringID _rail_types_list[] = {

    31

	STR_RAIL_VEHICLES,

    32

	STR_ELRAIL_VEHICLES,

    33

	STR_MONORAIL_VEHICLES,

    34

	STR_MAGLEV_VEHICLES,

    35

	INVALID_STRING_ID

    36

};

    37

    38

enum ReplaceVehicleWindowWidgets {

    39

	RVW_WIDGET_LEFT_MATRIX = 3,

    40

	RVW_WIDGET_LEFT_SCROLLBAR,

    41

	RVW_WIDGET_RIGHT_MATRIX,

    42

	RVW_WIDGET_RIGHT_SCROLLBAR,

    43

	RVW_WIDGET_LEFT_DETAILS,

    44

	RVW_WIDGET_RIGHT_DETAILS,

    45

    46

	/* Button row */

    47

	RVW_WIDGET_START_REPLACE,

    48

	RVW_WIDGET_INFO_TAB,

    49

	RVW_WIDGET_STOP_REPLACE,

    50

	RVW_WIDGET_RESIZE,

    51

    52

	/* Train only widgets */

    53

	RVW_WIDGET_TRAIN_ENGINEWAGON_TOGGLE,

    54

	RVW_WIDGET_TRAIN_FLUFF_LEFT,

    55

	RVW_WIDGET_TRAIN_RAILTYPE_DROPDOWN,

    56

	RVW_WIDGET_TRAIN_FLUFF_RIGHT,

    57

	RVW_WIDGET_TRAIN_WAGONREMOVE_TOGGLE,

    58

};

    59

    60

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

    61

{

    62

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

    63

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

    64

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

    65

    66

	return r;

    67

}

    68

    69

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

    70

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

    71

 * @param id_g The group the engine belongs to

    72

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

    73

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

    74

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

    75

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

    76

 */

    77

void InvalidateAutoreplaceWindow(EngineID e, GroupID id_g)

    78

{

    79

	Player *p = GetPlayer(_local_player);

    80

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

    81

    82

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

    83

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

    84

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

    85

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

    86

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

    87

	}

    88

}

    89

    90

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

    91

 * @param type The type of engine

    92

 */

    93

void AddRemoveEngineFromAutoreplaceAndBuildWindows(VehicleType type)

    94

{

    95

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

    96

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

    97

}

    98

    99

/** Get the default cargo type for an engine

   100

 * @param engine the EngineID to get the cargo for

   101

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

   102

 */

   103

static CargoID EngineCargo(EngineID engine)

   104

{

   105

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

   106

   107

	switch (GetEngine(engine)->type) {

   108

		default: NOT_REACHED();

   109

		case VEH_TRAIN:

   110

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

   111

			return RailVehInfo(engine)->cargo_type;

   112

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

   113

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

   114

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

   115

	}

   116

}

   117

   118

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

   119

 * @param engine_a one of the EngineIDs

   120

 * @param engine_b the other EngineID

   121

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

   122

 */

   123

static bool EnginesGotCargoInCommon(EngineID engine_a, EngineID engine_b)

   124

{

   125

	CargoID a = EngineCargo(engine_a);

   126

	CargoID b = EngineCargo(engine_b);

   127

   128

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

   129

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

   130

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

   131

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

   132

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

   133

	return false;

   134

}

   135

   136

/**

   137

 * Window for the autoreplacing of vehicles.

   138

 */

   139

class ReplaceVehicleWindow : public Window {

   140

	byte sel_index[2];

   141

	EngineID sel_engine[2];

   142

	uint16 count[2];

   143

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

   144

	EngineList list[2];

   145

	bool update_left;

   146

	bool update_right;

   147

	bool init_lists;

   148

	GroupID sel_group;

   149

	static RailType sel_railtype;

   150

   151

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

   152

	 * @param e The EngineID

   153

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

   154

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

   155

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

   156

	 */

   157

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

   158

	{

   159

		const RailVehicleInfo *rvi = RailVehInfo(e);

   160

   161

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

   162

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

   163

   164

		if (draw_left && show_engines) {

   165

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

   166

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

   167

		} else {

   168

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

   169

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

   170

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

   171

		}

   172

		return true;

   173

	}

   174

   175

   176

	/** Generate a list

   177

	 * @param w Window, that contains the list

   178

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

   179

	 */

   180

	void GenerateReplaceVehList(Window *w, bool draw_left)

   181

	{

   182

		EngineID selected_engine = INVALID_ENGINE;

   183

		VehicleType type = (VehicleType)this->window_number;

   184

		byte i = draw_left ? 0 : 1;

   185

   186

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

   187

		list->clear();

   188

   189

		const Engine *e;

   190

		FOR_ALL_ENGINES_OF_TYPE(e, type) {

   191

			EngineID eid = e->index;

   192

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

   193

   194

			if (draw_left) {

   195

				const GroupID selected_group = this->sel_group;

   196

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

   197

   198

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

   199

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

   200

			} else {

   201

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

   202

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

   203

				if (!EnginesGotCargoInCommon(eid, this->sel_engine[0])) continue; // the engines needs to be able to carry the same cargo

   204

   205

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

   206

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

   207

				if (eid == this->sel_engine[0]) continue; // we can't replace an engine into itself (that would be autorenew)

   208

			}

   209

   210

			list->push_back(eid);

   211

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

   212

		}

   213

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

   214

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

   215

	}

   216

   217

	/** Generate the lists */

   218

	void GenerateLists()

   219

	{

   220

		EngineID e = this->sel_engine[0];

   221

   222

		if (this->update_left == true) {

   223

			/* We need to rebuild the left list */

   224

			GenerateReplaceVehList(this, true);

   225

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

   226

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

   227

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

   228

			}

   229

		}

   230

   231

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

   232

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

   233

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

   234

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

   235

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

   236

				this->sel_engine[1] = INVALID_ENGINE;

   237

			} else {

   238

				GenerateReplaceVehList(this, false);

   239

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

   240

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

   241

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

   242

				}

   243

			}

   244

		}

   245

		/* Reset the flags about needed updates */

   246

		this->update_left  = false;

   247

		this->update_right = false;

   248

		this->init_lists   = false;

   249

	}

   250

   251

public:

   252

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

   253

	{

   254

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

   255

		new (&this->list[0]) EngineList();

   256

		new (&this->list[1]) EngineList();

   257

		this->update_left   = true;

   258

		this->update_right  = true;

   259

		this->init_lists    = true;

   260

		this->sel_engine[0] = INVALID_ENGINE;

   261

		this->sel_engine[1] = INVALID_ENGINE;

   262

   263

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

   264

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

   265

   266

		Widget *widget = this->widget;

   267

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

   268

   269

		if (vehicletype == VEH_TRAIN) {

   270

			this->wagon_btnstate = true;

   271

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

   272

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

   273

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

   274

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

   275

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

   276

   277

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

   278

			widget[RVW_WIDGET_LEFT_DETAILS].bottom  += 10;

   279

			widget[RVW_WIDGET_RIGHT_DETAILS].bottom += 10;

   280

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

   281

				widget[i].top    += 10;

   282

				widget[i].bottom += 10;

   283

			}

   284

		} else {

   285

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

   286

			this->SetWidgetsHiddenState(true,

   287

									RVW_WIDGET_TRAIN_ENGINEWAGON_TOGGLE,

   288

									RVW_WIDGET_TRAIN_FLUFF_LEFT,

   289

									RVW_WIDGET_TRAIN_RAILTYPE_DROPDOWN,

   290

									RVW_WIDGET_TRAIN_FLUFF_RIGHT,

   291

									RVW_WIDGET_TRAIN_WAGONREMOVE_TOGGLE,

   292

									WIDGET_LIST_END);

   293

		}

   294

   295

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

   296

   297

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

   298

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

   299

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

   300

   301

		this->caption_color = _local_player;

   302

		this->sel_group = id_g;

   303

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

   304

   305

		this->FindWindowPlacementAndResize(desc);

   306

	}

   307

   308

	virtual void OnPaint()

   309

	{

   310

		static const StringID _vehicle_type_names[] = {

   311

			STR_019F_TRAIN,

   312

			STR_019C_ROAD_VEHICLE,

   313

			STR_019E_SHIP,

   314

			STR_019D_AIRCRAFT

   315

		};

   316

   317

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

   318

   319

		Player *p = GetPlayer(_local_player);

   320

		EngineID selected_id[2];

   321

		const GroupID selected_group = this->sel_group;

   322

   323

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

   324

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

   325

   326

		/* Disable the "Start Replacing" button if:

   327

		 *    Either list is empty

   328

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

   329

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

   330

		this->SetWidgetDisabledState(RVW_WIDGET_START_REPLACE,

   331

										selected_id[0] == INVALID_ENGINE ||

   332

										selected_id[1] == INVALID_ENGINE ||

   333

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

   334

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

   335

   336

		/* Disable the "Stop Replacing" button if:

   337

		 *   The left list (existing vehicle) is empty

   338

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

   339

		this->SetWidgetDisabledState(RVW_WIDGET_STOP_REPLACE,

   340

										selected_id[0] == INVALID_ENGINE ||

   341

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

   342

   343

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

   344

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

   345

   346

		if (this->window_number == VEH_TRAIN) {

   347

			/* set on/off for renew_keep_length */

   348

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

   349

   350

			/* set wagon/engine button */

   351

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

   352

   353

			/* sets the colour of that art thing */

   354

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

   355

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

   356

		}

   357

   358

		if (this->window_number == VEH_TRAIN) {

   359

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

   360

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

   361

		}

   362

   364

   365

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

   366

		if (selected_id[0] != INVALID_ENGINE) {

   367

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

   368

				SetDParam(0, STR_NOT_REPLACING);

   369

			} else {

   370

				SetDParam(0, STR_ENGINE_NAME);

   371

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

   372

			}

   373

		} else {

   374

			SetDParam(0, STR_NOT_REPLACING_VEHICLE_SELECTED);

   375

		}

   376

   377

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

   378

   379

		/* Draw the lists */

   380

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

   381

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

   382

			EngineList list = this->list[i]; // which list to draw

   383

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

   384

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

   385

   386

			/* Do the actual drawing */

   387

			DrawEngineList((VehicleType)this->window_number, this->widget[widget].left + 2, 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);

   388

   389

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

   390

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

   391

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

   392

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

   393

   394

				if (text_end > wi->bottom) {

   395

					this->SetDirty();

   396

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

   397

					this->SetDirty();

   398

				}

   399

			}

   400

		}

   401

	}

   402

   403

	virtual void OnClick(Point pt, int widget)

   404

	{

   405

		switch (widget) {

   406

			case RVW_WIDGET_TRAIN_ENGINEWAGON_TOGGLE:

   407

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

   408

				this->update_left = true;

   409

				this->init_lists  = true;

   410

				this->SetDirty();

   411

				break;

   412

   413

			case RVW_WIDGET_TRAIN_RAILTYPE_DROPDOWN: /* Railtype selection dropdown menu */

   414

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

   415

				break;

   416

   417

			case RVW_WIDGET_TRAIN_WAGONREMOVE_TOGGLE: /* toggle renew_keep_length */

   418

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

   419

				break;

   420

   421

			case RVW_WIDGET_START_REPLACE: { /* Start replacing */

   422

				EngineID veh_from = this->sel_engine[0];

   423

				EngineID veh_to = this->sel_engine[1];

   424

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

   425

			} break;

   426

   427

			case RVW_WIDGET_STOP_REPLACE: { /* Stop replacing */

   428

				EngineID veh_from = this->sel_engine[0];

   429

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

   430

			} break;

   431

   432

			case RVW_WIDGET_LEFT_MATRIX:

   433

			case RVW_WIDGET_RIGHT_MATRIX: {

   434

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

   435

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

   436

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

   437

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

   438

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

   439

   440

				if (i < click_scroll_cap) {

   441

					i += click_scroll_pos;

   442

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

   443

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

   444

					this->sel_engine[click_side] = e;

   445

					if (click_side == 0) {

   446

						this->update_right = true;

   447

						this->init_lists   = true;

   448

					}

   449

					this->SetDirty();

   450

					}

   451

				break;

   452

				}

   453

		}

   454

	}

   455

   456

	virtual void OnDropdownSelect(int widget, int index)

   457

	{

   458

		RailType temp = (RailType)index;

   459

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

   460

		sel_railtype = temp;

   461

		/* Reset scrollbar positions */

   462

		this->vscroll.pos  = 0;

   463

		this->vscroll2.pos = 0;

   464

		/* Rebuild the lists */

   465

		this->update_left  = true;

   466

		this->update_right = true;

   467

		this->init_lists   = true;

   468

		this->SetDirty();

   469

	}

   470

   471

	virtual void OnResize(Point new_size, Point delta) {

   472

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

   473

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

   474

   475

		Widget *widget = this->widget;

   476

   477

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

   478

   479

		if (delta.x != 0) {

   480

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

   481

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

   482

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

   483

				* Instead we use it on the detail panels.

   484

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

   485

				* to place the lists.

   486

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

   487

			ResizeButtons(this, RVW_WIDGET_LEFT_DETAILS, RVW_WIDGET_RIGHT_DETAILS);

   488

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

   489

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

   490

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