~ubuntu-branches/debian/squeeze/openttd/squeeze

« back to all changes in this revision

Viewing changes to src/road_gui.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Jordi Mallach, Matthijs Kooijman, Jordi Mallach
  • Date: 2009-04-15 18:22:10 UTC
  • mfrom: (1.1.6 upstream) (2.1.3 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090415182210-22ktb8kdbp2tf3bm
[ Matthijs Kooijman ]
* New upstream release.
* Remove Debian specific desktop file, upstream provides one now. 
* Add debian/watch file.

[ Jordi Mallach ]
* Bump Standards-Version to 3.8.1, with no changes required.
* Move to debhelper compat 7. Bump Build-Depends accordingly.
* Use dh_prep.
* Add "set -e" to config script.
* Remove a few extra doc files that get installed by upstream Makefile.
* Add more complete copyright information.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
/* $Id: road_gui.cpp 12365 2008-03-13 18:53:49Z skidd13 $ */
 
1
/* $Id: road_gui.cpp 15723 2009-03-15 15:12:06Z rubidium $ */
2
2
 
3
 
/** @file road_gui.cpp */
 
3
/** @file road_gui.cpp GUI for building roads. */
4
4
 
5
5
#include "stdafx.h"
6
6
#include "openttd.h"
11
11
#include "viewport_func.h"
12
12
#include "gfx_func.h"
13
13
#include "command_func.h"
14
 
#include "variables.h"
15
14
#include "road_type.h"
16
15
#include "road_cmd.h"
17
16
#include "road_map.h"
18
 
#include "station_map.h"
19
 
#include "station.h"
 
17
#include "station_func.h"
20
18
#include "functions.h"
21
19
#include "window_func.h"
22
20
#include "vehicle_func.h"
23
21
#include "sound_func.h"
24
 
#include "player_func.h"
 
22
#include "company_func.h"
 
23
#include "tunnelbridge.h"
 
24
#include "tilehighlight_func.h"
 
25
#include "company_base.h"
25
26
#include "settings_type.h"
26
27
 
27
28
#include "table/sprites.h"
28
29
#include "table/strings.h"
29
30
 
30
 
static void ShowRVStationPicker(RoadStop::Type rs);
31
 
static void ShowRoadDepotPicker();
 
31
static void ShowRVStationPicker(Window *parent, RoadStopType rs);
 
32
static void ShowRoadDepotPicker(Window *parent);
32
33
 
33
34
static bool _remove_button_clicked;
34
35
static bool _one_way_button_clicked;
116
117
{
117
118
        if (success) {
118
119
                SndPlayTileFx(SND_20_SPLAT_2, tile);
119
 
                ResetObjectToPlace();
 
120
                if (!_settings_client.gui.persistent_buildingtools) ResetObjectToPlace();
120
121
        } else {
121
122
                SetRedErrorSquare(_build_tunnel_endtile);
122
123
        }
170
171
 
171
172
static void PlaceRoad_Tunnel(TileIndex tile)
172
173
{
173
 
        DoCommandP(tile, 0x200 | RoadTypeToRoadTypes(_cur_roadtype), 0, CcBuildRoadTunnel, CMD_BUILD_TUNNEL | CMD_MSG(STR_5016_CAN_T_BUILD_TUNNEL_HERE));
 
174
        DoCommandP(tile, 0x200 | RoadTypeToRoadTypes(_cur_roadtype), 0, CMD_BUILD_TUNNEL | CMD_MSG(STR_5016_CAN_T_BUILD_TUNNEL_HERE), CcBuildRoadTunnel);
174
175
}
175
176
 
176
177
static void BuildRoadOutsideStation(TileIndex tile, DiagDirection direction)
177
178
{
178
179
        tile += TileOffsByDiagDir(direction);
179
 
        // if there is a roadpiece just outside of the station entrance, build a connecting route
 
180
        /* if there is a roadpiece just outside of the station entrance, build a connecting route */
180
181
        if (IsNormalRoadTile(tile)) {
181
182
                if (GetRoadBits(tile, _cur_roadtype) != ROAD_NONE) {
182
 
                        DoCommandP(tile, _cur_roadtype << 4 | DiagDirToRoadBits(ReverseDiagDir(direction)), 0, NULL, CMD_BUILD_ROAD);
 
183
                        DoCommandP(tile, _cur_roadtype << 4 | DiagDirToRoadBits(ReverseDiagDir(direction)), 0, CMD_BUILD_ROAD);
183
184
                }
184
185
        }
185
186
}
189
190
        if (success) {
190
191
                DiagDirection dir = (DiagDirection)GB(p1, 0, 2);
191
192
                SndPlayTileFx(SND_1F_SPLAT, tile);
192
 
                ResetObjectToPlace();
 
193
                if (!_settings_client.gui.persistent_buildingtools) ResetObjectToPlace();
193
194
                BuildRoadOutsideStation(tile, dir);
194
195
                /* For a drive-through road stop build connecting road for other entrance */
195
196
                if (HasBit(p2, 1)) BuildRoadOutsideStation(tile, ReverseDiagDir(dir));
198
199
 
199
200
static void PlaceRoad_Depot(TileIndex tile)
200
201
{
201
 
        DoCommandP(tile, _cur_roadtype << 2 | _road_depot_orientation, 0, CcRoadDepot, CMD_BUILD_ROAD_DEPOT | CMD_NO_WATER | CMD_MSG(_road_type_infos[_cur_roadtype].err_depot));
 
202
        DoCommandP(tile, _cur_roadtype << 2 | _road_depot_orientation, 0, CMD_BUILD_ROAD_DEPOT | CMD_MSG(_road_type_infos[_cur_roadtype].err_depot), CcRoadDepot);
202
203
}
203
204
 
204
205
static void PlaceRoadStop(TileIndex tile, uint32 p2, uint32 cmd)
205
206
{
206
207
        uint32 p1 = _road_station_picker_orientation;
 
208
        SB(p2, 16, 16, INVALID_STATION); // no station to join
207
209
 
208
210
        if (p1 >= DIAGDIR_END) {
209
211
                SetBit(p2, 1); // It's a drive-through stop
210
212
                p1 -= DIAGDIR_END; // Adjust picker result to actual direction
211
213
        }
212
 
        DoCommandP(tile, p1, p2, CcRoadDepot, cmd);
 
214
        CommandContainer cmdcont = { tile, p1, p2, cmd, CcRoadDepot, "" };
 
215
        ShowSelectStationIfNeeded(cmdcont, 1, 1);
213
216
}
214
217
 
215
218
static void PlaceRoad_BusStation(TileIndex tile)
216
219
{
217
220
        if (_remove_button_clicked) {
218
 
                DoCommandP(tile, 0, RoadStop::BUS, CcPlaySound1D, CMD_REMOVE_ROAD_STOP | CMD_MSG(_road_type_infos[_cur_roadtype].err_remove_station[RoadStop::BUS]));
 
221
                DoCommandP(tile, 0, ROADSTOP_BUS, CMD_REMOVE_ROAD_STOP | CMD_MSG(_road_type_infos[_cur_roadtype].err_remove_station[ROADSTOP_BUS]), CcPlaySound1D);
219
222
        } else {
220
 
                PlaceRoadStop(tile, (_ctrl_pressed << 5) | RoadTypeToRoadTypes(_cur_roadtype) << 2 | RoadStop::BUS, CMD_BUILD_ROAD_STOP | CMD_NO_WATER | CMD_MSG(_road_type_infos[_cur_roadtype].err_build_station[RoadStop::BUS]));
 
223
                PlaceRoadStop(tile, (_ctrl_pressed << 5) | RoadTypeToRoadTypes(_cur_roadtype) << 2 | ROADSTOP_BUS, CMD_BUILD_ROAD_STOP | CMD_MSG(_road_type_infos[_cur_roadtype].err_build_station[ROADSTOP_BUS]));
221
224
        }
222
225
}
223
226
 
224
227
static void PlaceRoad_TruckStation(TileIndex tile)
225
228
{
226
229
        if (_remove_button_clicked) {
227
 
                DoCommandP(tile, 0, RoadStop::TRUCK, CcPlaySound1D, CMD_REMOVE_ROAD_STOP | CMD_MSG(_road_type_infos[_cur_roadtype].err_remove_station[RoadStop::TRUCK]));
 
230
                DoCommandP(tile, 0, ROADSTOP_TRUCK, CMD_REMOVE_ROAD_STOP | CMD_MSG(_road_type_infos[_cur_roadtype].err_remove_station[ROADSTOP_TRUCK]), CcPlaySound1D);
228
231
        } else {
229
 
                PlaceRoadStop(tile, (_ctrl_pressed << 5) | RoadTypeToRoadTypes(_cur_roadtype) << 2 | RoadStop::TRUCK, CMD_BUILD_ROAD_STOP | CMD_NO_WATER | CMD_MSG(_road_type_infos[_cur_roadtype].err_build_station[RoadStop::TRUCK]));
 
232
                PlaceRoadStop(tile, (_ctrl_pressed << 5) | RoadTypeToRoadTypes(_cur_roadtype) << 2 | ROADSTOP_TRUCK, CMD_BUILD_ROAD_STOP | CMD_MSG(_road_type_infos[_cur_roadtype].err_build_station[ROADSTOP_TRUCK]));
230
233
        }
231
234
}
232
235
 
233
 
static void PlaceRoad_DemolishArea(TileIndex tile)
234
 
{
235
 
        VpStartPlaceSizing(tile, VPM_X_AND_Y, DDSP_DEMOLISH_AREA);
236
 
}
237
 
 
238
236
/** Enum referring to the widgets of the build road toolbar */
239
237
enum RoadToolbarWidgets {
240
238
        RTW_CLOSEBOX = 0,
322
320
 
323
321
static void BuildRoadClick_Demolish(Window *w)
324
322
{
325
 
        HandlePlacePushButton(w, RTW_DEMOLISH, ANIMCURSOR_DEMOLISH, VHM_RECT, PlaceRoad_DemolishArea);
 
323
        HandlePlacePushButton(w, RTW_DEMOLISH, ANIMCURSOR_DEMOLISH, VHM_RECT, PlaceProc_DemolishArea);
326
324
}
327
325
 
328
326
static void BuildRoadClick_Depot(Window *w)
329
327
{
330
328
        if (_game_mode == GM_EDITOR || !CanBuildVehicleInfrastructure(VEH_ROAD)) return;
331
 
        if (HandlePlacePushButton(w, RTW_DEPOT, SPR_CURSOR_ROAD_DEPOT, VHM_RECT, PlaceRoad_Depot)) ShowRoadDepotPicker();
 
329
        if (HandlePlacePushButton(w, RTW_DEPOT, SPR_CURSOR_ROAD_DEPOT, VHM_RECT, PlaceRoad_Depot)) ShowRoadDepotPicker(w);
332
330
}
333
331
 
334
332
static void BuildRoadClick_BusStation(Window *w)
335
333
{
336
334
        if (_game_mode == GM_EDITOR || !CanBuildVehicleInfrastructure(VEH_ROAD)) return;
337
 
        if (HandlePlacePushButton(w, RTW_BUS_STATION, SPR_CURSOR_BUS_STATION, VHM_RECT, PlaceRoad_BusStation)) ShowRVStationPicker(RoadStop::BUS);
 
335
        if (HandlePlacePushButton(w, RTW_BUS_STATION, SPR_CURSOR_BUS_STATION, VHM_RECT, PlaceRoad_BusStation)) ShowRVStationPicker(w, ROADSTOP_BUS);
338
336
}
339
337
 
340
338
static void BuildRoadClick_TruckStation(Window *w)
341
339
{
342
340
        if (_game_mode == GM_EDITOR || !CanBuildVehicleInfrastructure(VEH_ROAD)) return;
343
 
        if (HandlePlacePushButton(w, RTW_TRUCK_STATION, SPR_CURSOR_TRUCK_STATION, VHM_RECT, PlaceRoad_TruckStation)) ShowRVStationPicker(RoadStop::TRUCK);
 
341
        if (HandlePlacePushButton(w, RTW_TRUCK_STATION, SPR_CURSOR_TRUCK_STATION, VHM_RECT, PlaceRoad_TruckStation)) ShowRVStationPicker(w, ROADSTOP_TRUCK);
344
342
}
345
343
 
346
344
/**
352
350
static void BuildRoadClick_OneWay(Window *w)
353
351
{
354
352
        if (w->IsWidgetDisabled(RTW_ONE_WAY)) return;
355
 
        SetWindowDirty(w);
 
353
        w->SetDirty();
356
354
        w->ToggleWidgetLoweredState(RTW_ONE_WAY);
357
355
        SetSelectionRed(false);
358
356
}
370
368
static void BuildRoadClick_Remove(Window *w)
371
369
{
372
370
        if (w->IsWidgetDisabled(RTW_REMOVE)) return;
 
371
 
 
372
        DeleteWindowById(WC_SELECT_STATION, 0);
373
373
        ToggleRoadButton_Remove(w);
374
374
        SndPlayFx(SND_15_BEEP);
375
375
}
376
376
 
377
377
/** Array with the handlers of the button-clicks for the road-toolbar */
378
 
static OnButtonClick* const _build_road_button_proc[] = {
 
378
static OnButtonClick * const _build_road_button_proc[] = {
379
379
        BuildRoadClick_X_Dir,
380
380
        BuildRoadClick_Y_Dir,
381
381
        BuildRoadClick_AutoRoad,
404
404
        'R',
405
405
};
406
406
 
407
 
/**
408
 
 * Update the remove button lowered state of the road toolbar
409
 
 *
410
 
 * @param w The toolbar window
411
 
 * @param clicked_widget The widget which the player clicked just now
412
 
 */
413
 
static void UpdateOptionWidgetStatus(Window *w, int clicked_widget)
414
 
{
415
 
        /* The remove and the one way button state is driven
416
 
         * by the other buttons so they don't act on themselfs.
417
 
         * Both are only valid if they are able to apply as options. */
418
 
        switch (clicked_widget) {
419
 
                case RTW_REMOVE:
420
 
                        w->RaiseWidget(RTW_ONE_WAY);
421
 
                        w->InvalidateWidget(RTW_ONE_WAY);
422
 
                        break;
423
 
                case RTW_ONE_WAY:
424
 
                        w->RaiseWidget(RTW_REMOVE);
425
 
                        w->InvalidateWidget(RTW_REMOVE);
426
 
                        break;
427
 
                case RTW_BUS_STATION:
428
 
                case RTW_TRUCK_STATION:
429
 
                        w->DisableWidget(RTW_ONE_WAY);
430
 
                        w->SetWidgetDisabledState(RTW_REMOVE, !w->IsWidgetLowered(clicked_widget));
431
 
                        break;
432
 
                case RTW_ROAD_X:
433
 
                case RTW_ROAD_Y:
434
 
                case RTW_AUTOROAD:
435
 
                        w->SetWidgetsDisabledState(!w->IsWidgetLowered(clicked_widget),
436
 
                                RTW_REMOVE,
437
 
                                RTW_ONE_WAY,
438
 
                                WIDGET_LIST_END);
439
 
                        break;
440
 
                default:
441
 
                        /* When any other buttons than road/station, raise and
442
 
                         * disable the removal button */
443
 
                        w->SetWidgetsDisabledState(true,
444
 
                                RTW_REMOVE,
445
 
                                RTW_ONE_WAY,
446
 
                                WIDGET_LIST_END);
447
 
                        w->SetWidgetsLoweredState (false,
448
 
                                RTW_REMOVE,
449
 
                                RTW_ONE_WAY,
450
 
                                WIDGET_LIST_END);
451
 
                        break;
452
 
        }
453
 
}
454
 
 
455
 
static void BuildRoadToolbWndProc(Window *w, WindowEvent *e)
456
 
{
457
 
        switch (e->event) {
458
 
        case WE_CREATE:
459
 
                w->SetWidgetsDisabledState(true,
 
407
struct BuildRoadToolbarWindow : Window {
 
408
        BuildRoadToolbarWindow(const WindowDesc *desc, WindowNumber window_number) : Window(desc, window_number)
 
409
        {
 
410
                this->SetWidgetsDisabledState(true,
460
411
                        RTW_REMOVE,
461
412
                        RTW_ONE_WAY,
462
413
                        WIDGET_LIST_END);
463
 
                break;
464
 
 
465
 
        case WE_PAINT:
466
 
                w->SetWidgetsDisabledState(!CanBuildVehicleInfrastructure(VEH_ROAD),
 
414
 
 
415
                this->FindWindowPlacementAndResize(desc);
 
416
                if (_settings_client.gui.link_terraform_toolbar) ShowTerraformToolbar(this);
 
417
        }
 
418
 
 
419
        ~BuildRoadToolbarWindow()
 
420
        {
 
421
                if (_settings_client.gui.link_terraform_toolbar) DeleteWindowById(WC_SCEN_LAND_GEN, 0, false);
 
422
        }
 
423
 
 
424
        /**
 
425
         * Update the remove button lowered state of the road toolbar
 
426
         *
 
427
         * @param clicked_widget The widget which the client clicked just now
 
428
         */
 
429
        void UpdateOptionWidgetStatus(RoadToolbarWidgets clicked_widget)
 
430
        {
 
431
                /* The remove and the one way button state is driven
 
432
                 * by the other buttons so they don't act on themselfs.
 
433
                 * Both are only valid if they are able to apply as options. */
 
434
                switch (clicked_widget) {
 
435
                        case RTW_REMOVE:
 
436
                                this->RaiseWidget(RTW_ONE_WAY);
 
437
                                this->InvalidateWidget(RTW_ONE_WAY);
 
438
                                break;
 
439
 
 
440
                        case RTW_ONE_WAY:
 
441
                                this->RaiseWidget(RTW_REMOVE);
 
442
                                this->InvalidateWidget(RTW_REMOVE);
 
443
                                break;
 
444
 
 
445
                        case RTW_BUS_STATION:
 
446
                        case RTW_TRUCK_STATION:
 
447
                                this->DisableWidget(RTW_ONE_WAY);
 
448
                                this->SetWidgetDisabledState(RTW_REMOVE, !this->IsWidgetLowered(clicked_widget));
 
449
                                break;
 
450
 
 
451
                        case RTW_ROAD_X:
 
452
                        case RTW_ROAD_Y:
 
453
                        case RTW_AUTOROAD:
 
454
                                this->SetWidgetsDisabledState(!this->IsWidgetLowered(clicked_widget),
 
455
                                        RTW_REMOVE,
 
456
                                        RTW_ONE_WAY,
 
457
                                        WIDGET_LIST_END);
 
458
                                break;
 
459
 
 
460
                        default:
 
461
                                /* When any other buttons than road/station, raise and
 
462
                                 * disable the removal button */
 
463
                                this->SetWidgetsDisabledState(true,
 
464
                                        RTW_REMOVE,
 
465
                                        RTW_ONE_WAY,
 
466
                                        WIDGET_LIST_END);
 
467
                                this->SetWidgetsLoweredState (false,
 
468
                                        RTW_REMOVE,
 
469
                                        RTW_ONE_WAY,
 
470
                                        WIDGET_LIST_END);
 
471
                                break;
 
472
                }
 
473
        }
 
474
 
 
475
        virtual void OnPaint()
 
476
        {
 
477
                this->SetWidgetsDisabledState(!CanBuildVehicleInfrastructure(VEH_ROAD),
467
478
                        RTW_DEPOT,
468
479
                        RTW_BUS_STATION,
469
480
                        RTW_TRUCK_STATION,
470
481
                        WIDGET_LIST_END);
471
 
                DrawWindowWidgets(w);
472
 
                break;
 
482
                this->DrawWidgets();
 
483
        }
473
484
 
474
 
        case WE_CLICK:
475
 
                if (e->we.click.widget >= RTW_ROAD_X) {
 
485
        virtual void OnClick(Point pt, int widget)
 
486
        {
 
487
                if (widget >= RTW_ROAD_X) {
476
488
                        _remove_button_clicked = false;
477
489
                        _one_way_button_clicked = false;
478
 
                        _build_road_button_proc[e->we.click.widget - RTW_ROAD_X](w);
 
490
                        _build_road_button_proc[widget - RTW_ROAD_X](this);
479
491
                }
480
 
                UpdateOptionWidgetStatus(w, e->we.click.widget);
481
 
                if (_ctrl_pressed) RoadToolbar_CtrlChanged(w);
482
 
                break;
 
492
                this->UpdateOptionWidgetStatus((RoadToolbarWidgets)widget);
 
493
                if (_ctrl_pressed) RoadToolbar_CtrlChanged(this);
 
494
        }
483
495
 
484
 
        case WE_KEYPRESS:
485
 
                for (uint8 i = 0; i != lengthof(_road_keycodes); i++) {
486
 
                        if (e->we.keypress.keycode == _road_keycodes[i]) {
487
 
                                e->we.keypress.cont = false;
 
496
        virtual EventState OnKeyPress(uint16 key, uint16 keycode)
 
497
        {
 
498
                EventState state = ES_NOT_HANDLED;
 
499
                for (uint i = 0; i != lengthof(_road_keycodes); i++) {
 
500
                        if (keycode == _road_keycodes[i]) {
488
501
                                _remove_button_clicked = false;
489
502
                                _one_way_button_clicked = false;
490
 
                                _build_road_button_proc[i](w);
491
 
                                UpdateOptionWidgetStatus(w, i + RTW_ROAD_X);
492
 
                                if (_ctrl_pressed) RoadToolbar_CtrlChanged(w);
 
503
                                _build_road_button_proc[i](this);
 
504
                                this->UpdateOptionWidgetStatus((RoadToolbarWidgets)(i + RTW_ROAD_X));
 
505
                                if (_ctrl_pressed) RoadToolbar_CtrlChanged(this);
 
506
                                state = ES_HANDLED;
493
507
                                break;
494
508
                        }
495
509
                }
496
510
                MarkTileDirty(_thd.pos.x, _thd.pos.y); // redraw tile selection
497
 
                break;
498
 
 
499
 
        case WE_PLACE_OBJ:
500
 
                _remove_button_clicked = w->IsWidgetLowered(RTW_REMOVE);
501
 
                _one_way_button_clicked = w->IsWidgetLowered(RTW_ONE_WAY);
502
 
                _place_proc(e->we.place.tile);
503
 
                break;
504
 
 
505
 
        case WE_ABORT_PLACE_OBJ:
506
 
                w->RaiseButtons();
507
 
                w->SetWidgetsDisabledState(true,
 
511
                return state;
 
512
        }
 
513
 
 
514
        virtual void OnPlaceObject(Point pt, TileIndex tile)
 
515
        {
 
516
                _remove_button_clicked = this->IsWidgetLowered(RTW_REMOVE);
 
517
                _one_way_button_clicked = this->IsWidgetLowered(RTW_ONE_WAY);
 
518
                _place_proc(tile);
 
519
        }
 
520
 
 
521
        virtual void OnPlaceObjectAbort()
 
522
        {
 
523
                this->RaiseButtons();
 
524
                this->SetWidgetsDisabledState(true,
508
525
                        RTW_REMOVE,
509
526
                        RTW_ONE_WAY,
510
527
                        WIDGET_LIST_END);
511
 
                w->InvalidateWidget(RTW_REMOVE);
512
 
                w->InvalidateWidget(RTW_ONE_WAY);
513
 
 
514
 
                w = FindWindowById(WC_BUS_STATION, 0);
515
 
                if (w != NULL) WP(w, def_d).close = true;
516
 
                w = FindWindowById(WC_TRUCK_STATION, 0);
517
 
                if (w != NULL) WP(w, def_d).close = true;
518
 
                w = FindWindowById(WC_BUILD_DEPOT, 0);
519
 
                if (w != NULL) WP(w, def_d).close = true;
520
 
                break;
521
 
 
522
 
        case WE_PLACE_DRAG:
 
528
                this->InvalidateWidget(RTW_REMOVE);
 
529
                this->InvalidateWidget(RTW_ONE_WAY);
 
530
 
 
531
                DeleteWindowById(WC_BUS_STATION, 0);
 
532
                DeleteWindowById(WC_TRUCK_STATION, 0);
 
533
                DeleteWindowById(WC_BUILD_DEPOT, 0);
 
534
                DeleteWindowById(WC_SELECT_STATION, 0);
 
535
                DeleteWindowById(WC_BUILD_BRIDGE, 0);
 
536
        }
 
537
 
 
538
        virtual void OnPlaceDrag(ViewportPlaceMethod select_method, ViewportDragDropSelectionProcess select_proc, Point pt)
 
539
        {
523
540
                /* Here we update the end tile flags
524
541
                 * of the road placement actions.
525
542
                 * At first we reset the end halfroad
526
543
                 * bits and if needed we set them again. */
527
 
                switch (e->we.place.select_proc) {
 
544
                switch (select_proc) {
528
545
                        case DDSP_PLACE_ROAD_X_DIR:
529
546
                                _place_road_flag &= ~RF_END_HALFROAD_X;
530
 
                                if (e->we.place.pt.x & 8) _place_road_flag |= RF_END_HALFROAD_X;
 
547
                                if (pt.x & 8) _place_road_flag |= RF_END_HALFROAD_X;
531
548
                                break;
532
549
 
533
550
                        case DDSP_PLACE_ROAD_Y_DIR:
534
551
                                _place_road_flag &= ~RF_END_HALFROAD_Y;
535
 
                                if (e->we.place.pt.y & 8) _place_road_flag |= RF_END_HALFROAD_Y;
 
552
                                if (pt.y & 8) _place_road_flag |= RF_END_HALFROAD_Y;
536
553
                                break;
537
554
 
538
555
                        case DDSP_PLACE_AUTOROAD:
539
556
                                _place_road_flag &= ~(RF_END_HALFROAD_Y | RF_END_HALFROAD_X);
540
 
                                if (e->we.place.pt.y & 8) _place_road_flag |= RF_END_HALFROAD_Y;
541
 
                                if (e->we.place.pt.x & 8) _place_road_flag |= RF_END_HALFROAD_X;
 
557
                                if (pt.y & 8) _place_road_flag |= RF_END_HALFROAD_Y;
 
558
                                if (pt.x & 8) _place_road_flag |= RF_END_HALFROAD_X;
542
559
 
543
560
                                /* For autoroad we need to update the
544
561
                                 * direction of the road */
545
562
                                if (_thd.size.x > _thd.size.y || (_thd.size.x == _thd.size.y &&
546
563
                                                ( (_tile_fract_coords.x < _tile_fract_coords.y && (_tile_fract_coords.x + _tile_fract_coords.y) < 16) ||
547
 
                                                  (_tile_fract_coords.x > _tile_fract_coords.y && (_tile_fract_coords.x + _tile_fract_coords.y) > 16) ))) {
 
564
                                                (_tile_fract_coords.x > _tile_fract_coords.y && (_tile_fract_coords.x + _tile_fract_coords.y) > 16) ))) {
548
565
                                        /* Set dir = X */
549
566
                                        _place_road_flag &= ~RF_DIR_Y;
550
567
                                } else {
553
570
                                }
554
571
 
555
572
                                break;
 
573
 
 
574
                        default:
 
575
                                break;
556
576
                }
557
577
 
558
 
                VpSelectTilesWithMethod(e->we.place.pt.x, e->we.place.pt.y, e->we.place.select_method);
559
 
                return;
560
 
 
561
 
        case WE_PLACE_MOUSEUP:
562
 
                if (e->we.place.pt.x != -1) {
563
 
                        TileIndex start_tile = e->we.place.starttile;
564
 
                        TileIndex end_tile = e->we.place.tile;
565
 
 
566
 
                        switch (e->we.place.select_proc) {
 
578
                VpSelectTilesWithMethod(pt.x, pt.y, select_method);
 
579
        }
 
580
 
 
581
        virtual void OnPlaceMouseUp(ViewportPlaceMethod select_method, ViewportDragDropSelectionProcess select_proc, Point pt, TileIndex start_tile, TileIndex end_tile)
 
582
        {
 
583
                if (pt.x != -1) {
 
584
                        switch (select_proc) {
 
585
                                default: NOT_REACHED();
567
586
                                case DDSP_BUILD_BRIDGE:
568
 
                                        ResetObjectToPlace();
 
587
                                        if (!_settings_client.gui.persistent_buildingtools) ResetObjectToPlace();
569
588
                                        ShowBuildBridgeWindow(start_tile, end_tile, TRANSPORT_ROAD, RoadTypeToRoadTypes(_cur_roadtype));
570
589
                                        break;
571
590
 
572
591
                                case DDSP_DEMOLISH_AREA:
573
 
                                        DoCommandP(end_tile, start_tile, 0, CcPlaySound10, CMD_CLEAR_AREA | CMD_MSG(STR_00B5_CAN_T_CLEAR_THIS_AREA));
 
592
                                        GUIPlaceProcDragXY(select_proc, start_tile, end_tile);
574
593
                                        break;
575
594
 
576
595
                                case DDSP_PLACE_ROAD_X_DIR:
582
601
                                         * not the 3rd bit set) */
583
602
                                        _place_road_flag = (RoadFlags)((_place_road_flag & RF_DIR_Y) ? (_place_road_flag & 0x07) : (_place_road_flag >> 3));
584
603
 
585
 
                                        DoCommandP(end_tile, start_tile, _place_road_flag | (_cur_roadtype << 3) | (_one_way_button_clicked << 5), CcPlaySound1D,
 
604
                                        DoCommandP(end_tile, start_tile, _place_road_flag | (_cur_roadtype << 3) | (_one_way_button_clicked << 5),
586
605
                                                (_ctrl_pressed || _remove_button_clicked) ?
587
 
                                                CMD_REMOVE_LONG_ROAD | CMD_NO_WATER | CMD_MSG(_road_type_infos[_cur_roadtype].err_remove_road) :
588
 
                                                CMD_BUILD_LONG_ROAD | CMD_NO_WATER | CMD_MSG(_road_type_infos[_cur_roadtype].err_build_road));
 
606
                                                CMD_REMOVE_LONG_ROAD | CMD_MSG(_road_type_infos[_cur_roadtype].err_remove_road) :
 
607
                                                CMD_BUILD_LONG_ROAD | CMD_MSG(_road_type_infos[_cur_roadtype].err_build_road), CcPlaySound1D);
589
608
                                        break;
590
609
                        }
591
610
                }
592
 
                break;
593
 
 
594
 
        case WE_PLACE_PRESIZE: {
595
 
                TileIndex tile = e->we.place.tile;
596
 
 
 
611
        }
 
612
 
 
613
        virtual void OnPlacePresize(Point pt, TileIndex tile)
 
614
        {
597
615
                DoCommand(tile, 0x200 | RoadTypeToRoadTypes(_cur_roadtype), 0, DC_AUTO, CMD_BUILD_TUNNEL);
598
616
                VpSetPresizeRange(tile, _build_tunnel_endtile == 0 ? tile : _build_tunnel_endtile);
599
 
                break;
600
 
        }
601
 
 
602
 
        case WE_DESTROY:
603
 
                if (_patches.link_terraform_toolbar) DeleteWindowById(WC_SCEN_LAND_GEN, 0);
604
 
                break;
605
 
 
606
 
        case WE_CTRL_CHANGED:
607
 
                if (RoadToolbar_CtrlChanged(w)) e->we.ctrl.cont = false;
608
 
                break;
609
 
        }
610
 
}
 
617
        }
 
618
 
 
619
        virtual EventState OnCTRLStateChange()
 
620
        {
 
621
                if (RoadToolbar_CtrlChanged(this)) return ES_HANDLED;
 
622
                return ES_NOT_HANDLED;
 
623
        }
 
624
};
611
625
 
612
626
/** Widget definition of the build road toolbar */
613
627
static const Widget _build_road_widgets[] = {
614
 
{   WWT_CLOSEBOX,   RESIZE_NONE,     7,     0,    10,     0,    13, STR_00C5,                   STR_018B_CLOSE_WINDOW},             // RTW_CLOSEBOX
615
 
{    WWT_CAPTION,   RESIZE_NONE,     7,    11,   250,     0,    13, STR_1802_ROAD_CONSTRUCTION, STR_018C_WINDOW_TITLE_DRAG_THIS},   // RTW_CAPTION
616
 
{  WWT_STICKYBOX,   RESIZE_NONE,     7,   251,   262,     0,    13, 0x0,                        STR_STICKY_BUTTON},                 // RTW_STICKY
 
628
{   WWT_CLOSEBOX,   RESIZE_NONE,  COLOUR_DARK_GREEN,     0,    10,     0,    13, STR_00C5,                   STR_018B_CLOSE_WINDOW},             // RTW_CLOSEBOX
 
629
{    WWT_CAPTION,   RESIZE_NONE,  COLOUR_DARK_GREEN,    11,   250,     0,    13, STR_1802_ROAD_CONSTRUCTION, STR_018C_WINDOW_TITLE_DRAG_THIS},   // RTW_CAPTION
 
630
{  WWT_STICKYBOX,   RESIZE_NONE,  COLOUR_DARK_GREEN,   251,   262,     0,    13, 0x0,                        STR_STICKY_BUTTON},                 // RTW_STICKY
617
631
 
618
 
{     WWT_IMGBTN,   RESIZE_NONE,     7,     0,    21,    14,    35, SPR_IMG_ROAD_X_DIR,         STR_180B_BUILD_ROAD_SECTION},       // RTW_ROAD_X
619
 
{     WWT_IMGBTN,   RESIZE_NONE,     7,    22,    43,    14,    35, SPR_IMG_ROAD_Y_DIR,         STR_180B_BUILD_ROAD_SECTION},       // RTW_ROAD_Y
620
 
{     WWT_IMGBTN,   RESIZE_NONE,     7,    44,    65,    14,    35, SPR_IMG_AUTOROAD,           STR_BUILD_AUTOROAD_TIP},            // RTW_AUTOROAD
621
 
{     WWT_IMGBTN,   RESIZE_NONE,     7,    66,    87,    14,    35, SPR_IMG_DYNAMITE,           STR_018D_DEMOLISH_BUILDINGS_ETC},   // RTW_DEMOLISH
622
 
{     WWT_IMGBTN,   RESIZE_NONE,     7,    88,   109,    14,    35, SPR_IMG_ROAD_DEPOT,         STR_180C_BUILD_ROAD_VEHICLE_DEPOT}, // RTW_DEPOT
623
 
{     WWT_IMGBTN,   RESIZE_NONE,     7,   110,   131,    14,    35, SPR_IMG_BUS_STATION,        STR_180D_BUILD_BUS_STATION},        // RTW_BUS_STATION
624
 
{     WWT_IMGBTN,   RESIZE_NONE,     7,   132,   153,    14,    35, SPR_IMG_TRUCK_BAY,          STR_180E_BUILD_TRUCK_LOADING_BAY},  // RTW_TRUCK_STATION
625
 
{     WWT_IMGBTN,   RESIZE_NONE,     7,   154,   175,    14,    35, SPR_IMG_ROAD_ONE_WAY,       STR_TOGGLE_ONE_WAY_ROAD},           // RTW_ONE_WAY
626
 
{     WWT_IMGBTN,   RESIZE_NONE,     7,   176,   218,    14,    35, SPR_IMG_BRIDGE,             STR_180F_BUILD_ROAD_BRIDGE},        // RTW_BUILD_BRIDGE
627
 
{     WWT_IMGBTN,   RESIZE_NONE,     7,   219,   240,    14,    35, SPR_IMG_ROAD_TUNNEL,        STR_1810_BUILD_ROAD_TUNNEL},        // RTW_BUILD_TUNNEL
628
 
{     WWT_IMGBTN,   RESIZE_NONE,     7,   241,   262,    14,    35, SPR_IMG_REMOVE,             STR_1811_TOGGLE_BUILD_REMOVE_FOR},  // RTW_REMOVE
 
632
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,     0,    21,    14,    35, SPR_IMG_ROAD_X_DIR,         STR_180B_BUILD_ROAD_SECTION},       // RTW_ROAD_X
 
633
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,    22,    43,    14,    35, SPR_IMG_ROAD_Y_DIR,         STR_180B_BUILD_ROAD_SECTION},       // RTW_ROAD_Y
 
634
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,    44,    65,    14,    35, SPR_IMG_AUTOROAD,           STR_BUILD_AUTOROAD_TIP},            // RTW_AUTOROAD
 
635
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,    66,    87,    14,    35, SPR_IMG_DYNAMITE,           STR_018D_DEMOLISH_BUILDINGS_ETC},   // RTW_DEMOLISH
 
636
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,    88,   109,    14,    35, SPR_IMG_ROAD_DEPOT,         STR_180C_BUILD_ROAD_VEHICLE_DEPOT}, // RTW_DEPOT
 
637
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,   110,   131,    14,    35, SPR_IMG_BUS_STATION,        STR_180D_BUILD_BUS_STATION},        // RTW_BUS_STATION
 
638
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,   132,   153,    14,    35, SPR_IMG_TRUCK_BAY,          STR_180E_BUILD_TRUCK_LOADING_BAY},  // RTW_TRUCK_STATION
 
639
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,   154,   175,    14,    35, SPR_IMG_ROAD_ONE_WAY,       STR_TOGGLE_ONE_WAY_ROAD},           // RTW_ONE_WAY
 
640
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,   176,   218,    14,    35, SPR_IMG_BRIDGE,             STR_180F_BUILD_ROAD_BRIDGE},        // RTW_BUILD_BRIDGE
 
641
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,   219,   240,    14,    35, SPR_IMG_ROAD_TUNNEL,        STR_1810_BUILD_ROAD_TUNNEL},        // RTW_BUILD_TUNNEL
 
642
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,   241,   262,    14,    35, SPR_IMG_REMOVE,             STR_1811_TOGGLE_BUILD_REMOVE_FOR},  // RTW_REMOVE
629
643
 
630
644
{   WIDGETS_END},
631
645
};
632
646
 
633
 
static const WindowDesc _build_road_desc = {
 
647
static const WindowDesc _build_road_desc(
634
648
        WDP_ALIGN_TBR, 22, 263, 36, 263, 36,
635
649
        WC_BUILD_TOOLBAR, WC_NONE,
636
 
        WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_STICKY_BUTTON,
637
 
        _build_road_widgets,
638
 
        BuildRoadToolbWndProc
639
 
};
 
650
        WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_STICKY_BUTTON | WDF_CONSTRUCTION,
 
651
        _build_road_widgets
 
652
);
640
653
 
641
654
/** Widget definition of the build tram toolbar */
642
655
static const Widget _build_tramway_widgets[] = {
643
 
{   WWT_CLOSEBOX,   RESIZE_NONE,     7,     0,    10,     0,    13, STR_00C5,                       STR_018B_CLOSE_WINDOW},                // RTW_CLOSEBOX
644
 
{    WWT_CAPTION,   RESIZE_NONE,     7,    11,   228,     0,    13, STR_WHITE_TRAMWAY_CONSTRUCTION, STR_018C_WINDOW_TITLE_DRAG_THIS},      // RTW_CAPTION
645
 
{  WWT_STICKYBOX,   RESIZE_NONE,     7,   229,   240,     0,    13, 0x0,                            STR_STICKY_BUTTON},                    // RTW_STICKY
 
656
{   WWT_CLOSEBOX,   RESIZE_NONE,  COLOUR_DARK_GREEN,     0,    10,     0,    13, STR_00C5,                       STR_018B_CLOSE_WINDOW},                // RTW_CLOSEBOX
 
657
{    WWT_CAPTION,   RESIZE_NONE,  COLOUR_DARK_GREEN,    11,   228,     0,    13, STR_WHITE_TRAMWAY_CONSTRUCTION, STR_018C_WINDOW_TITLE_DRAG_THIS},      // RTW_CAPTION
 
658
{  WWT_STICKYBOX,   RESIZE_NONE,  COLOUR_DARK_GREEN,   229,   240,     0,    13, 0x0,                            STR_STICKY_BUTTON},                    // RTW_STICKY
646
659
 
647
 
{     WWT_IMGBTN,   RESIZE_NONE,     7,     0,    21,    14,    35, SPR_IMG_TRAMWAY_X_DIR,          STR_BUILD_TRAMWAY_SECTION},            // RTW_ROAD_X
648
 
{     WWT_IMGBTN,   RESIZE_NONE,     7,    22,    43,    14,    35, SPR_IMG_TRAMWAY_Y_DIR,          STR_BUILD_TRAMWAY_SECTION},            // RTW_ROAD_Y
649
 
{     WWT_IMGBTN,   RESIZE_NONE,     7,    44,    65,    14,    35, SPR_IMG_AUTOTRAM,               STR_BUILD_AUTOTRAM_TIP},               // RTW_AUTOROAD
650
 
{     WWT_IMGBTN,   RESIZE_NONE,     7,    66,    87,    14,    35, SPR_IMG_DYNAMITE,               STR_018D_DEMOLISH_BUILDINGS_ETC},      // RTW_DEMOLISH
651
 
{     WWT_IMGBTN,   RESIZE_NONE,     7,    88,   109,    14,    35, SPR_IMG_ROAD_DEPOT,             STR_BUILD_TRAM_VEHICLE_DEPOT},         // RTW_DEPOT
652
 
{     WWT_IMGBTN,   RESIZE_NONE,     7,   110,   131,    14,    35, SPR_IMG_BUS_STATION,            STR_BUILD_PASSENGER_TRAM_STATION},     // RTW_BUS_STATION
653
 
{     WWT_IMGBTN,   RESIZE_NONE,     7,   132,   153,    14,    35, SPR_IMG_TRUCK_BAY,              STR_BUILD_CARGO_TRAM_STATION},         // RTW_TRUCK_STATION
654
 
{      WWT_EMPTY,   RESIZE_NONE,     0,     0,     0,     0,     0, 0x0,                            STR_NULL},                             // RTW_ONE_WAY
655
 
{     WWT_IMGBTN,   RESIZE_NONE,     7,   154,   196,    14,    35, SPR_IMG_BRIDGE,                 STR_BUILD_TRAMWAY_BRIDGE},             // RTW_BUILD_BRIDGE
656
 
{     WWT_IMGBTN,   RESIZE_NONE,     7,   197,   218,    14,    35, SPR_IMG_ROAD_TUNNEL,            STR_BUILD_TRAMWAY_TUNNEL},             // RTW_BUILD_TUNNEL
657
 
{     WWT_IMGBTN,   RESIZE_NONE,     7,   219,   240,    14,    35, SPR_IMG_REMOVE,                 STR_TOGGLE_BUILD_REMOVE_FOR_TRAMWAYS}, // RTW_REMOVE
 
660
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,     0,    21,    14,    35, SPR_IMG_TRAMWAY_X_DIR,          STR_BUILD_TRAMWAY_SECTION},            // RTW_ROAD_X
 
661
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,    22,    43,    14,    35, SPR_IMG_TRAMWAY_Y_DIR,          STR_BUILD_TRAMWAY_SECTION},            // RTW_ROAD_Y
 
662
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,    44,    65,    14,    35, SPR_IMG_AUTOTRAM,               STR_BUILD_AUTOTRAM_TIP},               // RTW_AUTOROAD
 
663
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,    66,    87,    14,    35, SPR_IMG_DYNAMITE,               STR_018D_DEMOLISH_BUILDINGS_ETC},      // RTW_DEMOLISH
 
664
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,    88,   109,    14,    35, SPR_IMG_ROAD_DEPOT,             STR_BUILD_TRAM_VEHICLE_DEPOT},         // RTW_DEPOT
 
665
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,   110,   131,    14,    35, SPR_IMG_BUS_STATION,            STR_BUILD_PASSENGER_TRAM_STATION},     // RTW_BUS_STATION
 
666
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,   132,   153,    14,    35, SPR_IMG_TRUCK_BAY,              STR_BUILD_CARGO_TRAM_STATION},         // RTW_TRUCK_STATION
 
667
{      WWT_EMPTY,   RESIZE_NONE,  COLOUR_DARK_GREEN,     0,     0,     0,     0, 0x0,                            STR_NULL},                             // RTW_ONE_WAY
 
668
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,   154,   196,    14,    35, SPR_IMG_BRIDGE,                 STR_BUILD_TRAMWAY_BRIDGE},             // RTW_BUILD_BRIDGE
 
669
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,   197,   218,    14,    35, SPR_IMG_ROAD_TUNNEL,            STR_BUILD_TRAMWAY_TUNNEL},             // RTW_BUILD_TUNNEL
 
670
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,   219,   240,    14,    35, SPR_IMG_REMOVE,                 STR_TOGGLE_BUILD_REMOVE_FOR_TRAMWAYS}, // RTW_REMOVE
658
671
 
659
672
{   WIDGETS_END},
660
673
};
661
674
 
662
 
static const WindowDesc _build_tramway_desc = {
 
675
static const WindowDesc _build_tramway_desc(
663
676
        WDP_ALIGN_TBR, 22, 241, 36, 241, 36,
664
677
        WC_BUILD_TOOLBAR, WC_NONE,
665
 
        WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_STICKY_BUTTON,
666
 
        _build_tramway_widgets,
667
 
        BuildRoadToolbWndProc
668
 
};
 
678
        WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_STICKY_BUTTON | WDF_CONSTRUCTION,
 
679
        _build_tramway_widgets
 
680
);
669
681
 
670
682
void ShowBuildRoadToolbar(RoadType roadtype)
671
683
{
672
 
        if (!IsValidPlayer(_current_player)) return;
 
684
        if (!IsValidCompanyID(_local_company)) return;
673
685
        _cur_roadtype = roadtype;
674
686
 
675
 
        DeleteWindowById(WC_BUILD_TOOLBAR, 0);
676
 
        Window *w = AllocateWindowDesc(roadtype == ROADTYPE_ROAD ? &_build_road_desc : &_build_tramway_desc);
677
 
        if (_patches.link_terraform_toolbar) ShowTerraformToolbar(w);
 
687
        DeleteWindowByClass(WC_BUILD_TOOLBAR);
 
688
        AllocateWindowDescFront<BuildRoadToolbarWindow>(roadtype == ROADTYPE_ROAD ? &_build_road_desc : &_build_tramway_desc, TRANSPORT_ROAD);
678
689
}
679
690
 
680
691
/** Widget definition of the build road toolbar in the scenario editor */
681
692
static const Widget _build_road_scen_widgets[] = {
682
 
{   WWT_CLOSEBOX,   RESIZE_NONE,     7,     0,    10,     0,    13, STR_00C5,                   STR_018B_CLOSE_WINDOW},            // RTW_CLOSEBOX
683
 
{    WWT_CAPTION,   RESIZE_NONE,     7,    11,   184,     0,    13, STR_1802_ROAD_CONSTRUCTION, STR_018C_WINDOW_TITLE_DRAG_THIS},  // RTW_CAPTION
684
 
{  WWT_STICKYBOX,   RESIZE_NONE,     7,   185,   196,     0,    13, 0x0,                        STR_STICKY_BUTTON},                // RTW_STICKY
 
693
{   WWT_CLOSEBOX,   RESIZE_NONE,  COLOUR_DARK_GREEN,     0,    10,     0,    13, STR_00C5,                   STR_018B_CLOSE_WINDOW},            // RTW_CLOSEBOX
 
694
{    WWT_CAPTION,   RESIZE_NONE,  COLOUR_DARK_GREEN,    11,   184,     0,    13, STR_1802_ROAD_CONSTRUCTION, STR_018C_WINDOW_TITLE_DRAG_THIS},  // RTW_CAPTION
 
695
{  WWT_STICKYBOX,   RESIZE_NONE,  COLOUR_DARK_GREEN,   185,   196,     0,    13, 0x0,                        STR_STICKY_BUTTON},                // RTW_STICKY
685
696
 
686
 
{     WWT_IMGBTN,   RESIZE_NONE,     7,     0,    21,    14,    35, SPR_IMG_ROAD_X_DIR,         STR_180B_BUILD_ROAD_SECTION},      // RTW_ROAD_X
687
 
{     WWT_IMGBTN,   RESIZE_NONE,     7,    22,    43,    14,    35, SPR_IMG_ROAD_Y_DIR,         STR_180B_BUILD_ROAD_SECTION},      // RTW_ROAD_Y
688
 
{     WWT_IMGBTN,   RESIZE_NONE,     7,    44,    65,    14,    35, SPR_IMG_AUTOROAD,           STR_BUILD_AUTOROAD_TIP},           // RTW_AUTOROAD
689
 
{     WWT_IMGBTN,   RESIZE_NONE,     7,    66,    87,    14,    35, SPR_IMG_DYNAMITE,           STR_018D_DEMOLISH_BUILDINGS_ETC},  // RTW_DEMOLISH
690
 
{      WWT_EMPTY,   RESIZE_NONE,     0,     0,     0,     0,     0, 0x0,                        STR_NULL},                         // RTW_DEPOT
691
 
{      WWT_EMPTY,   RESIZE_NONE,     0,     0,     0,     0,     0, 0x0,                        STR_NULL},                         // RTW_BUS_STATION
692
 
{      WWT_EMPTY,   RESIZE_NONE,     0,     0,     0,     0,     0, 0x0,                        STR_NULL},                         // RTW_TRUCK_STATION
693
 
{     WWT_IMGBTN,   RESIZE_NONE,     7,    88,   109,    14,    35, SPR_IMG_ROAD_ONE_WAY,       STR_TOGGLE_ONE_WAY_ROAD},          // RTW_ONE_WAY
694
 
{     WWT_IMGBTN,   RESIZE_NONE,     7,   110,   152,    14,    35, SPR_IMG_BRIDGE,             STR_180F_BUILD_ROAD_BRIDGE},       // RTW_BUILD_BRIDGE
695
 
{     WWT_IMGBTN,   RESIZE_NONE,     7,   153,   174,    14,    35, SPR_IMG_ROAD_TUNNEL,        STR_1810_BUILD_ROAD_TUNNEL},       // RTW_BUILD_TUNNEL
696
 
{     WWT_IMGBTN,   RESIZE_NONE,     7,   175,   196,    14,    35, SPR_IMG_REMOVE,             STR_1811_TOGGLE_BUILD_REMOVE_FOR}, // RTW_REMOVE
 
697
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,     0,    21,    14,    35, SPR_IMG_ROAD_X_DIR,         STR_180B_BUILD_ROAD_SECTION},      // RTW_ROAD_X
 
698
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,    22,    43,    14,    35, SPR_IMG_ROAD_Y_DIR,         STR_180B_BUILD_ROAD_SECTION},      // RTW_ROAD_Y
 
699
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,    44,    65,    14,    35, SPR_IMG_AUTOROAD,           STR_BUILD_AUTOROAD_TIP},           // RTW_AUTOROAD
 
700
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,    66,    87,    14,    35, SPR_IMG_DYNAMITE,           STR_018D_DEMOLISH_BUILDINGS_ETC},  // RTW_DEMOLISH
 
701
{      WWT_EMPTY,   RESIZE_NONE,  COLOUR_DARK_GREEN,     0,     0,     0,     0, 0x0,                        STR_NULL},                         // RTW_DEPOT
 
702
{      WWT_EMPTY,   RESIZE_NONE,  COLOUR_DARK_GREEN,     0,     0,     0,     0, 0x0,                        STR_NULL},                         // RTW_BUS_STATION
 
703
{      WWT_EMPTY,   RESIZE_NONE,  COLOUR_DARK_GREEN,     0,     0,     0,     0, 0x0,                        STR_NULL},                         // RTW_TRUCK_STATION
 
704
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,    88,   109,    14,    35, SPR_IMG_ROAD_ONE_WAY,       STR_TOGGLE_ONE_WAY_ROAD},          // RTW_ONE_WAY
 
705
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,   110,   152,    14,    35, SPR_IMG_BRIDGE,             STR_180F_BUILD_ROAD_BRIDGE},       // RTW_BUILD_BRIDGE
 
706
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,   153,   174,    14,    35, SPR_IMG_ROAD_TUNNEL,        STR_1810_BUILD_ROAD_TUNNEL},       // RTW_BUILD_TUNNEL
 
707
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,   175,   196,    14,    35, SPR_IMG_REMOVE,             STR_1811_TOGGLE_BUILD_REMOVE_FOR}, // RTW_REMOVE
697
708
{   WIDGETS_END},
698
709
};
699
710
 
700
 
static const WindowDesc _build_road_scen_desc = {
 
711
static const WindowDesc _build_road_scen_desc(
701
712
        WDP_AUTO, WDP_AUTO, 197, 36, 197, 36,
702
 
        WC_SCEN_BUILD_ROAD, WC_NONE,
703
 
        WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_STICKY_BUTTON,
704
 
        _build_road_scen_widgets,
705
 
        BuildRoadToolbWndProc
706
 
};
 
713
        WC_SCEN_BUILD_TOOLBAR, WC_NONE,
 
714
        WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_STICKY_BUTTON | WDF_CONSTRUCTION,
 
715
        _build_road_scen_widgets
 
716
);
707
717
 
708
718
void ShowBuildRoadScenToolbar()
709
719
{
710
720
        _cur_roadtype = ROADTYPE_ROAD;
711
 
        AllocateWindowDescFront(&_build_road_scen_desc, 0);
 
721
        AllocateWindowDescFront<BuildRoadToolbarWindow>(&_build_road_scen_desc, 0);
712
722
}
713
723
 
714
 
/** Enum referring to the widgets of the build road depot window */
715
 
enum BuildRoadDepotWidgets {
716
 
        BRDW_CLOSEBOX = 0,
717
 
        BRDW_CAPTION,
718
 
        BRDW_BACKGROUND,
719
 
        BRDW_DEPOT_NE,
720
 
        BRDW_DEPOT_SE,
721
 
        BRDW_DEPOT_SW,
722
 
        BRDW_DEPOT_NW,
723
 
};
724
 
 
725
 
static void BuildRoadDepotWndProc(Window *w, WindowEvent *e)
726
 
{
727
 
        switch (e->event) {
728
 
        case WE_CREATE: w->LowerWidget(_road_depot_orientation + BRDW_DEPOT_NE); break;
729
 
 
730
 
        case WE_PAINT:
731
 
                DrawWindowWidgets(w);
 
724
struct BuildRoadDepotWindow : public PickerWindowBase {
 
725
private:
 
726
        /** Enum referring to the widgets of the build road depot window */
 
727
        enum BuildRoadDepotWidgets {
 
728
                BRDW_CLOSEBOX = 0,
 
729
                BRDW_CAPTION,
 
730
                BRDW_BACKGROUND,
 
731
                BRDW_DEPOT_NE,
 
732
                BRDW_DEPOT_SE,
 
733
                BRDW_DEPOT_SW,
 
734
                BRDW_DEPOT_NW,
 
735
        };
 
736
 
 
737
public:
 
738
        BuildRoadDepotWindow(const WindowDesc *desc, Window *parent) : PickerWindowBase(desc, parent)
 
739
        {
 
740
                this->LowerWidget(_road_depot_orientation + BRDW_DEPOT_NE);
 
741
                if ( _cur_roadtype == ROADTYPE_TRAM) {
 
742
                        this->widget[BRDW_CAPTION].data = STR_TRAM_DEPOT_ORIENTATION;
 
743
                        for (int i = BRDW_DEPOT_NE; i <= BRDW_DEPOT_NW; i++) this->widget[i].tooltips = STR_SELECT_TRAM_VEHICLE_DEPOT;
 
744
                }
 
745
                this->FindWindowPlacementAndResize(desc);
 
746
        }
 
747
 
 
748
        virtual void OnPaint()
 
749
        {
 
750
                this->DrawWidgets();
732
751
 
733
752
                DrawRoadDepotSprite(70, 17, DIAGDIR_NE, _cur_roadtype);
734
753
                DrawRoadDepotSprite(70, 69, DIAGDIR_SE, _cur_roadtype);
735
754
                DrawRoadDepotSprite( 2, 69, DIAGDIR_SW, _cur_roadtype);
736
755
                DrawRoadDepotSprite( 2, 17, DIAGDIR_NW, _cur_roadtype);
737
 
                break;
 
756
        }
738
757
 
739
 
        case WE_CLICK:
740
 
                switch (e->we.click.widget) {
 
758
        virtual void OnClick(Point pt, int widget)
 
759
        {
 
760
                switch (widget) {
741
761
                        case BRDW_DEPOT_NW:
742
762
                        case BRDW_DEPOT_NE:
743
763
                        case BRDW_DEPOT_SW:
744
764
                        case BRDW_DEPOT_SE:
745
 
                                w->RaiseWidget(_road_depot_orientation + BRDW_DEPOT_NE);
746
 
                                _road_depot_orientation = (DiagDirection)(e->we.click.widget - BRDW_DEPOT_NE);
747
 
                                w->LowerWidget(_road_depot_orientation + BRDW_DEPOT_NE);
 
765
                                this->RaiseWidget(_road_depot_orientation + BRDW_DEPOT_NE);
 
766
                                _road_depot_orientation = (DiagDirection)(widget - BRDW_DEPOT_NE);
 
767
                                this->LowerWidget(_road_depot_orientation + BRDW_DEPOT_NE);
748
768
                                SndPlayFx(SND_15_BEEP);
749
 
                                SetWindowDirty(w);
 
769
                                this->SetDirty();
 
770
                                break;
 
771
 
 
772
                        default:
750
773
                                break;
751
774
                }
752
 
                break;
753
 
 
754
 
        case WE_MOUSELOOP:
755
 
                if (WP(w, def_d).close) DeleteWindow(w);
756
 
                break;
757
 
 
758
 
        case WE_DESTROY:
759
 
                if (!WP(w, def_d).close) ResetObjectToPlace();
760
 
                break;
761
775
        }
762
 
}
 
776
};
763
777
 
764
778
/** Widget definition of the build road depot window */
765
779
static const Widget _build_road_depot_widgets[] = {
766
 
{   WWT_CLOSEBOX,   RESIZE_NONE,     7,     0,    10,     0,    13, STR_00C5,                        STR_018B_CLOSE_WINDOW},              // BRDW_CLOSEBOX
767
 
{    WWT_CAPTION,   RESIZE_NONE,     7,    11,   139,     0,    13, STR_1806_ROAD_DEPOT_ORIENTATION, STR_018C_WINDOW_TITLE_DRAG_THIS},    // BRDW_CAPTION
768
 
{      WWT_PANEL,   RESIZE_NONE,     7,     0,   139,    14,   121, 0x0,                             STR_NULL},                           // BRDW_BACKGROUND
769
 
{      WWT_PANEL,   RESIZE_NONE,    14,    71,   136,    17,    66, 0x0,                             STR_1813_SELECT_ROAD_VEHICLE_DEPOT}, // BRDW_DEPOT_NE
770
 
{      WWT_PANEL,   RESIZE_NONE,    14,    71,   136,    69,   118, 0x0,                             STR_1813_SELECT_ROAD_VEHICLE_DEPOT}, // BRDW_DEPOT_SE
771
 
{      WWT_PANEL,   RESIZE_NONE,    14,     3,    68,    69,   118, 0x0,                             STR_1813_SELECT_ROAD_VEHICLE_DEPOT}, // BRDW_DEPOT_SW
772
 
{      WWT_PANEL,   RESIZE_NONE,    14,     3,    68,    17,    66, 0x0,                             STR_1813_SELECT_ROAD_VEHICLE_DEPOT}, // BRDW_DEPOT_NW
773
 
{   WIDGETS_END},
774
 
};
775
 
 
776
 
/** Widget definition of the build tram depot window */
777
 
static const Widget _build_tram_depot_widgets[] = {
778
 
{   WWT_CLOSEBOX,   RESIZE_NONE,     7,     0,    10,     0,    13, STR_00C5,                        STR_018B_CLOSE_WINDOW},              // BRDW_CLOSEBOX
779
 
{    WWT_CAPTION,   RESIZE_NONE,     7,    11,   139,     0,    13, STR_TRAM_DEPOT_ORIENTATION,      STR_018C_WINDOW_TITLE_DRAG_THIS},    // BRDW_CAPTION
780
 
{      WWT_PANEL,   RESIZE_NONE,     7,     0,   139,    14,   121, 0x0,                             STR_NULL},                           // BRDW_BACKGROUND
781
 
{      WWT_PANEL,   RESIZE_NONE,    14,    71,   136,    17,    66, 0x0,                             STR_SELECT_TRAM_VEHICLE_DEPOT},      // BRDW_DEPOT_NE
782
 
{      WWT_PANEL,   RESIZE_NONE,    14,    71,   136,    69,   118, 0x0,                             STR_SELECT_TRAM_VEHICLE_DEPOT},      // BRDW_DEPOT_SE
783
 
{      WWT_PANEL,   RESIZE_NONE,    14,     3,    68,    69,   118, 0x0,                             STR_SELECT_TRAM_VEHICLE_DEPOT},      // BRDW_DEPOT_SW
784
 
{      WWT_PANEL,   RESIZE_NONE,    14,     3,    68,    17,    66, 0x0,                             STR_SELECT_TRAM_VEHICLE_DEPOT},      // BRDW_DEPOT_NW
785
 
{   WIDGETS_END},
786
 
};
787
 
 
788
 
static const WindowDesc _build_road_depot_desc = {
789
 
        WDP_AUTO, WDP_AUTO, 140, 122, 140, 122,
790
 
        WC_BUILD_DEPOT, WC_BUILD_TOOLBAR,
791
 
        WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET,
792
 
        _build_road_depot_widgets,
793
 
        BuildRoadDepotWndProc
794
 
};
795
 
 
796
 
static const WindowDesc _build_tram_depot_desc = {
797
 
        WDP_AUTO, WDP_AUTO, 140, 122, 140, 122,
798
 
        WC_BUILD_DEPOT, WC_BUILD_TOOLBAR,
799
 
        WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET,
800
 
        _build_tram_depot_widgets,
801
 
        BuildRoadDepotWndProc
802
 
};
803
 
 
804
 
static void ShowRoadDepotPicker()
 
780
{   WWT_CLOSEBOX,   RESIZE_NONE,  COLOUR_DARK_GREEN,    0,    10,     0,    13, STR_00C5,                        STR_018B_CLOSE_WINDOW},              // BRDW_CLOSEBOX
 
781
{    WWT_CAPTION,   RESIZE_NONE,  COLOUR_DARK_GREEN,   11,   139,     0,    13, STR_1806_ROAD_DEPOT_ORIENTATION, STR_018C_WINDOW_TITLE_DRAG_THIS},    // BRDW_CAPTION
 
782
{      WWT_PANEL,   RESIZE_NONE,  COLOUR_DARK_GREEN,    0,   139,    14,   121, 0x0,                             STR_NULL},                           // BRDW_BACKGROUND
 
783
{      WWT_PANEL,   RESIZE_NONE,  COLOUR_GREY,         71,   136,    17,    66, 0x0,                             STR_1813_SELECT_ROAD_VEHICLE_DEPOT}, // BRDW_DEPOT_NE
 
784
{      WWT_PANEL,   RESIZE_NONE,  COLOUR_GREY,         71,   136,    69,   118, 0x0,                             STR_1813_SELECT_ROAD_VEHICLE_DEPOT}, // BRDW_DEPOT_SE
 
785
{      WWT_PANEL,   RESIZE_NONE,  COLOUR_GREY,          3,    68,    69,   118, 0x0,                             STR_1813_SELECT_ROAD_VEHICLE_DEPOT}, // BRDW_DEPOT_SW
 
786
{      WWT_PANEL,   RESIZE_NONE,  COLOUR_GREY,          3,    68,    17,    66, 0x0,                             STR_1813_SELECT_ROAD_VEHICLE_DEPOT}, // BRDW_DEPOT_NW
 
787
{   WIDGETS_END},
 
788
};
 
789
 
 
790
static const WindowDesc _build_road_depot_desc(
 
791
        WDP_AUTO, WDP_AUTO, 140, 122, 140, 122,
 
792
        WC_BUILD_DEPOT, WC_BUILD_TOOLBAR,
 
793
        WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_CONSTRUCTION,
 
794
        _build_road_depot_widgets
 
795
);
 
796
 
 
797
static void ShowRoadDepotPicker(Window *parent)
805
798
{
806
 
        AllocateWindowDesc(_cur_roadtype == ROADTYPE_ROAD ? &_build_road_depot_desc : &_build_tram_depot_desc);
 
799
        new BuildRoadDepotWindow(&_build_road_depot_desc, parent);
807
800
}
808
801
 
809
 
/** Enum referring to the widgets of the build road station window */
810
 
enum BuildRoadStationWidgets {
811
 
        BRSW_CLOSEBOX = 0,
812
 
        BRSW_CAPTION,
813
 
        BRSW_BACKGROUND,
814
 
        BRSW_STATION_NE,
815
 
        BRSW_STATION_SE,
816
 
        BRSW_STATION_SW,
817
 
        BRSW_STATION_NW,
818
 
        BRSW_STATION_X,
819
 
        BRSW_STATION_Y,
820
 
        BRSW_LT_OFF,
821
 
        BRSW_LT_ON,
822
 
        BRSW_INFO,
823
 
};
 
802
struct BuildRoadStationWindow : public PickerWindowBase {
 
803
private:
 
804
        /** Enum referring to the widgets of the build road station window */
 
805
        enum BuildRoadStationWidgets {
 
806
                BRSW_CLOSEBOX = 0,
 
807
                BRSW_CAPTION,
 
808
                BRSW_BACKGROUND,
 
809
                BRSW_STATION_NE,
 
810
                BRSW_STATION_SE,
 
811
                BRSW_STATION_SW,
 
812
                BRSW_STATION_NW,
 
813
                BRSW_STATION_X,
 
814
                BRSW_STATION_Y,
 
815
                BRSW_LT_OFF,
 
816
                BRSW_LT_ON,
 
817
                BRSW_INFO,
 
818
        };
824
819
 
825
 
static void RoadStationPickerWndProc(Window *w, WindowEvent *e)
826
 
{
827
 
        switch (e->event) {
828
 
        case WE_CREATE:
 
820
public:
 
821
        BuildRoadStationWindow(const WindowDesc *desc, Window *parent, RoadStopType rs) : PickerWindowBase(desc, parent)
 
822
        {
829
823
                /* Trams don't have non-drivethrough stations */
830
824
                if (_cur_roadtype == ROADTYPE_TRAM && _road_station_picker_orientation < DIAGDIR_END) {
831
825
                        _road_station_picker_orientation = DIAGDIR_END;
832
826
                }
833
 
                w->SetWidgetsDisabledState(_cur_roadtype == ROADTYPE_TRAM,
 
827
                this->SetWidgetsDisabledState(_cur_roadtype == ROADTYPE_TRAM,
834
828
                        BRSW_STATION_NE,
835
829
                        BRSW_STATION_SE,
836
830
                        BRSW_STATION_SW,
837
831
                        BRSW_STATION_NW,
838
832
                        WIDGET_LIST_END);
839
833
 
840
 
                w->LowerWidget(_road_station_picker_orientation + BRSW_STATION_NE);
841
 
                w->LowerWidget(_station_show_coverage + BRSW_LT_OFF);
842
 
                break;
843
 
 
844
 
        case WE_PAINT: {
845
 
                if (WP(w, def_d).close) return;
846
 
 
847
 
                DrawWindowWidgets(w);
848
 
 
849
 
                if (_station_show_coverage) {
850
 
                        int rad = _patches.modified_catchment ? CA_TRUCK /* = CA_BUS */ : CA_UNMODIFIED;
 
834
                this->window_class = (rs == ROADSTOP_BUS) ? WC_BUS_STATION : WC_TRUCK_STATION;
 
835
                this->widget[BRSW_CAPTION].data = _road_type_infos[_cur_roadtype].picker_title[rs];
 
836
                for (uint i = BRSW_STATION_NE; i < BRSW_LT_OFF; i++) this->widget[i].tooltips = _road_type_infos[_cur_roadtype].picker_tooltip[rs];
 
837
 
 
838
                this->LowerWidget(_road_station_picker_orientation + BRSW_STATION_NE);
 
839
                this->LowerWidget(_settings_client.gui.station_show_coverage + BRSW_LT_OFF);
 
840
                this->FindWindowPlacementAndResize(desc);
 
841
        }
 
842
 
 
843
        virtual ~BuildRoadStationWindow()
 
844
        {
 
845
                DeleteWindowById(WC_SELECT_STATION, 0);
 
846
        }
 
847
 
 
848
        virtual void OnPaint()
 
849
        {
 
850
                this->DrawWidgets();
 
851
 
 
852
                if (_settings_client.gui.station_show_coverage) {
 
853
                        int rad = _settings_game.station.modified_catchment ? CA_TRUCK /* = CA_BUS */ : CA_UNMODIFIED;
851
854
                        SetTileSelectBigSize(-rad, -rad, 2 * rad, 2 * rad);
852
855
                } else {
853
856
                        SetTileSelectSize(1, 1);
854
857
                }
855
858
 
856
 
                StationType st = (w->window_class == WC_BUS_STATION) ? STATION_BUS : STATION_TRUCK;
 
859
                StationType st = (this->window_class == WC_BUS_STATION) ? STATION_BUS : STATION_TRUCK;
857
860
 
858
861
                StationPickerDrawSprite(103, 35, st, INVALID_RAILTYPE, ROADTYPE_ROAD, 0);
859
862
                StationPickerDrawSprite(103, 85, st, INVALID_RAILTYPE, ROADTYPE_ROAD, 1);
864
867
                StationPickerDrawSprite(171, 85, st, INVALID_RAILTYPE, _cur_roadtype, 5);
865
868
 
866
869
                int text_end = DrawStationCoverageAreaText(2, 146,
867
 
                        (w->window_class == WC_BUS_STATION) ? SCT_PASSENGERS_ONLY : SCT_NON_PASSENGERS_ONLY,
868
 
                        3) + 4;
869
 
                if (text_end > w->widget[BRSW_BACKGROUND].bottom) {
870
 
                        SetWindowDirty(w);
871
 
                        ResizeWindowForWidget(w, BRSW_BACKGROUND, 0, text_end - w->widget[BRSW_BACKGROUND].bottom);
872
 
                        SetWindowDirty(w);
 
870
                        (this->window_class == WC_BUS_STATION) ? SCT_PASSENGERS_ONLY : SCT_NON_PASSENGERS_ONLY,
 
871
                        3, false);
 
872
                text_end = DrawStationCoverageAreaText(2, text_end + 4,
 
873
                        (this->window_class == WC_BUS_STATION) ? SCT_PASSENGERS_ONLY : SCT_NON_PASSENGERS_ONLY,
 
874
                        3, true) + 4;
 
875
                if (text_end > this->widget[BRSW_BACKGROUND].bottom) {
 
876
                        this->SetDirty();
 
877
                        ResizeWindowForWidget(this, BRSW_BACKGROUND, 0, text_end - this->widget[BRSW_BACKGROUND].bottom);
 
878
                        this->SetDirty();
873
879
                }
874
 
 
875
 
        } break;
876
 
 
877
 
        case WE_CLICK: {
878
 
                switch (e->we.click.widget) {
 
880
        }
 
881
 
 
882
        virtual void OnClick(Point pt, int widget)
 
883
        {
 
884
                switch (widget) {
879
885
                        case BRSW_STATION_NE:
880
886
                        case BRSW_STATION_SE:
881
887
                        case BRSW_STATION_SW:
882
888
                        case BRSW_STATION_NW:
883
889
                        case BRSW_STATION_X:
884
890
                        case BRSW_STATION_Y:
885
 
                                w->RaiseWidget(_road_station_picker_orientation + BRSW_STATION_NE);
886
 
                                _road_station_picker_orientation = (DiagDirection)(e->we.click.widget - BRSW_STATION_NE);
887
 
                                w->LowerWidget(_road_station_picker_orientation + BRSW_STATION_NE);
 
891
                                this->RaiseWidget(_road_station_picker_orientation + BRSW_STATION_NE);
 
892
                                _road_station_picker_orientation = (DiagDirection)(widget - BRSW_STATION_NE);
 
893
                                this->LowerWidget(_road_station_picker_orientation + BRSW_STATION_NE);
888
894
                                SndPlayFx(SND_15_BEEP);
889
 
                                SetWindowDirty(w);
 
895
                                this->SetDirty();
 
896
                                DeleteWindowById(WC_SELECT_STATION, 0);
890
897
                                break;
891
898
 
892
899
                        case BRSW_LT_OFF:
893
900
                        case BRSW_LT_ON:
894
 
                                w->RaiseWidget(_station_show_coverage + BRSW_LT_OFF);
895
 
                                _station_show_coverage = (e->we.click.widget != BRSW_LT_OFF);
896
 
                                w->LowerWidget(_station_show_coverage + BRSW_LT_OFF);
 
901
                                this->RaiseWidget(_settings_client.gui.station_show_coverage + BRSW_LT_OFF);
 
902
                                _settings_client.gui.station_show_coverage = (widget != BRSW_LT_OFF);
 
903
                                this->LowerWidget(_settings_client.gui.station_show_coverage + BRSW_LT_OFF);
897
904
                                SndPlayFx(SND_15_BEEP);
898
 
                                SetWindowDirty(w);
899
 
                                break;
900
 
                }
901
 
        } break;
902
 
 
903
 
        case WE_MOUSELOOP: {
904
 
                if (WP(w, def_d).close) {
905
 
                        DeleteWindow(w);
906
 
                        return;
907
 
                }
908
 
 
909
 
                CheckRedrawStationCoverage(w);
910
 
        } break;
911
 
 
912
 
        case WE_DESTROY:
913
 
                if (!WP(w, def_d).close) ResetObjectToPlace();
914
 
                break;
915
 
        }
916
 
}
 
905
                                this->SetDirty();
 
906
                                break;
 
907
 
 
908
                        default:
 
909
                                break;
 
910
                }
 
911
        }
 
912
 
 
913
        virtual void OnTick()
 
914
        {
 
915
                CheckRedrawStationCoverage(this);
 
916
        }
 
917
};
917
918
 
918
919
/** Widget definition of the build raod station window */
919
920
static const Widget _rv_station_picker_widgets[] = {
920
 
{   WWT_CLOSEBOX,   RESIZE_NONE,     7,     0,    10,     0,    13, STR_00C5,                         STR_018B_CLOSE_WINDOW},             // BRSW_CLOSEBOX
921
 
{    WWT_CAPTION,   RESIZE_NONE,     7,    11,   206,     0,    13, STR_NULL,                         STR_018C_WINDOW_TITLE_DRAG_THIS},   // BRSW_CAPTION
922
 
{      WWT_PANEL,   RESIZE_NONE,     7,     0,   206,    14,   176, 0x0,                              STR_NULL},                          // BRSW_BACKGROUND
923
 
 
924
 
{      WWT_PANEL,   RESIZE_NONE,    14,    71,   136,    17,    66, 0x0,                              STR_NULL},                          // BRSW_STATION_NE
925
 
{      WWT_PANEL,   RESIZE_NONE,    14,    71,   136,    69,   118, 0x0,                              STR_NULL},                          // BRSW_STATION_SE
926
 
{      WWT_PANEL,   RESIZE_NONE,    14,     3,    68,    69,   118, 0x0,                              STR_NULL},                          // BRSW_STATION_SW
927
 
{      WWT_PANEL,   RESIZE_NONE,    14,     3,    68,    17,    66, 0x0,                              STR_NULL},                          // BRSW_STATION_NW
928
 
{      WWT_PANEL,   RESIZE_NONE,    14,   139,   204,    17,    66, 0x0,                              STR_NULL},                          // BRSW_STATION_X
929
 
{      WWT_PANEL,   RESIZE_NONE,    14,   139,   204,    69,   118, 0x0,                              STR_NULL},                          // BRSW_STATION_Y
930
 
 
931
 
{    WWT_TEXTBTN,   RESIZE_NONE,    14,    10,    69,   133,   144, STR_02DB_OFF,                     STR_3065_DON_T_HIGHLIGHT_COVERAGE}, // BRSW_LT_OFF
932
 
{    WWT_TEXTBTN,   RESIZE_NONE,    14,    70,   129,   133,   144, STR_02DA_ON,                      STR_3064_HIGHLIGHT_COVERAGE_AREA},  // BRSW_LT_ON
933
 
{      WWT_LABEL,   RESIZE_NONE,     7,     0,   139,   120,   133, STR_3066_COVERAGE_AREA_HIGHLIGHT, STR_NULL},                          // BRSW_INFO
 
921
{   WWT_CLOSEBOX,   RESIZE_NONE,  COLOUR_DARK_GREEN,   0,    10,     0,    13, STR_00C5,                         STR_018B_CLOSE_WINDOW},             // BRSW_CLOSEBOX
 
922
{    WWT_CAPTION,   RESIZE_NONE,  COLOUR_DARK_GREEN,  11,   206,     0,    13, STR_NULL,                         STR_018C_WINDOW_TITLE_DRAG_THIS},   // BRSW_CAPTION
 
923
{      WWT_PANEL,   RESIZE_NONE,  COLOUR_DARK_GREEN,   0,   206,    14,   176, 0x0,                              STR_NULL},                          // BRSW_BACKGROUND
 
924
 
 
925
{      WWT_PANEL,   RESIZE_NONE,  COLOUR_GREY,        71,   136,    17,    66, 0x0,                              STR_NULL},                          // BRSW_STATION_NE
 
926
{      WWT_PANEL,   RESIZE_NONE,  COLOUR_GREY,        71,   136,    69,   118, 0x0,                              STR_NULL},                          // BRSW_STATION_SE
 
927
{      WWT_PANEL,   RESIZE_NONE,  COLOUR_GREY,         3,    68,    69,   118, 0x0,                              STR_NULL},                          // BRSW_STATION_SW
 
928
{      WWT_PANEL,   RESIZE_NONE,  COLOUR_GREY,         3,    68,    17,    66, 0x0,                              STR_NULL},                          // BRSW_STATION_NW
 
929
{      WWT_PANEL,   RESIZE_NONE,  COLOUR_GREY,       139,   204,    17,    66, 0x0,                              STR_NULL},                          // BRSW_STATION_X
 
930
{      WWT_PANEL,   RESIZE_NONE,  COLOUR_GREY,       139,   204,    69,   118, 0x0,                              STR_NULL},                          // BRSW_STATION_Y
 
931
 
 
932
{    WWT_TEXTBTN,   RESIZE_NONE,  COLOUR_GREY,        10,    69,   133,   144, STR_02DB_OFF,                     STR_3065_DON_T_HIGHLIGHT_COVERAGE}, // BRSW_LT_OFF
 
933
{    WWT_TEXTBTN,   RESIZE_NONE,  COLOUR_GREY,        70,   129,   133,   144, STR_02DA_ON,                      STR_3064_HIGHLIGHT_COVERAGE_AREA},  // BRSW_LT_ON
 
934
{      WWT_LABEL,   RESIZE_NONE,  COLOUR_DARK_GREEN,   0,   139,   120,   133, STR_3066_COVERAGE_AREA_HIGHLIGHT, STR_NULL},                          // BRSW_INFO
934
935
{   WIDGETS_END},
935
936
};
936
937
 
937
 
static const WindowDesc _rv_station_picker_desc = {
 
938
static const WindowDesc _rv_station_picker_desc(
938
939
        WDP_AUTO, WDP_AUTO, 207, 177, 207, 177,
939
940
        WC_BUS_STATION, WC_BUILD_TOOLBAR,
940
 
        WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET,
941
 
        _rv_station_picker_widgets,
942
 
        RoadStationPickerWndProc
943
 
};
 
941
        WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_CONSTRUCTION,
 
942
        _rv_station_picker_widgets
 
943
);
944
944
 
945
 
static void ShowRVStationPicker(RoadStop::Type rs)
 
945
static void ShowRVStationPicker(Window *parent, RoadStopType rs)
946
946
{
947
 
        Window *w = AllocateWindowDesc(&_rv_station_picker_desc);
948
 
        if (w == NULL) return;
949
 
 
950
 
        w->window_class = (rs == RoadStop::BUS) ? WC_BUS_STATION : WC_TRUCK_STATION;
951
 
        w->widget[BRSW_CAPTION].data = _road_type_infos[_cur_roadtype].picker_title[rs];
952
 
        for (uint i = BRSW_STATION_NE; i < BRSW_LT_OFF; i++) w->widget[i].tooltips = _road_type_infos[_cur_roadtype].picker_tooltip[rs];
 
947
        new BuildRoadStationWindow(&_rv_station_picker_desc, parent, rs);
953
948
}
954
949
 
955
950
void InitializeRoadGui()