rail_gui.cpp

Go to the documentation of this file.

/* $Id: rail_gui.cpp 14422 2008-09-30 20:51:04Z rubidium $ */

#include "stdafx.h"
#include "direction_type.h"
#include "openttd.h"
#include "tile_cmd.h"
#include "landscape.h"
#include "gui.h"
#include "window_gui.h"
#include "station_gui.h"
#include "terraform_gui.h"
#include "viewport_func.h"
#include "gfx_func.h"
#include "command_func.h"
#include "town_type.h"
#include "waypoint.h"
#include "debug.h"
#include "variables.h"
#include "newgrf_callbacks.h"
#include "newgrf_station.h"
#include "train.h"
#include "strings_func.h"
#include "functions.h"
#include "window_func.h"
#include "date_func.h"
#include "sound_func.h"
#include "company_func.h"
#include "settings_type.h"
#include "widgets/dropdown_type.h"
#include "widgets/dropdown_func.h"
#include "tunnelbridge.h"
#include "tilehighlight_func.h"

#include "bridge_map.h"
#include "rail_map.h"
#include "road_map.h"
#include "station_map.h"
#include "tunnel_map.h"
#include "tunnelbridge_map.h"

#include "table/sprites.h"
#include "table/strings.h"

static RailType _cur_railtype;               
static bool _remove_button_clicked;          
static DiagDirection _build_depot_direction; 
static byte _waypoint_count = 1;             
static byte _cur_waypoint_type;              
static bool _convert_signal_button;          
static SignalVariant _cur_signal_variant;    
static SignalType _cur_signal_type;          

/* Map _patches.default_signal_type to the corresponding signal type */
static const SignalType _default_signal_type[] = {SIGTYPE_NORMAL, SIGTYPE_PBS, SIGTYPE_PBS_ONEWAY};

struct RailStationGUISettings {
  Axis orientation;                 
  byte numtracks;                   
  byte platlength;                  
  bool dragdrop;                    

  bool newstations;                 
  StationClassIDByte station_class; 
  byte station_type;                
  byte station_count;               
};
static RailStationGUISettings _railstation; 


static void HandleStationPlacement(TileIndex start, TileIndex end);
static void ShowBuildTrainDepotPicker(Window *parent);
static void ShowBuildWaypointPicker(Window *parent);
static void ShowStationBuilder(Window *parent);
static void ShowSignalBuilder(Window *parent);

void CcPlaySound1E(bool success, TileIndex tile, uint32 p1, uint32 p2)
{
  if (success) SndPlayTileFx(SND_20_SPLAT_2, tile);
}

static void GenericPlaceRail(TileIndex tile, int cmd)
{
  DoCommandP(tile, _cur_railtype, cmd, CcPlaySound1E,
    _remove_button_clicked ?
    CMD_REMOVE_SINGLE_RAIL | CMD_MSG(STR_1012_CAN_T_REMOVE_RAILROAD_TRACK) | CMD_NO_WATER :
    CMD_BUILD_SINGLE_RAIL | CMD_MSG(STR_1011_CAN_T_BUILD_RAILROAD_TRACK) | CMD_NO_WATER
  );
}

static void PlaceRail_N(TileIndex tile)
{
  int cmd = _tile_fract_coords.x > _tile_fract_coords.y ? 4 : 5;
  GenericPlaceRail(tile, cmd);
}

static void PlaceRail_NE(TileIndex tile)
{
  VpStartPlaceSizing(tile, VPM_FIX_Y, DDSP_PLACE_RAIL_NE);
}

static void PlaceRail_E(TileIndex tile)
{
  int cmd = _tile_fract_coords.x + _tile_fract_coords.y <= 15 ? 2 : 3;
  GenericPlaceRail(tile, cmd);
}

static void PlaceRail_NW(TileIndex tile)
{
  VpStartPlaceSizing(tile, VPM_FIX_X, DDSP_PLACE_RAIL_NW);
}

static void PlaceRail_AutoRail(TileIndex tile)
{
  VpStartPlaceSizing(tile, VPM_RAILDIRS, DDSP_PLACE_AUTORAIL);
}

static void PlaceExtraDepotRail(TileIndex tile, uint16 extra)
{
  if (GetRailTileType(tile) != RAIL_TILE_NORMAL) return;
  if ((GetTrackBits(tile) & GB(extra, 8, 8)) == 0) return;

  DoCommandP(tile, _cur_railtype, extra & 0xFF, NULL, CMD_BUILD_SINGLE_RAIL | CMD_NO_WATER);
}

static const uint16 _place_depot_extra[12] = {
  0x0604, 0x2102, 0x1202, 0x0505,  // First additional track for directions 0..3
  0x2400, 0x2801, 0x1800, 0x1401,  // Second additional track
  0x2203, 0x0904, 0x0A05, 0x1103,  // Third additional track
};


void CcRailDepot(bool success, TileIndex tile, uint32 p1, uint32 p2)
{
  if (success) {
    DiagDirection dir = (DiagDirection)p2;

    SndPlayTileFx(SND_20_SPLAT_2, tile);
    ResetObjectToPlace();

    tile += TileOffsByDiagDir(dir);

    if (IsTileType(tile, MP_RAILWAY)) {
      PlaceExtraDepotRail(tile, _place_depot_extra[dir]);
      PlaceExtraDepotRail(tile, _place_depot_extra[dir + 4]);
      PlaceExtraDepotRail(tile, _place_depot_extra[dir + 8]);
    }
  }
}

static void PlaceRail_Depot(TileIndex tile)
{
  DoCommandP(tile, _cur_railtype, _build_depot_direction, CcRailDepot,
    CMD_BUILD_TRAIN_DEPOT | CMD_NO_WATER | CMD_MSG(STR_100E_CAN_T_BUILD_TRAIN_DEPOT));
}

static void PlaceRail_Waypoint(TileIndex tile)
{
  if (_remove_button_clicked) {
    DoCommandP(tile, 0, 0, CcPlaySound1E, CMD_REMOVE_TRAIN_WAYPOINT | CMD_MSG(STR_CANT_REMOVE_TRAIN_WAYPOINT));
  } else {
    DoCommandP(tile, _cur_waypoint_type, 0, CcPlaySound1E, CMD_BUILD_TRAIN_WAYPOINT | CMD_MSG(STR_CANT_BUILD_TRAIN_WAYPOINT));
  }
}

void CcStation(bool success, TileIndex tile, uint32 p1, uint32 p2)
{
  if (success) {
    SndPlayTileFx(SND_20_SPLAT_2, tile);
    /* Only close the station builder window if the default station is chosen. */
    if (_railstation.station_class == STAT_CLASS_DFLT && _railstation.station_type == 0) ResetObjectToPlace();
  }
}

static void PlaceRail_Station(TileIndex tile)
{
  if (_remove_button_clicked) {
    VpStartPlaceSizing(tile, VPM_X_AND_Y_LIMITED, DDSP_REMOVE_STATION);
    VpSetPlaceSizingLimit(-1);
  } else if (_railstation.dragdrop) {
    VpStartPlaceSizing(tile, VPM_X_AND_Y_LIMITED, DDSP_BUILD_STATION);
    VpSetPlaceSizingLimit(_settings_game.station.station_spread);
  } else {
    DoCommandP(tile,
        _railstation.orientation | (_railstation.numtracks << 8) | (_railstation.platlength << 16) | (_ctrl_pressed << 24),
        _cur_railtype | (_railstation.station_class << 8) | (_railstation.station_type << 16), CcStation,
        CMD_BUILD_RAILROAD_STATION | CMD_NO_WATER | CMD_MSG(STR_100F_CAN_T_BUILD_RAILROAD_STATION));
  }
}

static void GenericPlaceSignals(TileIndex tile)
{
  TrackBits trackbits = TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, 0));

  if (trackbits & TRACK_BIT_VERT) { // N-S direction
    trackbits = (_tile_fract_coords.x <= _tile_fract_coords.y) ? TRACK_BIT_RIGHT : TRACK_BIT_LEFT;
  }

  if (trackbits & TRACK_BIT_HORZ) { // E-W direction
    trackbits = (_tile_fract_coords.x + _tile_fract_coords.y <= 15) ? TRACK_BIT_UPPER : TRACK_BIT_LOWER;
  }

  Track track = FindFirstTrack(trackbits);

  if (_remove_button_clicked) {
    DoCommandP(tile, track, 0, CcPlaySound1E,
      CMD_REMOVE_SIGNALS | CMD_MSG(STR_1013_CAN_T_REMOVE_SIGNALS_FROM));
  } else {
    const Window *w = FindWindowById(WC_BUILD_SIGNAL, 0);

    /* Map _patches.cycle_signal_types to the lower and upper allowed signal type. */
    static const uint cycle_bounds[] = {SIGTYPE_NORMAL | (SIGTYPE_LAST_NOPBS << 3), SIGTYPE_PBS | (SIGTYPE_LAST << 3), SIGTYPE_NORMAL | (SIGTYPE_LAST << 3)};

    /* various bitstuffed elements for CmdBuildSingleSignal() */
    uint32 p1 = track;

    if (w != NULL) {
      /* signal GUI is used */
      SB(p1, 3, 1, _ctrl_pressed);
      SB(p1, 4, 1, _cur_signal_variant);
      SB(p1, 5, 3, _cur_signal_type);
      SB(p1, 8, 1, _convert_signal_button);
      SB(p1, 9, 6, cycle_bounds[_settings_client.gui.cycle_signal_types]);
    } else {
      SB(p1, 3, 1, _ctrl_pressed);
      SB(p1, 4, 1, (_cur_year < _settings_client.gui.semaphore_build_before ? SIG_SEMAPHORE : SIG_ELECTRIC));
      SB(p1, 5, 3, _default_signal_type[_settings_client.gui.default_signal_type]);
      SB(p1, 8, 1, 0);
      SB(p1, 9, 6, cycle_bounds[_settings_client.gui.cycle_signal_types]);
    }

    DoCommandP(tile, p1, 0, CcPlaySound1E, CMD_BUILD_SIGNALS |
      CMD_MSG((w != NULL && _convert_signal_button) ? STR_SIGNAL_CAN_T_CONVERT_SIGNALS_HERE : STR_1010_CAN_T_BUILD_SIGNALS_HERE));
  }
}

static void PlaceRail_Bridge(TileIndex tile)
{
  VpStartPlaceSizing(tile, VPM_X_OR_Y, DDSP_BUILD_BRIDGE);
}

void CcBuildRailTunnel(bool success, TileIndex tile, uint32 p1, uint32 p2)
{
  if (success) {
    SndPlayTileFx(SND_20_SPLAT_2, tile);
    ResetObjectToPlace();
  } else {
    SetRedErrorSquare(_build_tunnel_endtile);
  }
}

static void PlaceRail_Tunnel(TileIndex tile)
{
  DoCommandP(tile, _cur_railtype, 0, CcBuildRailTunnel,
    CMD_BUILD_TUNNEL | CMD_MSG(STR_5016_CAN_T_BUILD_TUNNEL_HERE));
}

static void PlaceRail_ConvertRail(TileIndex tile)
{
  VpStartPlaceSizing(tile, VPM_X_AND_Y, DDSP_CONVERT_RAIL);
}

static void PlaceRail_AutoSignals(TileIndex tile)
{
  VpStartPlaceSizing(tile, VPM_SIGNALDIRS, DDSP_BUILD_SIGNALS);
}


enum RailToolbarWidgets {
  RTW_CLOSEBOX = 0,
  RTW_CAPTION,
  RTW_STICKY,
  RTW_SPACER,
  RTW_BUILD_NS,
  RTW_BUILD_X,
  RTW_BUILD_EW,
  RTW_BUILD_Y,
  RTW_AUTORAIL,
  RTW_DEMOLISH,
  RTW_BUILD_DEPOT,
  RTW_BUILD_WAYPOINT,
  RTW_BUILD_STATION,
  RTW_BUILD_SIGNALS,
  RTW_BUILD_BRIDGE,
  RTW_BUILD_TUNNEL,
  RTW_REMOVE,
  RTW_CONVERT_RAIL,
};


static void ToggleRailButton_Remove(Window *w)
{
  w->ToggleWidgetLoweredState(RTW_REMOVE);
  w->InvalidateWidget(RTW_REMOVE);
  _remove_button_clicked = w->IsWidgetLowered(RTW_REMOVE);
  SetSelectionRed(_remove_button_clicked);
}

static bool RailToolbar_CtrlChanged(Window *w)
{
  if (w->IsWidgetDisabled(RTW_REMOVE)) return false;

  /* allow ctrl to switch remove mode only for these widgets */
  for (uint i = RTW_BUILD_NS; i <= RTW_BUILD_STATION; i++) {
    if ((i <= RTW_AUTORAIL || i >= RTW_BUILD_WAYPOINT) && w->IsWidgetLowered(i)) {
      ToggleRailButton_Remove(w);
      return true;
    }
  }

  return false;
}


static void BuildRailClick_N(Window *w)
{
  HandlePlacePushButton(w, RTW_BUILD_NS, GetRailTypeInfo(_cur_railtype)->cursor.rail_ns, VHM_RECT, PlaceRail_N);
}

static void BuildRailClick_NE(Window *w)
{
  HandlePlacePushButton(w, RTW_BUILD_X, GetRailTypeInfo(_cur_railtype)->cursor.rail_swne, VHM_RECT, PlaceRail_NE);
}

static void BuildRailClick_E(Window *w)
{
  HandlePlacePushButton(w, RTW_BUILD_EW, GetRailTypeInfo(_cur_railtype)->cursor.rail_ew, VHM_RECT, PlaceRail_E);
}

static void BuildRailClick_NW(Window *w)
{
  HandlePlacePushButton(w, RTW_BUILD_Y, GetRailTypeInfo(_cur_railtype)->cursor.rail_nwse, VHM_RECT, PlaceRail_NW);
}

static void BuildRailClick_AutoRail(Window *w)
{
  HandlePlacePushButton(w, RTW_AUTORAIL, GetRailTypeInfo(_cur_railtype)->cursor.autorail, VHM_RAIL, PlaceRail_AutoRail);
}

static void BuildRailClick_Demolish(Window *w)
{
  HandlePlacePushButton(w, RTW_DEMOLISH, ANIMCURSOR_DEMOLISH, VHM_RECT, PlaceProc_DemolishArea);
}

static void BuildRailClick_Depot(Window *w)
{
  if (HandlePlacePushButton(w, RTW_BUILD_DEPOT, GetRailTypeInfo(_cur_railtype)->cursor.depot, VHM_RECT, PlaceRail_Depot)) {
    ShowBuildTrainDepotPicker(w);
  }
}

static void BuildRailClick_Waypoint(Window *w)
{
  _waypoint_count = GetNumCustomStations(STAT_CLASS_WAYP);
  if (HandlePlacePushButton(w, RTW_BUILD_WAYPOINT, SPR_CURSOR_WAYPOINT, VHM_RECT, PlaceRail_Waypoint) &&
      _waypoint_count > 1) {
    ShowBuildWaypointPicker(w);
  }
}

static void BuildRailClick_Station(Window *w)
{
  if (HandlePlacePushButton(w, RTW_BUILD_STATION, SPR_CURSOR_RAIL_STATION, VHM_RECT, PlaceRail_Station)) ShowStationBuilder(w);
}

static void BuildRailClick_AutoSignals(Window *w)
{
  if (_settings_client.gui.enable_signal_gui != _ctrl_pressed) {
    if (HandlePlacePushButton(w, RTW_BUILD_SIGNALS, ANIMCURSOR_BUILDSIGNALS, VHM_RECT, PlaceRail_AutoSignals)) ShowSignalBuilder(w);
  } else {
    HandlePlacePushButton(w, RTW_BUILD_SIGNALS, ANIMCURSOR_BUILDSIGNALS, VHM_RECT, PlaceRail_AutoSignals);
  }
}

static void BuildRailClick_Bridge(Window *w)
{
  HandlePlacePushButton(w, RTW_BUILD_BRIDGE, SPR_CURSOR_BRIDGE, VHM_RECT, PlaceRail_Bridge);
}

static void BuildRailClick_Tunnel(Window *w)
{
  HandlePlacePushButton(w, RTW_BUILD_TUNNEL, GetRailTypeInfo(_cur_railtype)->cursor.tunnel, VHM_SPECIAL, PlaceRail_Tunnel);
}

static void BuildRailClick_Remove(Window *w)
{
  if (w->IsWidgetDisabled(RTW_REMOVE)) return;
  ToggleRailButton_Remove(w);
  SndPlayFx(SND_15_BEEP);

  /* handle station builder */
  if (w->IsWidgetLowered(RTW_BUILD_STATION)) {
    if (_remove_button_clicked) {
      /* starting drag & drop remove */
      if (!_railstation.dragdrop) {
        SetTileSelectSize(1, 1);
      } else {
        VpSetPlaceSizingLimit(-1);
      }
    } else {
      /* starting station build mode */
      if (!_railstation.dragdrop) {
        int x = _railstation.numtracks;
        int y = _railstation.platlength;
        if (_railstation.orientation == 0) Swap(x, y);
        SetTileSelectSize(x, y);
      } else {
        VpSetPlaceSizingLimit(_settings_game.station.station_spread);
      }
    }
  }
}

static void BuildRailClick_Convert(Window *w)
{
  HandlePlacePushButton(w, RTW_CONVERT_RAIL, GetRailTypeInfo(_cur_railtype)->cursor.convert, VHM_RECT, PlaceRail_ConvertRail);
}


static void DoRailroadTrack(int mode)
{
  DoCommandP(TileVirtXY(_thd.selstart.x, _thd.selstart.y), TileVirtXY(_thd.selend.x, _thd.selend.y), _cur_railtype | (mode << 4), NULL,
    _remove_button_clicked ?
    CMD_REMOVE_RAILROAD_TRACK | CMD_NO_WATER | CMD_MSG(STR_1012_CAN_T_REMOVE_RAILROAD_TRACK) :
    CMD_BUILD_RAILROAD_TRACK  | CMD_NO_WATER | CMD_MSG(STR_1011_CAN_T_BUILD_RAILROAD_TRACK)
  );
}

static void HandleAutodirPlacement()
{
  TileHighlightData *thd = &_thd;
  int trackstat = thd->drawstyle & 0xF; // 0..5

  if (thd->drawstyle & HT_RAIL) { // one tile case
    GenericPlaceRail(TileVirtXY(thd->selend.x, thd->selend.y), trackstat);
    return;
  }

  DoRailroadTrack(trackstat);
}

static void HandleAutoSignalPlacement()
{
  TileHighlightData *thd = &_thd;
  uint32 p2 = GB(thd->drawstyle, 0, 3); // 0..5

  if (thd->drawstyle == HT_RECT) { // one tile case
    GenericPlaceSignals(TileVirtXY(thd->selend.x, thd->selend.y));
    return;
  }

  const Window *w = FindWindowById(WC_BUILD_SIGNAL, 0);

  if (w != NULL) {
    /* signal GUI is used */
    SB(p2,  3, 1, 0);
    SB(p2,  4, 1, _cur_signal_variant);
    SB(p2,  6, 1, _ctrl_pressed);
    SB(p2,  7, 3, _cur_signal_type);
    SB(p2, 24, 8, _settings_client.gui.drag_signals_density);
  } else {
    SB(p2,  3, 1, 0);
    SB(p2,  4, 1, (_cur_year < _settings_client.gui.semaphore_build_before ? SIG_SEMAPHORE : SIG_ELECTRIC));
    SB(p2,  6, 1, _ctrl_pressed);
    SB(p2,  7, 3, _default_signal_type[_settings_client.gui.default_signal_type]);
    SB(p2, 24, 8, _settings_client.gui.drag_signals_density);
  }

  /* _settings_client.gui.drag_signals_density is given as a parameter such that each user
   * in a network game can specify his/her own signal density */
  DoCommandP(
    TileVirtXY(thd->selstart.x, thd->selstart.y),
    TileVirtXY(thd->selend.x, thd->selend.y),
    p2,
    CcPlaySound1E,
    _remove_button_clicked ?
      CMD_REMOVE_SIGNAL_TRACK | CMD_NO_WATER | CMD_MSG(STR_1013_CAN_T_REMOVE_SIGNALS_FROM) :
      CMD_BUILD_SIGNAL_TRACK  | CMD_NO_WATER | CMD_MSG(STR_1010_CAN_T_BUILD_SIGNALS_HERE)
  );
}


typedef void OnButtonClick(Window *w);

struct RailBuildingGUIButtonData {
  uint16 keycode;            
  OnButtonClick *click_proc; 
};

static const RailBuildingGUIButtonData _rail_build_button_data[] = {
  {'1', BuildRailClick_N          },
  {'2', BuildRailClick_NE         },
  {'3', BuildRailClick_E          },
  {'4', BuildRailClick_NW         },
  {'5', BuildRailClick_AutoRail   },
  {'6', BuildRailClick_Demolish   },
  {'7', BuildRailClick_Depot      },
  {'8', BuildRailClick_Waypoint   },
  {'9', BuildRailClick_Station    },
  {'S', BuildRailClick_AutoSignals},
  {'B', BuildRailClick_Bridge     },
  {'T', BuildRailClick_Tunnel     },
  {'R', BuildRailClick_Remove     },
  {'C', BuildRailClick_Convert    }
};

struct BuildRailToolbarWindow : Window {
  BuildRailToolbarWindow(const WindowDesc *desc, WindowNumber window_number) : Window(desc, window_number)
  {
    this->DisableWidget(RTW_REMOVE);

    this->FindWindowPlacementAndResize(desc);
    if (_settings_client.gui.link_terraform_toolbar) ShowTerraformToolbar(this);
  }

  ~BuildRailToolbarWindow()
  {
    if (_settings_client.gui.link_terraform_toolbar) DeleteWindowById(WC_SCEN_LAND_GEN, 0);
  }

  void UpdateRemoveWidgetStatus(int clicked_widget)
  {
    switch (clicked_widget) {
      case RTW_REMOVE:
        /* If it is the removal button that has been clicked, do nothing,
        * as it is up to the other buttons to drive removal status */
        return;
        break;
      case RTW_BUILD_NS:
      case RTW_BUILD_X:
      case RTW_BUILD_EW:
      case RTW_BUILD_Y:
      case RTW_AUTORAIL:
      case RTW_BUILD_WAYPOINT:
      case RTW_BUILD_STATION:
      case RTW_BUILD_SIGNALS:
        /* Removal button is enabled only if the rail/signal/waypoint/station
        * button is still lowered.  Once raised, it has to be disabled */
        this->SetWidgetDisabledState(RTW_REMOVE, !this->IsWidgetLowered(clicked_widget));
        break;

      default:
        /* When any other buttons than rail/signal/waypoint/station, raise and
        * disable the removal button */
        this->DisableWidget(RTW_REMOVE);
        this->RaiseWidget(RTW_REMOVE);
        break;
    }
  }

  virtual void OnPaint()
  {
    this->DrawWidgets();
  }

  virtual void OnClick(Point pt, int widget)
  {
    if (widget >= RTW_BUILD_NS) {
      _remove_button_clicked = false;
      _rail_build_button_data[widget - RTW_BUILD_NS].click_proc(this);
    }
    this->UpdateRemoveWidgetStatus(widget);
    if (_ctrl_pressed) RailToolbar_CtrlChanged(this);
  }

  virtual EventState OnKeyPress(uint16 key, uint16 keycode)
  {
    EventState state = ES_NOT_HANDLED;
    for (uint8 i = 0; i != lengthof(_rail_build_button_data); i++) {
      if (keycode == _rail_build_button_data[i].keycode) {
        _remove_button_clicked = false;
        _rail_build_button_data[i].click_proc(this);
        this->UpdateRemoveWidgetStatus(i + RTW_BUILD_NS);
        if (_ctrl_pressed) RailToolbar_CtrlChanged(this);
        state = ES_HANDLED;
        break;
      }
    }
    MarkTileDirty(_thd.pos.x, _thd.pos.y); // redraw tile selection
    return state;
  }

  virtual void OnPlaceObject(Point pt, TileIndex tile)
  {
    _place_proc(tile);
  }

  virtual void OnPlaceDrag(ViewportPlaceMethod select_method, ViewportDragDropSelectionProcess select_proc, Point pt)
  {
    /* no dragging if you have pressed the convert button */
    if (FindWindowById(WC_BUILD_SIGNAL, 0) != NULL && _convert_signal_button && this->IsWidgetLowered(RTW_BUILD_SIGNALS)) return;

    VpSelectTilesWithMethod(pt.x, pt.y, select_method);
  }

  virtual void OnPlaceMouseUp(ViewportPlaceMethod select_method, ViewportDragDropSelectionProcess select_proc, Point pt, TileIndex start_tile, TileIndex end_tile)
  {
    if (pt.x != -1) {
      switch (select_proc) {
        default: NOT_REACHED();
        case DDSP_BUILD_BRIDGE:
          ResetObjectToPlace();
          ShowBuildBridgeWindow(start_tile, end_tile, TRANSPORT_RAIL, _cur_railtype);
          break;

        case DDSP_PLACE_AUTORAIL:
          HandleAutodirPlacement();
          break;

        case DDSP_BUILD_SIGNALS:
          HandleAutoSignalPlacement();
          break;

        case DDSP_DEMOLISH_AREA:
          GUIPlaceProcDragXY(select_proc, start_tile, end_tile);
          break;

        case DDSP_CONVERT_RAIL:
          DoCommandP(end_tile, start_tile, _cur_railtype, CcPlaySound10, CMD_CONVERT_RAIL | CMD_MSG(STR_CANT_CONVERT_RAIL));
          break;

        case DDSP_REMOVE_STATION:
        case DDSP_BUILD_STATION:
          if (_remove_button_clicked) {
            DoCommandP(end_tile, start_tile, 0, CcPlaySound1E, CMD_REMOVE_FROM_RAILROAD_STATION | CMD_MSG(STR_CANT_REMOVE_PART_OF_STATION));
            break;
          }
          HandleStationPlacement(start_tile, end_tile);
          break;

        case DDSP_PLACE_RAIL_NE:
        case DDSP_PLACE_RAIL_NW:
          DoRailroadTrack(select_proc == DDSP_PLACE_RAIL_NE ? TRACK_X : TRACK_Y);
          break;
      }
    }
  }

  virtual void OnPlaceObjectAbort()
  {
    this->RaiseButtons();
    this->DisableWidget(RTW_REMOVE);
    this->InvalidateWidget(RTW_REMOVE);

    delete FindWindowById(WC_BUILD_SIGNAL, 0);
    delete FindWindowById(WC_BUILD_STATION, 0);
    delete FindWindowById(WC_BUILD_DEPOT, 0);
  }

  virtual void OnPlacePresize(Point pt, TileIndex tile)
  {
    DoCommand(tile, 0, 0, DC_AUTO, CMD_BUILD_TUNNEL);
    VpSetPresizeRange(tile, _build_tunnel_endtile == 0 ? tile : _build_tunnel_endtile);
  }

  virtual EventState OnCTRLStateChange()
  {
    /* do not toggle Remove button by Ctrl when placing station */
    if (!this->IsWidgetLowered(RTW_BUILD_STATION) && RailToolbar_CtrlChanged(this)) return ES_HANDLED;
    return ES_NOT_HANDLED;
  }
};

static const Widget _build_rail_widgets[] = {
{   WWT_CLOSEBOX,   RESIZE_NONE,  COLOUR_DARK_GREEN,     0,    10,     0,    13, STR_00C5,                       STR_018B_CLOSE_WINDOW},                   // RTW_CLOSEBOX
{    WWT_CAPTION,   RESIZE_NONE,  COLOUR_DARK_GREEN,    11,   337,     0,    13, STR_100A_RAILROAD_CONSTRUCTION, STR_018C_WINDOW_TITLE_DRAG_THIS},         // RTW_CAPTION
{  WWT_STICKYBOX,   RESIZE_NONE,  COLOUR_DARK_GREEN,   338,   349,     0,    13, 0x0,                            STR_STICKY_BUTTON},                       // RTW_STICKY

{      WWT_PANEL,   RESIZE_NONE,  COLOUR_DARK_GREEN,   110,   113,    14,    35, 0x0,                            STR_NULL},                                // RTW_SPACER

{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,     0,    21,    14,    35, SPR_IMG_RAIL_NS,                STR_1018_BUILD_RAILROAD_TRACK},           // RTW_BUILD_NS
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,    22,    43,    14,    35, SPR_IMG_RAIL_NE,                STR_1018_BUILD_RAILROAD_TRACK},           // RTW_BUILD_X
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,    44,    65,    14,    35, SPR_IMG_RAIL_EW,                STR_1018_BUILD_RAILROAD_TRACK},           // RTW_BUILD_EW
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,    66,    87,    14,    35, SPR_IMG_RAIL_NW,                STR_1018_BUILD_RAILROAD_TRACK},           // RTW_BUILD_Y
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,    88,   109,    14,    35, SPR_IMG_AUTORAIL,               STR_BUILD_AUTORAIL_TIP},                  // RTW_AUTORAIL

{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,   114,   135,    14,    35, SPR_IMG_DYNAMITE,               STR_018D_DEMOLISH_BUILDINGS_ETC},         // RTW_DEMOLISH
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,   136,   157,    14,    35, SPR_IMG_DEPOT_RAIL,             STR_1019_BUILD_TRAIN_DEPOT_FOR_BUILDING}, // RTW_BUILD_DEPOT
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,   158,   179,    14,    35, SPR_IMG_WAYPOINT,               STR_CONVERT_RAIL_TO_WAYPOINT_TIP},        // RTW_BUILD_WAYPOINT

{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,   180,   221,    14,    35, SPR_IMG_RAIL_STATION,           STR_101A_BUILD_RAILROAD_STATION},         // RTW_BUILD_STATION
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,   222,   243,    14,    35, SPR_IMG_RAIL_SIGNALS,           STR_101B_BUILD_RAILROAD_SIGNALS},         // RTW_BUILD_SIGNALS
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,   244,   285,    14,    35, SPR_IMG_BRIDGE,                 STR_101C_BUILD_RAILROAD_BRIDGE},          // RTW_BUILD_BRIDGE
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,   286,   305,    14,    35, SPR_IMG_TUNNEL_RAIL,            STR_101D_BUILD_RAILROAD_TUNNEL},          // RTW_BUILD_TUNNEL
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,   306,   327,    14,    35, SPR_IMG_REMOVE,                 STR_101E_TOGGLE_BUILD_REMOVE_FOR},        // RTW_REMOVE
{     WWT_IMGBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,   328,   349,    14,    35, SPR_IMG_CONVERT_RAIL,           STR_CONVERT_RAIL_TIP},                    // RTW_CONVERT_RAIL

{   WIDGETS_END},
};

static const WindowDesc _build_rail_desc = {
  WDP_ALIGN_TBR, 22, 350, 36, 350, 36,
  WC_BUILD_TOOLBAR, WC_NONE,