1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "debug.h"

     6

#include "functions.h"

     7

#include "table/sprites.h"

     8

#include "table/strings.h"

     9

#include "window.h"

    10

#include "gui.h"

    11

#include "command.h"

    12

#include "variables.h"

    13

#include "vehicle_gui.h"

    14

#include "newgrf_engine.h"

    15

    16

    17

static RailType _railtype_selected_in_replace_gui;

    18

    19

static const StringID _rail_types_list[] = {

    20

	STR_RAIL_VEHICLES,

    21

	STR_ELRAIL_VEHICLES,

    22

	STR_MONORAIL_VEHICLES,

    23

	STR_MAGLEV_VEHICLES,

    24

	INVALID_STRING_ID

    25

};

    26

    27

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

    28

void InitializeVehiclesGuiList(void)

    29

{

    30

	_railtype_selected_in_replace_gui = RAILTYPE_RAIL;

    31

}

    32

    33

// this define is to match engine.c, but engine.c keeps it to itself

    34

// ENGINE_AVAILABLE is used in ReplaceVehicleWndProc

    35

#define ENGINE_AVAILABLE ((e->flags & 1 && HASBIT(info->climates, _opt.landscape)) || HASBIT(e->player_avail, _local_player))

    36

    37

/*  if show_outdated is selected, it do not sort psudo engines properly but it draws all engines

    38

 * if used compined with show_cars set to false, it will work as intended. Replace window do it like that

    39

 *  this was a big hack even before show_outdated was added. Stupid newgrf :p

    40

 */

    41

static void train_engine_drawing_loop(int *x, int *y, int *pos, int *sel, EngineID *selected_id, RailType railtype,

    42

	uint8 lines_drawn, bool is_engine, bool show_cars, bool show_outdated, bool show_compatible)

    43

{

    44

	EngineID j;

    45

	byte colour;

    46

	const Player *p = GetPlayer(_local_player);

    47

    48

	for (j = 0; j < NUM_TRAIN_ENGINES; j++) {

    49

		EngineID i = GetRailVehAtPosition(j);

    50

		const Engine *e = GetEngine(i);

    51

		const RailVehicleInfo *rvi = RailVehInfo(i);

    52

		const EngineInfo *info = EngInfo(i);

    53

    54

		if (!EngineHasReplacementForPlayer(p, i) && p->num_engines[i] == 0 && show_outdated) continue;

    55

    56

		if ((rvi->power == 0 && !show_cars) || (rvi->power != 0 && show_cars))  // show wagons or engines (works since wagons do not have power)

    57

			continue;

    58

    59

		if (*sel == 0) *selected_id = j;

    60

    61

    62

		colour = *sel == 0 ? 0xC : 0x10;

    63

		if (!(ENGINE_AVAILABLE && show_outdated && RailVehInfo(i)->power && IsCompatibleRail(rvi->railtype, railtype))) {

    64

			if ((!IsCompatibleRail(rvi->railtype, railtype) && show_compatible)

    65

				|| (rvi->railtype != railtype && !show_compatible)

    66

				|| (rvi->railveh_type != RAILVEH_WAGON) != is_engine ||

    67

				!HASBIT(e->player_avail, _local_player))

    68

				continue;

    69

#if 0

    70

		} else {

    71

			// TODO find a nice red colour for vehicles being replaced

    72

			if ( _autoreplace_array[i] != i )

    73

				colour = *sel == 0 ? 0x44 : 0x45;

    74

#endif

    75

		}

    76

    77

		if (IS_INT_INSIDE(--*pos, -lines_drawn, 0)) {

    78

			DrawString(*x + 59, *y + 2, GetCustomEngineName(i),

    79

				colour);

    80

			// show_outdated is true only for left side, which is where we show old replacements

    81

			DrawTrainEngine(*x + 29, *y + 6, i, (p->num_engines[i] == 0 && show_outdated) ?

    82

				PALETTE_CRASH : GetEnginePalette(i, _local_player));

    83

			if ( show_outdated ) {

    84

				SetDParam(0, p->num_engines[i]);

    85

				DrawStringRightAligned(213, *y+5, STR_TINY_BLACK, 0);

    86

			}

    87

			*y += 14;

    88

		}

    89

		--*sel;

    90

	}

    91

}

    92

    93

    94

static void SetupScrollStuffForReplaceWindow(Window *w)

    95

{

    96

	EngineID selected_id[2] = { INVALID_ENGINE, INVALID_ENGINE };

    97

	const Player* p = GetPlayer(_local_player);

    98

	uint sel[2];

    99

	uint count = 0;

   100

	uint count2 = 0;

   101

	EngineID i;

   102

   103

	sel[0] = WP(w,replaceveh_d).sel_index[0];

   104

	sel[1] = WP(w,replaceveh_d).sel_index[1];

   105

   106

	switch (WP(w,replaceveh_d).vehicletype) {

   107

		case VEH_Train: {

   108

			RailType railtype = _railtype_selected_in_replace_gui;

   109

   110

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

   111

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

   112

   113

			for (i = 0; i < NUM_TRAIN_ENGINES; i++) {

   114

				EngineID eid = GetRailVehAtPosition(i);

   115

				const Engine* e = GetEngine(eid);

   116

				const RailVehicleInfo *rvi = RailVehInfo(eid);

   117

				const EngineInfo* info = EngInfo(eid);

   118

   119

				// left window contains compatible engines while right window only contains engines of the selected type

   120

				if (ENGINE_AVAILABLE &&

   121

						(rvi->power != 0) == (WP(w, replaceveh_d).wagon_btnstate != 0)) {

   122

					if (IsCompatibleRail(rvi->railtype, railtype) && (p->num_engines[eid] > 0 || EngineHasReplacementForPlayer(p, eid))) {

   123

						if (sel[0] == count) selected_id[0] = eid;

   124

						count++;

   125

					}

   126

					if (rvi->railtype == railtype && HASBIT(e->player_avail, _local_player)) {

   127

						if (sel[1] == count2) selected_id[1] = eid;

   128

						count2++;

   129

					}

   130

				}

   131

			}

   132

			break;

   133

		}

   134

   135

		case VEH_Road: {

   136

			for (i = ROAD_ENGINES_INDEX; i < ROAD_ENGINES_INDEX + NUM_ROAD_ENGINES; i++) {

   137

				if (p->num_engines[i] > 0 || EngineHasReplacementForPlayer(p, i)) {

   138

					if (sel[0] == count) selected_id[0] = i;

   139

					count++;

   140

				}

   141

			}

   142

   143

			if (selected_id[0] != INVALID_ENGINE) { // only draw right array if we have anything in the left one

   144

				CargoID cargo = RoadVehInfo(selected_id[0])->cargo_type;

   145

   146

				for (i = ROAD_ENGINES_INDEX; i < ROAD_ENGINES_INDEX + NUM_ROAD_ENGINES; i++) {

   147

					if (cargo == RoadVehInfo(i)->cargo_type &&

   148

							HASBIT(GetEngine(i)->player_avail, _local_player)) {

   149

						if (sel[1] == count2) selected_id[1] = i;

   150

						count2++;

   151

					}

   152

				}

   153

			}

   154

			break;

   155

		}

   156

   157

		case VEH_Ship: {

   158

			for (i = SHIP_ENGINES_INDEX; i < SHIP_ENGINES_INDEX + NUM_SHIP_ENGINES; i++) {

   159

				if (p->num_engines[i] > 0 || EngineHasReplacementForPlayer(p, i)) {

   160

					if (sel[0] == count) selected_id[0] = i;

   161

					count++;

   162

				}

   163

			}

   164

   165

			if (selected_id[0] != INVALID_ENGINE) {

   166

				const ShipVehicleInfo* svi = ShipVehInfo(selected_id[0]);

   167

				CargoID cargo = svi->cargo_type;

   168

				bool refittable = svi->refittable;

   169

   170

				for (i = SHIP_ENGINES_INDEX; i < SHIP_ENGINES_INDEX + NUM_SHIP_ENGINES; i++) {

   171

					if (HASBIT(GetEngine(i)->player_avail, _local_player) && (

   172

								ShipVehInfo(i)->cargo_type == cargo ||

   173

								ShipVehInfo(i)->refittable && refittable

   174

							)) {

   175

						if (sel[1] == count2) selected_id[1] = i;

   176

						count2++;

   177

					}

   178

				}

   179

			}

   180

			break;

   181

		}

   182

   183

		case VEH_Aircraft: {

   184

			for (i = AIRCRAFT_ENGINES_INDEX; i < AIRCRAFT_ENGINES_INDEX + NUM_AIRCRAFT_ENGINES; i++) {

   185

				if (p->num_engines[i] > 0 || EngineHasReplacementForPlayer(p, i)) {

   186

					if (sel[0] == count) selected_id[0] = i;

   187

					count++;

   188

				}

   189

			}

   190

   191

			if (selected_id[0] != INVALID_ENGINE) {

   192

				byte subtype = AircraftVehInfo(selected_id[0])->subtype;

   193

   194

				for (i = AIRCRAFT_ENGINES_INDEX; i < AIRCRAFT_ENGINES_INDEX + NUM_AIRCRAFT_ENGINES; i++) {

   195

					if (HASBIT(GetEngine(i)->player_avail, _local_player) &&

   196

							(subtype & AIR_CTOL) == (AircraftVehInfo(i)->subtype & AIR_CTOL)) {

   197

						if (sel[1] == count2) selected_id[1] = i;

   198

						count2++;

   199

					}

   200

				}

   201

			}

   202

			break;

   203

		}

   204

	}

   205

	// sets up the number of items in each list

   206

	SetVScrollCount(w, count);

   207

	SetVScroll2Count(w, count2);

   208

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

   209

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

   210

   211

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

   212

	WP(w,replaceveh_d).count[1] = count2;

   213

	return;

   214

}

   215

   216

   217

static void DrawEngineArrayInReplaceWindow(Window *w, int x, int y, int x2, int y2, int pos, int pos2,

   218

	int sel1, int sel2, EngineID selected_id1, EngineID selected_id2)

   219

{

   220

	int sel[2];

   221

	EngineID selected_id[2];

   222

	const Player *p = GetPlayer(_local_player);

   223

   224

	sel[0] = sel1;

   225

	sel[1] = sel2;

   226

   227

	selected_id[0] = selected_id1;

   228

	selected_id[1] = selected_id2;

   229

   230

	switch (WP(w,replaceveh_d).vehicletype) {

   231

		case VEH_Train: {

   232

			RailType railtype = _railtype_selected_in_replace_gui;

   233

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

   234

			/* draw sorting criteria string */

   235

   236

			/* Ensure that custom engines which substituted wagons

   237

			 * are sorted correctly.

   238

			 * XXX - DO NOT EVER DO THIS EVER AGAIN! GRRR hacking in wagons as

   239

			 * engines to get more types.. Stays here until we have our own format

   240

			 * then it is exit!!! */

   241

			if (WP(w,replaceveh_d).wagon_btnstate) {

   242

				train_engine_drawing_loop(&x, &y, &pos, &sel[0], &selected_id[0], railtype, w->vscroll.cap, true, false, true, true); // True engines

   243

				train_engine_drawing_loop(&x2, &y2, &pos2, &sel[1], &selected_id[1], railtype, w->vscroll.cap, true, false, false, false); // True engines

   244

				train_engine_drawing_loop(&x2, &y2, &pos2, &sel[1], &selected_id[1], railtype, w->vscroll.cap, false, false, false, false); // Feeble wagons

   245

			} else {

   246

				train_engine_drawing_loop(&x, &y, &pos, &sel[0], &selected_id[0], railtype, w->vscroll.cap, false, true, true, true);

   247

				train_engine_drawing_loop(&x2, &y2, &pos2, &sel[1], &selected_id[1], railtype, w->vscroll.cap, false, true, false, true);

   248

			}

   249

			break;

   250

		}

   251

   252

		case VEH_Road: {

   253

			int num = NUM_ROAD_ENGINES;

   254

			const Engine* e = GetEngine(ROAD_ENGINES_INDEX);

   255

			EngineID engine_id = ROAD_ENGINES_INDEX;

   256

   257

			do {

   258

				if (p->num_engines[engine_id] > 0 || EngineHasReplacementForPlayer(p, engine_id)) {

   259

					if (IS_INT_INSIDE(--pos, -w->vscroll.cap, 0)) {

   260

						DrawString(x+59, y+2, GetCustomEngineName(engine_id), sel[0]==0 ? 0xC : 0x10);

   261

						DrawRoadVehEngine(x+29, y+6, engine_id, p->num_engines[engine_id] > 0 ? GetEnginePalette(engine_id, _local_player) : PALETTE_CRASH);

   262

						SetDParam(0, p->num_engines[engine_id]);

   263

						DrawStringRightAligned(213, y+5, STR_TINY_BLACK, 0);

   264

						y += 14;

   265

					}

   266

				sel[0]--;

   267

				}

   268

   269

				if (selected_id[0] != INVALID_ENGINE) {

   270

					byte cargo = RoadVehInfo(selected_id[0])->cargo_type;

   271

   272

					if (RoadVehInfo(engine_id)->cargo_type == cargo && HASBIT(e->player_avail, _local_player)) {

   273

						if (IS_INT_INSIDE(--pos2, -w->vscroll.cap, 0) && RoadVehInfo(engine_id)->cargo_type == cargo) {

   274

							DrawString(x2+59, y2+2, GetCustomEngineName(engine_id), sel[1]==0 ? 0xC : 0x10);

   275

							DrawRoadVehEngine(x2+29, y2+6, engine_id, GetEnginePalette(engine_id, _local_player));

   276

							y2 += 14;

   277

						}

   278

						sel[1]--;

   279

					}

   280

				}

   281

			} while (++engine_id, ++e,--num);

   282

			break;

   283

		}

   284

   285

		case VEH_Ship: {

   286

			int num = NUM_SHIP_ENGINES;

   287

			const Engine* e = GetEngine(SHIP_ENGINES_INDEX);

   288

			EngineID engine_id = SHIP_ENGINES_INDEX;

   289

   290

			do {

   291

				if (p->num_engines[engine_id] > 0 || EngineHasReplacementForPlayer(p, engine_id)) {

   292

					if (IS_INT_INSIDE(--pos, -w->vscroll.cap, 0)) {

   293

						DrawString(x+75, y+7, GetCustomEngineName(engine_id), sel[0]==0 ? 0xC : 0x10);

   294

						DrawShipEngine(x+35, y+10, engine_id, p->num_engines[engine_id] > 0 ? GetEnginePalette(engine_id, _local_player) : PALETTE_CRASH);

   295

						SetDParam(0, p->num_engines[engine_id]);

   296

						DrawStringRightAligned(213, y+15, STR_TINY_BLACK, 0);

   297

						y += 24;

   298

					}

   299

					sel[0]--;

   300

				}

   301

   302

				if (selected_id[0] != INVALID_ENGINE) {

   303

					CargoID cargo = ShipVehInfo(selected_id[0])->cargo_type;

   304

					bool refittable = ShipVehInfo(selected_id[0])->refittable;

   305

   306

					if (HASBIT(e->player_avail, _local_player) && ( cargo == ShipVehInfo(engine_id)->cargo_type || refittable & ShipVehInfo(engine_id)->refittable)) {

   307

						if (IS_INT_INSIDE(--pos2, -w->vscroll.cap, 0)) {

   308

							DrawString(x2+75, y2+7, GetCustomEngineName(engine_id), sel[1]==0 ? 0xC : 0x10);

   309

							DrawShipEngine(x2+35, y2+10, engine_id, GetEnginePalette(engine_id, _local_player));

   310

							y2 += 24;

   311

						}

   312

						sel[1]--;

   313

					}

   314

				}

   315

			} while (++engine_id, ++e, --num);

   316

			break;

   317

		}   //end of ship

   318

   319

		case VEH_Aircraft: {

   320

			int num = NUM_AIRCRAFT_ENGINES;

   321

			const Engine* e = GetEngine(AIRCRAFT_ENGINES_INDEX);

   322

			EngineID engine_id = AIRCRAFT_ENGINES_INDEX;

   323

   324

			do {

   325

				if (p->num_engines[engine_id] > 0 || EngineHasReplacementForPlayer(p, engine_id)) {

   326

					if (sel[0] == 0) selected_id[0] = engine_id;

   327

					if (IS_INT_INSIDE(--pos, -w->vscroll.cap, 0)) {

   328

						DrawString(x+62, y+7, GetCustomEngineName(engine_id), sel[0]==0 ? 0xC : 0x10);

   329

						DrawAircraftEngine(x+29, y+10, engine_id, p->num_engines[engine_id] > 0 ? GetEnginePalette(engine_id, _local_player) : PALETTE_CRASH);

   330

						SetDParam(0, p->num_engines[engine_id]);

   331

						DrawStringRightAligned(213, y+15, STR_TINY_BLACK, 0);

   332

						y += 24;

   333

					}

   334

					sel[0]--;

   335

				}

   336

   337

				if (selected_id[0] != INVALID_ENGINE) {

   338

					byte subtype = AircraftVehInfo(selected_id[0])->subtype;

   339

   340

					if ((subtype & AIR_CTOL) == (AircraftVehInfo(engine_id)->subtype & AIR_CTOL) &&

   341

							HASBIT(e->player_avail, _local_player)) {

   342

						if (sel[1] == 0) selected_id[1] = engine_id;

   343

						if (IS_INT_INSIDE(--pos2, -w->vscroll.cap, 0)) {

   344

							DrawString(x2+62, y2+7, GetCustomEngineName(engine_id), sel[1]==0 ? 0xC : 0x10);

   345

							DrawAircraftEngine(x2+29, y2+10, engine_id, GetEnginePalette(engine_id, _local_player));

   346

							y2 += 24;

   347

						}

   348

						sel[1]--;

   349

					}

   350

				}

   351

			} while (++engine_id, ++e,--num);

   352

			break;

   353

		}   // end of aircraft

   354

	}

   355

}

   356

   357

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

   358

{

   359

	static const StringID _vehicle_type_names[] = {

   360

		STR_019F_TRAIN,

   361

		STR_019C_ROAD_VEHICLE,

   362

		STR_019E_SHIP,

   363

		STR_019D_AIRCRAFT

   364

	};

   365

   366

	switch (e->event) {

   367

		case WE_PAINT: {

   368

				Player *p = GetPlayer(_local_player);

   369

				int pos = w->vscroll.pos;

   370

				EngineID selected_id[2] = { INVALID_ENGINE, INVALID_ENGINE };

   371

				int x = 1;

   372

				int y = 15;

   373

				int pos2 = w->vscroll2.pos;

   374

				int x2 = 1 + 228;

   375

				int y2 = 15;

   376

				int sel[2];

   377

				byte i;

   378

				sel[0] = WP(w,replaceveh_d).sel_index[0];

   379

				sel[1] = WP(w,replaceveh_d).sel_index[1];

   380

   381

				SetupScrollStuffForReplaceWindow(w);

   382

   383

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

   384

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

   385

   386

				// Disable the "Start Replacing" button if:

   387

				//    Either list is empty

   388

				// or Both lists have the same vehicle selected

   389

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

   390

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

   391

				SetWindowWidgetDisabledState(w, 4,

   392

						selected_id[0] == INVALID_ENGINE ||

   393

						selected_id[1] == INVALID_ENGINE ||

   394

						selected_id[0] == selected_id[1] ||

   395

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

   396

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

   397

   398

				// Disable the "Stop Replacing" button if:

   399

				//    The left list (existing vehicle) is empty

   400

				// or The selected vehicle has no replacement set up

   401

				SetWindowWidgetDisabledState(w, 6,

   402

						selected_id[0] == INVALID_ENGINE ||

   403

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

   404

   405

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

   406

				SetDParam(0, _vehicle_type_names[WP(w, replaceveh_d).vehicletype - VEH_Train]);

   407

   408

				if (WP(w, replaceveh_d).vehicletype == VEH_Train) {

   409

					// set on/off for renew_keep_length

   410

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

   411

   412

					// set wagon/engine button

   413

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

   414

				}

   415

   416

				DrawWindowWidgets(w);

   417

   418

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

   419

				if (selected_id[0] != INVALID_ENGINE) {

   420

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

   421

						SetDParam(0, STR_NOT_REPLACING);

   422

					} else {

   423

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

   424

					}

   425

				} else {

   426

					SetDParam(0, STR_NOT_REPLACING_VEHICLE_SELECTED);

   427

				}

   428

   429

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

   430

   431

				/* now we draw the two arrays according to what we just counted */

   432

				DrawEngineArrayInReplaceWindow(w, x, y, x2, y2, pos, pos2, sel[0], sel[1], selected_id[0], selected_id[1]);

   433

   434

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

   435

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

   436

				/* now we draw the info about the vehicles we selected */

   437

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

   438

					if (selected_id[i] != INVALID_ENGINE) {

   439

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

   440

						DrawVehiclePurchaseInfo(wi->left + 2 , wi->top + 1, wi->right - wi->left - 2, selected_id[i]);

   441

					}

   442

				}

   443

			} break;   // end of paint

   444

   445

		case WE_CLICK: {

   446

			// these 3 variables is used if any of the lists is clicked

   447

			uint16 click_scroll_pos = w->vscroll2.pos;

   448

			uint16 click_scroll_cap = w->vscroll2.cap;

   449

			byte click_side = 1;

   450

   451

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

   452

				case 12:

   453

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

   454

					SetWindowDirty(w);

   455

					break;

   456

   457

				case 14:

   458

				case 15: /* Railtype selection dropdown menu */

   459

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

   460

					break;

   461

   462

				case 17: /* toggle renew_keep_length */

   463

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

   464

					break;

   465

   466

				case 4: { /* Start replacing */

   467

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

   468

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

   469

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

   470

					break;

   471

				}

   472

   473

				case 6: { /* Stop replacing */

   474

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

   475

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

   476

					break;

   477

				}

   478

   479

				case 7:

   480

					// sets up that the left one was clicked. The default values are for the right one (9)

   481

					// this way, the code for 9 handles both sides

   482

					click_scroll_pos = w->vscroll.pos;

   483

					click_scroll_cap = w->vscroll.cap;

   484

					click_side = 0;

   485

					/* FALL THROUGH */

   486

   487

				case 9: {

   488

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

   489

					if (i < click_scroll_cap) {

   490

						WP(w,replaceveh_d).sel_index[click_side] = i + click_scroll_pos;

   491

						SetWindowDirty(w);

   492

					}

   493

					break;

   494

				}

   495

			}