1

/* $Id$ */

     2

     3

/** @file road_gui.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "table/sprites.h"

     8

#include "table/strings.h"

     9

#include "functions.h"

    10

#include "map.h"

    11

#include "tile.h"

    12

#include "window.h"

    13

#include "gui.h"

    14

#include "viewport.h"

    15

#include "gfx.h"

    16

#include "sound.h"

    17

#include "command.h"

    18

#include "variables.h"

    19

#include "road.h"

    20

#include "road_cmd.h"

    21

#include "road_map.h"

    22

#include "station_map.h"

    23

//needed for catchments

    24

#include "station.h"

    25

    26

    27

static void ShowBusStationPicker();

    28

static void ShowTruckStationPicker();

    29

static void ShowRoadDepotPicker();

    30

    31

static bool _remove_button_clicked;

    32

    33

static byte _place_road_flag;

    34

    35

static RoadType _cur_roadtype;

    36

    37

static DiagDirection _road_depot_orientation;

    38

static DiagDirection _road_station_picker_orientation;

    39

    40

void CcPlaySound1D(bool success, TileIndex tile, uint32 p1, uint32 p2)

    41

{

    42

	if (success) SndPlayTileFx(SND_1F_SPLAT, tile);

    43

}

    44

    45

static void PlaceRoad_NE(TileIndex tile)

    46

{

    47

	_place_road_flag = (_tile_fract_coords.y >= 8) + 4;

    48

	VpStartPlaceSizing(tile, VPM_FIX_X, DDSP_PLACE_ROAD_NE);

    49

}

    50

    51

static void PlaceRoad_NW(TileIndex tile)

    52

{

    53

	_place_road_flag = (_tile_fract_coords.x >= 8) + 0;

    54

	VpStartPlaceSizing(tile, VPM_FIX_Y, DDSP_PLACE_ROAD_NW);

    55

}

    56

    57

static void PlaceRoad_Bridge(TileIndex tile)

    58

{

    59

	VpStartPlaceSizing(tile, VPM_X_OR_Y, DDSP_BUILD_BRIDGE);

    60

}

    61

    62

    63

void CcBuildRoadTunnel(bool success, TileIndex tile, uint32 p1, uint32 p2)

    64

{

    65

	if (success) {

    66

		SndPlayTileFx(SND_20_SPLAT_2, tile);

    67

		ResetObjectToPlace();

    68

	} else {

    69

		SetRedErrorSquare(_build_tunnel_endtile);

    70

	}

    71

}

    72

    73

/** Structure holding information per roadtype for several functions */

    74

struct RoadTypeInfo {

    75

	StringID err_build_road;        ///< Building a normal piece of road

    76

	StringID err_remove_road;       ///< Removing a normal piece of road

    77

	StringID err_depot;             ///< Building a depot

    78

	StringID err_build_station[2];  ///< Building a bus or truck station

    79

	StringID err_remove_station[2]; ///< Removing of a bus or truck station

    80

    81

	SpriteID cursor_nesw;           ///< Cursor for building NE and SW bits

    82

	SpriteID cursor_nwse;           ///< Cursor for building NW and SE bits

    83

};

    84

    85

/** What errors/cursors must be shown for several types of roads */

    86

static const RoadTypeInfo _road_type_infos[] = {

    87

	{

    88

		STR_1804_CAN_T_BUILD_ROAD_HERE,

    89

		STR_1805_CAN_T_REMOVE_ROAD_FROM,

    90

		STR_1807_CAN_T_BUILD_ROAD_VEHICLE,

    91

		{ STR_1808_CAN_T_BUILD_BUS_STATION, STR_1809_CAN_T_BUILD_TRUCK_STATION },

    92

		{ STR_CAN_T_REMOVE_BUS_STATION,     STR_CAN_T_REMOVE_TRUCK_STATION     },

    93

    94

		SPR_CURSOR_ROAD_NESW,

    95

		SPR_CURSOR_ROAD_NWSE,

    96

	},

    97

};

    98

    99

static void PlaceRoad_Tunnel(TileIndex tile)

   100

{

   101

	DoCommandP(tile, 0x200 | RoadTypeToRoadTypes(_cur_roadtype), 0, CcBuildRoadTunnel, CMD_BUILD_TUNNEL | CMD_AUTO | CMD_MSG(STR_5016_CAN_T_BUILD_TUNNEL_HERE));

   102

}

   103

   104

static void BuildRoadOutsideStation(TileIndex tile, DiagDirection direction)

   105

{

   106

	tile += TileOffsByDiagDir(direction);

   107

	// if there is a roadpiece just outside of the station entrance, build a connecting route

   108

	if (IsTileType(tile, MP_STREET) && GetRoadTileType(tile) == ROAD_TILE_NORMAL) {

   109

		if (GetRoadBits(tile, _cur_roadtype) != ROAD_NONE) {

   110

			DoCommandP(tile, _cur_roadtype << 4 | DiagDirToRoadBits(ReverseDiagDir(direction)), 0, NULL, CMD_BUILD_ROAD);

   111

		}

   112

	}

   113

}

   114

   115

void CcRoadDepot(bool success, TileIndex tile, uint32 p1, uint32 p2)

   116

{

   117

	if (success) {

   118

		DiagDirection dir = (DiagDirection)GB(p1, 0, 2);

   119

		SndPlayTileFx(SND_1F_SPLAT, tile);

   120

		ResetObjectToPlace();

   121

		BuildRoadOutsideStation(tile, dir);

   122

		/* For a drive-through road stop build connecting road for other entrance */

   123

		if (HASBIT(p2, 1)) BuildRoadOutsideStation(tile, ReverseDiagDir(dir));

   124

	}

   125

}

   126

   127

static void PlaceRoad_Depot(TileIndex tile)

   128

{

   129

	DoCommandP(tile, _cur_roadtype << 2 | _road_depot_orientation, 0, CcRoadDepot, CMD_BUILD_ROAD_DEPOT | CMD_AUTO | CMD_NO_WATER | CMD_MSG(_road_type_infos[_cur_roadtype].err_depot));

   130

}

   131

   132

static void PlaceRoadStop(TileIndex tile, uint32 p2, uint32 cmd)

   133

{

   134

	uint32 p1 = _road_station_picker_orientation;

   135

   136

	if (p1 >= DIAGDIR_END) {

   137

		SETBIT(p2, 1); // It's a drive-through stop

   138

		p1 -= DIAGDIR_END; // Adjust picker result to actual direction

   139

	}

   140

	DoCommandP(tile, p1, p2, CcRoadDepot, cmd);

   141

}

   142

   143

static void PlaceRoad_BusStation(TileIndex tile)

   144

{

   145

	if (_remove_button_clicked) {

   146

		DoCommandP(tile, 0, RoadStop::BUS, CcPlaySound1D, CMD_REMOVE_ROAD_STOP | CMD_MSG(_road_type_infos[_cur_roadtype].err_remove_station[RoadStop::BUS]));

   147

	} else {

   148

		PlaceRoadStop(tile, (_ctrl_pressed << 5) | RoadTypeToRoadTypes(_cur_roadtype) << 2 | RoadStop::BUS, CMD_BUILD_ROAD_STOP | CMD_AUTO | CMD_NO_WATER | CMD_MSG(_road_type_infos[_cur_roadtype].err_build_station[RoadStop::BUS]));

   149

	}

   150

}

   151

   152

static void PlaceRoad_TruckStation(TileIndex tile)

   153

{

   154

	if (_remove_button_clicked) {

   155

		DoCommandP(tile, 0, RoadStop::TRUCK, CcPlaySound1D, CMD_REMOVE_ROAD_STOP | CMD_MSG(_road_type_infos[_cur_roadtype].err_build_station[RoadStop::TRUCK]));

   156

	} else {

   157

		PlaceRoadStop(tile, (_ctrl_pressed << 5) | RoadTypeToRoadTypes(_cur_roadtype) << 2 | RoadStop::TRUCK, CMD_BUILD_ROAD_STOP | CMD_AUTO | CMD_NO_WATER | CMD_MSG(_road_type_infos[_cur_roadtype].err_build_station[RoadStop::TRUCK]));

   158

	}

   159

}

   160

   161

static void PlaceRoad_DemolishArea(TileIndex tile)

   162

{

   163

	VpStartPlaceSizing(tile, VPM_X_AND_Y, DDSP_DEMOLISH_AREA);

   164

}

   165

   166

   167

enum {

   168

	RTW_ROAD_X        =  3,

   169

	RTW_ROAD_Y        =  4,

   170

	RTW_DEMOLISH      =  5,

   171

	RTW_DEPOT         =  6,

   172

	RTW_BUS_STATION   =  7,

   173

	RTW_TRUCK_STATION =  8,

   174

	RTW_BUILD_BRIDGE  =  9,

   175

	RTW_BUILD_TUNNEL  = 10,

   176

	RTW_REMOVE        = 11

   177

};

   178

   179

   180

typedef void OnButtonClick(Window *w);

   181

   182

static void BuildRoadClick_NE(Window *w)

   183

{

   184

	HandlePlacePushButton(w, RTW_ROAD_X, _road_type_infos[_cur_roadtype].cursor_nesw, 1, PlaceRoad_NE);

   185

}

   186

   187

static void BuildRoadClick_NW(Window *w)

   188

{

   189

	HandlePlacePushButton(w, RTW_ROAD_Y, _road_type_infos[_cur_roadtype].cursor_nwse, 1, PlaceRoad_NW);

   190

}

   191

   192

   193

static void BuildRoadClick_Demolish(Window *w)

   194

{

   195

	HandlePlacePushButton(w, RTW_DEMOLISH, ANIMCURSOR_DEMOLISH, 1, PlaceRoad_DemolishArea);

   196

}

   197

   198

static void BuildRoadClick_Depot(Window *w)

   199

{

   200

	if (_game_mode == GM_EDITOR) return;

   201

	if (HandlePlacePushButton(w, RTW_DEPOT, SPR_CURSOR_ROAD_DEPOT, 1, PlaceRoad_Depot)) ShowRoadDepotPicker();

   202

}

   203

   204

static void BuildRoadClick_BusStation(Window *w)

   205

{

   206

	if (_game_mode == GM_EDITOR) return;

   207

	if (HandlePlacePushButton(w, RTW_BUS_STATION, SPR_CURSOR_BUS_STATION, 1, PlaceRoad_BusStation)) ShowBusStationPicker();

   208

}

   209

   210

static void BuildRoadClick_TruckStation(Window *w)

   211

{

   212

	if (_game_mode == GM_EDITOR) return;

   213

	if (HandlePlacePushButton(w, RTW_TRUCK_STATION, SPR_CURSOR_TRUCK_STATION, 1, PlaceRoad_TruckStation)) ShowTruckStationPicker();

   214

}

   215

   216

static void BuildRoadClick_Bridge(Window *w)

   217

{

   218

	HandlePlacePushButton(w, RTW_BUILD_BRIDGE, SPR_CURSOR_BRIDGE, 1, PlaceRoad_Bridge);

   219

}

   220

   221

static void BuildRoadClick_Tunnel(Window *w)

   222

{

   223

	HandlePlacePushButton(w, RTW_BUILD_TUNNEL, SPR_CURSOR_ROAD_TUNNEL, 3, PlaceRoad_Tunnel);

   224

}

   225

   226

static void BuildRoadClick_Remove(Window *w)

   227

{

   228

	if (IsWindowWidgetDisabled(w, RTW_REMOVE)) return;

   229

	SetWindowDirty(w);

   230

	SndPlayFx(SND_15_BEEP);

   231

	ToggleWidgetLoweredState(w, RTW_REMOVE);

   232

	SetSelectionRed(IsWindowWidgetLowered(w, RTW_REMOVE));

   233

}

   234

   235

   236

static OnButtonClick* const _build_road_button_proc[] = {

   237

	BuildRoadClick_NE,

   238

	BuildRoadClick_NW,

   239

	BuildRoadClick_Demolish,

   240

	BuildRoadClick_Depot,

   241

	BuildRoadClick_BusStation,

   242

	BuildRoadClick_TruckStation,

   243

	BuildRoadClick_Bridge,

   244

	BuildRoadClick_Tunnel,

   245

	BuildRoadClick_Remove

   246

};

   247

   248

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

   249

{

   250

	switch (e->event) {

   251

	case WE_CREATE: DisableWindowWidget(w, RTW_REMOVE); break;

   252

   253

	case WE_PAINT:

   254

		if (IsWindowWidgetLowered(w, RTW_ROAD_X) || IsWindowWidgetLowered(w, RTW_ROAD_Y) || IsWindowWidgetLowered(w, RTW_BUS_STATION) || IsWindowWidgetLowered(w, RTW_TRUCK_STATION)) {

   255

			EnableWindowWidget(w, RTW_REMOVE);

   256

		}

   257

		DrawWindowWidgets(w);

   258

		break;

   259

   260

	case WE_CLICK: {

   261

		if (e->we.click.widget >= 3) _build_road_button_proc[e->we.click.widget - 3](w);

   262

	} break;

   263

   264

	case WE_KEYPRESS:

   265

		switch (e->we.keypress.keycode) {

   266

			case '1': BuildRoadClick_NE(w);           break;

   267

			case '2': BuildRoadClick_NW(w);           break;

   268

			case '3': BuildRoadClick_Demolish(w);     break;

   269

			case '4': BuildRoadClick_Depot(w);        break;

   270

			case '5': BuildRoadClick_BusStation(w);   break;

   271

			case '6': BuildRoadClick_TruckStation(w); break;

   272

			case 'B': BuildRoadClick_Bridge(w);       break;

   273

			case 'T': BuildRoadClick_Tunnel(w);       break;

   274

			case 'R': BuildRoadClick_Remove(w);       break;

   275

			default: return;

   276

		}

   277

		MarkTileDirty(_thd.pos.x, _thd.pos.y); // redraw tile selection

   278

		e->we.keypress.cont = false;

   279

		break;

   280

   281

	case WE_PLACE_OBJ:

   282

		_remove_button_clicked = IsWindowWidgetLowered(w, RTW_REMOVE);

   283

		_place_proc(e->we.place.tile);

   284

		break;

   285

   286

	case WE_ABORT_PLACE_OBJ:

   287

		RaiseWindowButtons(w);

   288

		DisableWindowWidget(w, RTW_REMOVE);

   289

		InvalidateWidget(w, RTW_REMOVE);

   290

   291

		w = FindWindowById(WC_BUS_STATION, 0);

   292

		if (w != NULL) WP(w, def_d).close = true;

   293

		w = FindWindowById(WC_TRUCK_STATION, 0);

   294

		if (w != NULL) WP(w, def_d).close = true;

   295

		w = FindWindowById(WC_BUILD_DEPOT, 0);

   296

		if (w != NULL) WP(w, def_d).close = true;

   297

		break;

   298

   299

	case WE_PLACE_DRAG:

   300

		switch (e->we.place.select_proc) {

   301

			case DDSP_PLACE_ROAD_NE:

   302

				_place_road_flag = (_place_road_flag & ~2) | ((e->we.place.pt.y & 8) >> 2);

   303

				break;

   304

   305

			case DDSP_PLACE_ROAD_NW:

   306

				_place_road_flag = (_place_road_flag & ~2) | ((e->we.place.pt.x & 8) >> 2);

   307

				break;

   308

		}

   309

   310

		VpSelectTilesWithMethod(e->we.place.pt.x, e->we.place.pt.y, e->we.place.select_method);

   311

		return;

   312

   313

	case WE_PLACE_MOUSEUP:

   314

		if (e->we.place.pt.x != -1) {

   315

			TileIndex start_tile = e->we.place.starttile;

   316

			TileIndex end_tile = e->we.place.tile;

   317

   318

			switch (e->we.place.select_proc) {

   319

				case DDSP_BUILD_BRIDGE:

   320

					ResetObjectToPlace();

   321

					ShowBuildBridgeWindow(start_tile, end_tile, 0x80 | RoadTypeToRoadTypes(_cur_roadtype));

   322

					break;

   323

   324

				case DDSP_DEMOLISH_AREA:

   325

					DoCommandP(end_tile, start_tile, 0, CcPlaySound10, CMD_CLEAR_AREA | CMD_MSG(STR_00B5_CAN_T_CLEAR_THIS_AREA));

   326

					break;

   327

   328

				case DDSP_PLACE_ROAD_NE:

   329

				case DDSP_PLACE_ROAD_NW:

   330

					DoCommandP(end_tile, start_tile, _place_road_flag | (_cur_roadtype << 3), CcPlaySound1D,

   331

						_remove_button_clicked ?

   332

						CMD_REMOVE_LONG_ROAD | CMD_AUTO | CMD_NO_WATER | CMD_MSG(_road_type_infos[_cur_roadtype].err_remove_road) :

   333

						CMD_BUILD_LONG_ROAD | CMD_AUTO | CMD_NO_WATER | CMD_MSG(_road_type_infos[_cur_roadtype].err_build_road));

   334

					break;

   335

			}

   336

		}

   337

		break;

   338

   339

	case WE_PLACE_PRESIZE: {

   340

		TileIndex tile = e->we.place.tile;

   341

   343

		VpSetPresizeRange(tile, _build_tunnel_endtile == 0 ? tile : _build_tunnel_endtile);

   344

		break;

   345

	}

   346

   347

	case WE_DESTROY:

   348

		if (_patches.link_terraform_toolbar) DeleteWindowById(WC_SCEN_LAND_GEN, 0);

   349

		break;

   350

	}

   351

}

   352

   353

static const Widget _build_road_widgets[] = {

   354

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

   355

{    WWT_CAPTION,   RESIZE_NONE,     7,    11,   205,     0,    13, STR_1802_ROAD_CONSTRUCTION, STR_018C_WINDOW_TITLE_DRAG_THIS},

   356

{  WWT_STICKYBOX,   RESIZE_NONE,     7,   206,   217,     0,    13, 0x0,                        STR_STICKY_BUTTON},

   357

   358

{     WWT_IMGBTN,   RESIZE_NONE,     7,     0,    21,    14,    35, SPR_IMG_ROAD_NW,            STR_180B_BUILD_ROAD_SECTION},

   359

{     WWT_IMGBTN,   RESIZE_NONE,     7,    22,    43,    14,    35, SPR_IMG_ROAD_NE,            STR_180B_BUILD_ROAD_SECTION},

   360

{     WWT_IMGBTN,   RESIZE_NONE,     7,    44,    65,    14,    35, SPR_IMG_DYNAMITE,           STR_018D_DEMOLISH_BUILDINGS_ETC},

   361

{     WWT_IMGBTN,   RESIZE_NONE,     7,    66,    87,    14,    35, SPR_IMG_ROAD_DEPOT,         STR_180C_BUILD_ROAD_VEHICLE_DEPOT},

   362

{     WWT_IMGBTN,   RESIZE_NONE,     7,    88,   109,    14,    35, SPR_IMG_BUS_STATION,        STR_180D_BUILD_BUS_STATION},

   363

{     WWT_IMGBTN,   RESIZE_NONE,     7,   110,   131,    14,    35, SPR_IMG_TRUCK_BAY,          STR_180E_BUILD_TRUCK_LOADING_BAY},

   364

{     WWT_IMGBTN,   RESIZE_NONE,     7,   132,   173,    14,    35, SPR_IMG_BRIDGE,             STR_180F_BUILD_ROAD_BRIDGE},

   365

{     WWT_IMGBTN,   RESIZE_NONE,     7,   174,   195,    14,    35, SPR_IMG_ROAD_TUNNEL,        STR_1810_BUILD_ROAD_TUNNEL},

   366

{     WWT_IMGBTN,   RESIZE_NONE,     7,   196,   217,    14,    35, SPR_IMG_REMOVE,             STR_1811_TOGGLE_BUILD_REMOVE_FOR},

   367

{   WIDGETS_END},

   368

};

   369

   370

static const WindowDesc _build_road_desc = {

   371

	WDP_ALIGN_TBR, 22, 218, 36,

   372

	WC_BUILD_TOOLBAR, WC_NONE,

   373

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_STICKY_BUTTON,

   374

	_build_road_widgets,

   375

	BuildRoadToolbWndProc

   376

};

   377

   378

void ShowBuildRoadToolbar(RoadType roadtype)

   379

{

   380

	if (!IsValidPlayer(_current_player)) return;

   381

	_cur_roadtype = roadtype;

   382

   383

	DeleteWindowById(WC_BUILD_TOOLBAR, 0);

   384

	Window *w = AllocateWindowDesc(&_build_road_desc);

   385

	if (_patches.link_terraform_toolbar) ShowTerraformToolbar(w);

   386

}

   387

   388

static const Widget _build_road_scen_widgets[] = {

   389

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

   390

{    WWT_CAPTION,   RESIZE_NONE,     7,    11,   139,     0,    13, STR_1802_ROAD_CONSTRUCTION, STR_018C_WINDOW_TITLE_DRAG_THIS},

   391

{  WWT_STICKYBOX,   RESIZE_NONE,     7,   140,   151,     0,    13, 0x0,                        STR_STICKY_BUTTON},

   392

   393

{     WWT_IMGBTN,   RESIZE_NONE,     7,     0,    21,    14,    35, SPR_IMG_ROAD_NW,            STR_180B_BUILD_ROAD_SECTION},

   394

{     WWT_IMGBTN,   RESIZE_NONE,     7,    22,    43,    14,    35, SPR_IMG_ROAD_NE,            STR_180B_BUILD_ROAD_SECTION},

   395

{     WWT_IMGBTN,   RESIZE_NONE,     7,    44,    65,    14,    35, SPR_IMG_DYNAMITE,           STR_018D_DEMOLISH_BUILDINGS_ETC},

   396

{      WWT_EMPTY,   RESIZE_NONE,     0,     0,     0,     0,     0, 0x0,                        STR_NULL},

   397

{      WWT_EMPTY,   RESIZE_NONE,     0,     0,     0,     0,     0, 0x0,                        STR_NULL},

   398

{      WWT_EMPTY,   RESIZE_NONE,     0,     0,     0,     0,     0, 0x0,                        STR_NULL},

   399

{     WWT_IMGBTN,   RESIZE_NONE,     7,    66,   107,    14,    35, SPR_IMG_BRIDGE,             STR_180F_BUILD_ROAD_BRIDGE},

   400

{     WWT_IMGBTN,   RESIZE_NONE,     7,   108,   129,    14,    35, SPR_IMG_ROAD_TUNNEL,        STR_1810_BUILD_ROAD_TUNNEL},

   401

{     WWT_IMGBTN,   RESIZE_NONE,     7,   130,   151,    14,    35, SPR_IMG_REMOVE,             STR_1811_TOGGLE_BUILD_REMOVE_FOR},

   402

{   WIDGETS_END},

   403

};

   404

   405

static const WindowDesc _build_road_scen_desc = {

   406

	WDP_AUTO, WDP_AUTO, 152, 36,

   407

	WC_SCEN_BUILD_ROAD, WC_NONE,

   408

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_STICKY_BUTTON,

   409

	_build_road_scen_widgets,

   410

	BuildRoadToolbWndProc

   411

};

   412

   413

void ShowBuildRoadScenToolbar()

   414

{

   415

	AllocateWindowDescFront(&_build_road_scen_desc, 0);

   416

}

   417

   418

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

   419

{

   420

	switch (e->event) {

   421

	case WE_CREATE: LowerWindowWidget(w, _road_depot_orientation + 3); break;

   422

   423

	case WE_PAINT:

   424

		DrawWindowWidgets(w);

   425

   426

		DrawRoadDepotSprite(70, 17, DIAGDIR_NE, _cur_roadtype);

   427

		DrawRoadDepotSprite(70, 69, DIAGDIR_SE, _cur_roadtype);

   428

		DrawRoadDepotSprite( 2, 69, DIAGDIR_SW, _cur_roadtype);

   429

		DrawRoadDepotSprite( 2, 17, DIAGDIR_NW, _cur_roadtype);

   430

		break;

   431

   432

	case WE_CLICK: {

   433

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

   434

		case 3: case 4: case 5: case 6:

   435

			RaiseWindowWidget(w, _road_depot_orientation + 3);

   436

			_road_depot_orientation = (DiagDirection)(e->we.click.widget - 3);

   437

			LowerWindowWidget(w, _road_depot_orientation + 3);

   438

			SndPlayFx(SND_15_BEEP);

   439

			SetWindowDirty(w);

   440

			break;

   441

		}

   442

	} break;

   443

   444

	case WE_MOUSELOOP:

   445

		if (WP(w, def_d).close) DeleteWindow(w);

   446

		break;

   447

   448

	case WE_DESTROY:

   449

		if (!WP(w, def_d).close) ResetObjectToPlace();

   450

		break;

   451

	}

   452

}

   453

   454

static const Widget _build_road_depot_widgets[] = {

   455

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

   456

{    WWT_CAPTION,   RESIZE_NONE,     7,    11,   139,     0,    13, STR_1806_ROAD_DEPOT_ORIENTATION, STR_018C_WINDOW_TITLE_DRAG_THIS},

   457

{      WWT_PANEL,   RESIZE_NONE,     7,     0,   139,    14,   121, 0x0,                             STR_NULL},

   458

{      WWT_PANEL,   RESIZE_NONE,    14,    71,   136,    17,    66, 0x0,                             STR_1813_SELECT_ROAD_VEHICLE_DEPOT},

   459

{      WWT_PANEL,   RESIZE_NONE,    14,    71,   136,    69,   118, 0x0,                             STR_1813_SELECT_ROAD_VEHICLE_DEPOT},

   460

{      WWT_PANEL,   RESIZE_NONE,    14,     3,    68,    69,   118, 0x0,                             STR_1813_SELECT_ROAD_VEHICLE_DEPOT},

   461

{      WWT_PANEL,   RESIZE_NONE,    14,     3,    68,    17,    66, 0x0,                             STR_1813_SELECT_ROAD_VEHICLE_DEPOT},

   462

{   WIDGETS_END},

   463

};

   464

   465

static const WindowDesc _build_road_depot_desc = {

   466

	WDP_AUTO, WDP_AUTO, 140, 122,

   467

	WC_BUILD_DEPOT, WC_BUILD_TOOLBAR,

   468

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET,

   469

	_build_road_depot_widgets,

   470

	BuildRoadDepotWndProc

   471

};

   472

   473

static void ShowRoadDepotPicker()

   474

{

   475

	AllocateWindowDesc(&_build_road_depot_desc);

   476

}

   477

   478

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

   479

{

   480

	switch (e->event) {

   481

	case WE_CREATE:

   482

		/* Trams don't have non-drivethrough stations */

   483

		if (_cur_roadtype == ROADTYPE_TRAM && _road_station_picker_orientation < DIAGDIR_END) {

   484

			_road_station_picker_orientation = DIAGDIR_END;

   485

		}

   486

		SetWindowWidgetsDisabledState(w, _cur_roadtype == ROADTYPE_TRAM, 3, 4, 5, 6, WIDGET_LIST_END);

   487

   488

		LowerWindowWidget(w, _road_station_picker_orientation + 3);

   489

		LowerWindowWidget(w, _station_show_coverage + 9);

   490

		break;

   491

   492

	case WE_PAINT: {

   493

		int image;