diff options
Diffstat (limited to 'depot_gui.c')
| -rw-r--r-- | depot_gui.c | 808 |
1 files changed, 808 insertions, 0 deletions
diff --git a/depot_gui.c b/depot_gui.c new file mode 100644 index 000000000..0d3920f50 --- /dev/null +++ b/depot_gui.c @@ -0,0 +1,808 @@ +/* $Id$ */ + +#include "stdafx.h" +#include "openttd.h" +#include "functions.h" +#include "ship.h" +#include "table/strings.h" +#include "table/sprites.h" +#include "gui.h" +#include "gfx.h" +#include "vehicle.h" +#include "viewport.h" +#include "command.h" +#include "depot.h" +#include "vehicle_gui.h" +#include "station_map.h" +#include "newgrf_engine.h" +#include "train.h" + +enum { + DEPOT_WIDGET_CLOSEBOX = 0, + DEPOT_WIDGET_CAPTION = 1, + DEPOT_WIDGET_STICKY = 2, + DEPOT_WIDGET_V_RESIZE = 3, // blank widget, that fills the gab at the sell button when resizing vertically + DEPOT_WIDGET_SELL = 4, + DEPOT_WIDGET_SELL_ALL = 5, + DEPOT_WIDGET_MATRIX = 6, + DEPOT_WIDGET_V_SCROLL = 7, // Vertical scrollbar + DEPOT_WIDGET_H_SCROLL = 8, // Horizontal scrollbar + DEPOT_WIDGET_BUILD = 9, + DEPOT_WIDGET_CLONE = 10, + DEPOT_WIDGET_LOCATION = 11, + DEPOT_WIDGET_H_RESIZE = 12, // blank widget, that fills the gab at the build and clone buttons when resizing horizontally + DEPOT_WIDGET_RESIZE = 13, +}; + +/* Widget array for all depot windows. + * If a widget is needed in some windows only (like train specific), add it for all windows + * and use w->hidden_state in ShowDepotWindow() to remove it in the windows where it should not be + * Keep the widget numbers in sync with the enum or really bad stuff will happen!!! */ +static const Widget _depot_widgets[] = { + { WWT_CLOSEBOX, RESIZE_NONE, 14, 0, 10, 0, 13, STR_00C5, STR_018B_CLOSE_WINDOW}, // DEPOT_WIDGET_CLOSEBOX + { WWT_CAPTION, RESIZE_RIGHT, 14, 11, 292, 0, 13, 0x0, STR_018C_WINDOW_TITLE_DRAG_THIS}, // DEPOT_WIDGET_CAPTION + { WWT_STICKYBOX, RESIZE_LR, 14, 293, 304, 0, 13, 0x0, STR_STICKY_BUTTON}, // DEPOT_WIDGET_STICKY + { WWT_PANEL, RESIZE_LRB, 14, 270, 292, 14, 13, 0x0, STR_NULL}, // DEPOT_WIDGET_V_RESIZE + { WWT_IMGBTN, RESIZE_LRTB, 14, 270, 292, 14, 61, 0x2A9, STR_NULL}, // DEPOT_WIDGET_SELL + { WWT_PANEL, RESIZE_LRTB, 14, 326, 348, 0, 0, 0x2BF, STR_DRAG_WHOLE_TRAIN_TO_SELL_TIP}, // DEPOT_WIDGET_SELL_ALL, trains only + + { WWT_MATRIX, RESIZE_RB, 14, 0, 269, 14, 61, 0x0, STR_NULL}, // DEPOT_WIDGET_MATRIX + { WWT_SCROLLBAR, RESIZE_LRB, 14, 293, 304, 14, 61, 0x0, STR_0190_SCROLL_BAR_SCROLLS_LIST}, // DEPOT_WIDGET_V_SCROLL + + { WWT_HSCROLLBAR, RESIZE_RTB, 14, 0, 325, 98, 109, 0x0, STR_HSCROLL_BAR_SCROLLS_LIST}, // DEPOT_WIDGET_H_SCROLL, trains only + + /* The buttons in the bottom of the window. left and right is not important as they are later resized to be equal in size + * This calculation is based on right in DEPOT_WIDGET_LOCATION and it presumes left of DEPOT_WIDGET_BUILD is 0 */ + { WWT_PUSHTXTBTN, RESIZE_TB, 14, 0, 96, 62, 73, 0x0, STR_NULL}, // DEPOT_WIDGET_BUILD + {WWT_NODISTXTBTN, RESIZE_TB, 14, 97, 194, 62, 73, 0x0, STR_NULL}, // DEPOT_WIDGET_CLONE + { WWT_PUSHTXTBTN, RESIZE_TB, 14, 195, 292, 62, 73, STR_00E4_LOCATION, STR_NULL}, // DEPOT_WIDGET_LOCATION + + { WWT_PANEL, RESIZE_RTB, 14, 293, 292, 62, 73, 0x0, STR_NULL}, // DEPOT_WIDGET_H_RESIZE + { WWT_RESIZEBOX, RESIZE_LRTB, 14, 293, 304, 62, 73, 0x0, STR_RESIZE_BUTTON}, // DEPOT_WIDGET_RESIZE + { WIDGETS_END}, +}; + +/* + * Since all depot window sizes aren't the same, we need to modify sizes a little. + * It's done with the following arrays of widget indexes. Each of them tells if a widget side should be moved and in what direction. + * How long they should be moved and for what window types are controlled in ShowDepotWindow() + */ + +/* List of widgets where the left side should be moved to the right */ +static const byte left[] = { + DEPOT_WIDGET_STICKY, + DEPOT_WIDGET_V_RESIZE, + DEPOT_WIDGET_SELL, + DEPOT_WIDGET_V_SCROLL, + DEPOT_WIDGET_H_RESIZE, + DEPOT_WIDGET_RESIZE, +}; + +/* List of widgets where the right side should be moved to the right */ +static const byte right[] = { + DEPOT_WIDGET_CAPTION, + DEPOT_WIDGET_STICKY, + DEPOT_WIDGET_V_RESIZE, + DEPOT_WIDGET_SELL, + DEPOT_WIDGET_MATRIX, + DEPOT_WIDGET_V_SCROLL, + DEPOT_WIDGET_LOCATION, + DEPOT_WIDGET_H_RESIZE, + DEPOT_WIDGET_RESIZE, +}; + +/* List of widgets where the top side should be moved down */ +static const byte top[] = { + DEPOT_WIDGET_BUILD, + DEPOT_WIDGET_CLONE, + DEPOT_WIDGET_LOCATION, + DEPOT_WIDGET_H_RESIZE, + DEPOT_WIDGET_RESIZE, +}; + +/* List of widgets where the bottom side should be moved down */ +static const byte bottom[] = { + DEPOT_WIDGET_SELL, + DEPOT_WIDGET_MATRIX, + DEPOT_WIDGET_V_SCROLL, + DEPOT_WIDGET_BUILD, + DEPOT_WIDGET_CLONE, + DEPOT_WIDGET_LOCATION, + DEPOT_WIDGET_H_RESIZE, + DEPOT_WIDGET_RESIZE, +}; + +static void DepotWndProc(Window *w, WindowEvent *e); + +static const WindowDesc _train_depot_desc = { + -1, -1, 361, 122, + WC_VEHICLE_DEPOT,0, + WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS | WDF_STICKY_BUTTON | WDF_RESIZABLE, + _depot_widgets, + DepotWndProc +}; + +static const WindowDesc _road_depot_desc = { + -1, -1, 315, 68, + WC_VEHICLE_DEPOT,0, + WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS | WDF_STICKY_BUTTON | WDF_RESIZABLE, + _depot_widgets, + DepotWndProc +}; + +static const WindowDesc _ship_depot_desc = { + -1, -1, 305, 74, + WC_VEHICLE_DEPOT,0, + WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS | WDF_STICKY_BUTTON | WDF_RESIZABLE, + _depot_widgets, + DepotWndProc +}; + +static const WindowDesc _aircraft_depot_desc = { + -1, -1, 331, 74, + WC_VEHICLE_DEPOT,0, + WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS | WDF_STICKY_BUTTON | WDF_RESIZABLE, + _depot_widgets, + DepotWndProc +}; + +extern int WagonLengthToPixels(int len); + +void CcCloneVehicle(bool success, TileIndex tile, uint32 p1, uint32 p2) +{ + if (!success) return; + CcCloneShip(true, tile, p1, p2); +} + +static inline void ShowVehicleViewWindow(const Vehicle *v) +{ + switch (v->type) { + case VEH_Train: ShowTrainViewWindow(v); break; + case VEH_Road: ShowRoadVehViewWindow(v); break; + case VEH_Ship: ShowShipViewWindow(v); break; + case VEH_Aircraft: ShowAircraftViewWindow(v); break; + default: NOT_REACHED(); + } +} + +static void DrawDepotWindow(Window *w) +{ + Vehicle **vl = WP(w, depot_d).vehicle_list; + TileIndex tile; + int x, y, i, hnum, max; + uint16 num = WP(w, depot_d).engine_count; + + tile = w->window_number; + + /* setup disabled buttons */ + w->disabled_state = + IsTileOwner(tile, _local_player) ? 0 : ((1 << DEPOT_WIDGET_SELL) | (1 << DEPOT_WIDGET_SELL_ALL) | (1 << DEPOT_WIDGET_BUILD) | (1 << DEPOT_WIDGET_CLONE)); + + /* determine amount of items for scroller */ + if (WP(w, depot_d).type == VEH_Train) { + hnum = 8; + for (num = 0; num < WP(w, depot_d).engine_count; num++) { + const Vehicle *v = vl[num]; + hnum = maxu(hnum, v->u.rail.cached_total_length); + } + /* Always have 1 empty row, so people can change the setting of the train */ + SetVScrollCount(w, WP(w, depot_d).engine_count + WP(w, depot_d).wagon_count + 1); + SetHScrollCount(w, WagonLengthToPixels(hnum)); + } else { + SetVScrollCount(w, (num + w->hscroll.cap - 1) / w->hscroll.cap); + } + + /* locate the depot struct */ + if (WP(w, depot_d).type == VEH_Aircraft) { + SetDParam(0, GetStationIndex(tile)); // Airport name + } else { + Depot *depot = GetDepotByTile(tile); + assert(depot != NULL); + + SetDParam(0, depot->town_index); + } + + DrawWindowWidgets(w); + + x = 2; + y = 15; + num = w->vscroll.pos * w->hscroll.cap; + if (WP(w, depot_d).type == VEH_Train) { + max = min(WP(w, depot_d).engine_count, w->vscroll.pos + w->vscroll.cap); + num = w->vscroll.pos; + } else { + max = min(WP(w, depot_d).engine_count, num + (w->vscroll.cap * w->hscroll.cap)); + num = w->vscroll.pos * w->hscroll.cap; + } + + for (; num < max; num++) { + const Vehicle *v = vl[num]; + byte diff_x = 0, diff_y = 0; + + switch (WP(w, depot_d).type) { + case VEH_Train: + DrawTrainImage(v, x + 21, y, w->hscroll.cap + 4, w->hscroll.pos, WP(w,depot_d).sel); + + /* Number of wagons relative to a standard length wagon (rounded up) */ + SetDParam(0, (v->u.rail.cached_total_length + 7) / 8); + DrawStringRightAligned(w->widget[DEPOT_WIDGET_MATRIX].right - 1, y + 4, STR_TINY_BLACK, 0); // Draw the counter + break; + + case VEH_Road: DrawRoadVehImage( v, x + 24, y, WP(w, depot_d).sel); break; + case VEH_Ship: DrawShipImage( v, x + 19, y, WP(w, depot_d).sel); break; + case VEH_Aircraft: DrawAircraftImage(v, x + 12, y, WP(w, depot_d).sel); break; + default: NOT_REACHED(); + } + + if (w->resize.step_height == 14) { + /* VEH_Train and VEH_Road, which are low */ + diff_x = 15; + } else { + /* VEH_Ship and VEH_Aircraft, which are tall */ + diff_y = 12; + } + + DrawSprite((v->vehstatus & VS_STOPPED) ? SPR_FLAG_VEH_STOPPED : SPR_FLAG_VEH_RUNNING, x + diff_x, y + diff_y); + + SetDParam(0, v->unitnumber); + DrawString(x, y + 2, (uint16)(v->max_age-366) >= v->age ? STR_00E2 : STR_00E3, 0); + + if (WP(w, depot_d).type == VEH_Train) { + y += w->resize.step_height; + } else { + if ((x += w->resize.step_width) == 2 + (int)w->resize.step_width * w->hscroll.cap) { + x = 2; + y += w->resize.step_height; + } + } + } + + max = min(WP(w, depot_d).engine_count + WP(w, depot_d).wagon_count, w->vscroll.pos + w->vscroll.cap); + + /* draw the train wagons, that do not have an engine in front */ + for (; num < max; num++) { + const Vehicle *v = WP(w, depot_d).wagon_list[num - WP(w, depot_d).engine_count]; + const Vehicle *u; + + DrawTrainImage(v, x + 50, y, w->hscroll.cap - 29, 0, WP(w,depot_d).sel); + DrawString(x, y + 2, STR_8816, 0); + + /*Draw the train counter */ + i = 0; + u = v; + do i++; while ( (u=u->next) != NULL); // Determine length of train + SetDParam(0, i); // Set the counter + DrawStringRightAligned(w->widget[DEPOT_WIDGET_MATRIX].right - 1, y + 4, STR_TINY_BLACK, 0); // Draw the counter + y += 14; + } +} + +typedef struct GetDepotVehiclePtData { + Vehicle *head; + Vehicle *wagon; +} GetDepotVehiclePtData; + +enum { + MODE_ERROR = 1, + MODE_DRAG_VEHICLE = 0, + MODE_SHOW_VEHICLE = -1, + MODE_START_STOP = -2, +}; + +static int GetVehicleFromDepotWndPt(const Window *w, int x, int y, Vehicle **veh, GetDepotVehiclePtData *d) +{ + Vehicle **vl = WP(w, depot_d).vehicle_list; + uint xt, row, xm, ym; + int pos, skip = 0; + + if (WP(w, depot_d).type == VEH_Train) { + xt = 0; + x -= 23; + } else { + xt = x / w->resize.step_width; + xm = x % w->resize.step_width; + if (xt >= w->hscroll.cap) return MODE_ERROR; + + ym = (y - 14) % w->resize.step_height; + } + + row = (y - 14) / w->resize.step_height; + if (row >= w->vscroll.cap) return MODE_ERROR; + + pos = (row + w->vscroll.pos) * w->hscroll.cap + xt; + + if (WP(w, depot_d).type == VEH_Train) pos = row + w->vscroll.pos; + + if (WP(w, depot_d).engine_count + WP(w, depot_d).wagon_count <= pos) return MODE_ERROR; // empty block, so no vehicle is selected + + if (WP(w, depot_d).engine_count > pos) { + *veh = vl[pos]; + skip = w->hscroll.pos; + } else { + vl = WP(w, depot_d).wagon_list; + pos -= WP(w, depot_d).engine_count; + *veh = vl[pos]; + /* free wagons don't have an initial loco. */ + x -= _traininfo_vehicle_width; + } + + switch (WP(w, depot_d).type) { + case VEH_Train: { + Vehicle *v = *veh; + d->head = d->wagon = v; + + /* either pressed the flag or the number, but only when it's a loco */ + if (x < 0 && IsFrontEngine(v)) return (x >= -10) ? MODE_START_STOP : MODE_SHOW_VEHICLE; + + skip = (skip * 8) / _traininfo_vehicle_width; + x = (x * 8) / _traininfo_vehicle_width; + + /* Skip vehicles that are scrolled off the list */ + x += skip; + + /* find the vehicle in this row that was clicked */ + while (v != NULL && (x -= v->u.rail.cached_veh_length) >= 0) v = v->next; + + /* if an articulated part was selected, find its parent */ + while (v != NULL && IsArticulatedPart(v)) v = GetPrevVehicleInChain(v); + + d->wagon = v; + + return MODE_DRAG_VEHICLE; + } + break; + + case VEH_Road: + if (xm >= 24) return MODE_DRAG_VEHICLE; + if (xm <= 16) return MODE_SHOW_VEHICLE; + break; + + case VEH_Ship: + if (xm >= 19) return MODE_DRAG_VEHICLE; + if (ym <= 10) return MODE_SHOW_VEHICLE; + break; + + case VEH_Aircraft: + if (xm >= 12) return MODE_DRAG_VEHICLE; + if (ym <= 12) return MODE_SHOW_VEHICLE; + break; + + default: NOT_REACHED(); + } + return MODE_START_STOP; +} + +static void TrainDepotMoveVehicle(Vehicle *wagon, VehicleID sel, Vehicle *head) +{ + Vehicle *v; + + v = GetVehicle(sel); + + if (v == wagon) return; + + if (wagon == NULL) { + if (head != NULL) wagon = GetLastVehicleInChain(head); + } else { + wagon = GetPrevVehicleInChain(wagon); + if (wagon == NULL) return; + } + + if (wagon == v) return; + + DoCommandP(v->tile, v->index + ((wagon == NULL ? INVALID_VEHICLE : wagon->index) << 16), _ctrl_pressed ? 1 : 0, NULL, CMD_MOVE_RAIL_VEHICLE | CMD_MSG(STR_8837_CAN_T_MOVE_VEHICLE)); +} + +static void DepotClick(Window *w, int x, int y) +{ + GetDepotVehiclePtData gdvp; + Vehicle *v = NULL; + int mode = GetVehicleFromDepotWndPt(w, x, y, &v, &gdvp); + + /* share / copy orders */ + if (_thd.place_mode && mode <= 0) { + _place_clicked_vehicle = (WP(w, depot_d).type == VEH_Train ? gdvp.head : v); + return; + } + + if (WP(w, depot_d).type == VEH_Train) v = gdvp.wagon; + + switch (mode) { + case MODE_ERROR: // invalid + return; + + case MODE_DRAG_VEHICLE: { // start dragging of vehicle + VehicleID sel = WP(w, depot_d).sel; + + if (WP(w, depot_d).type == VEH_Train && sel != INVALID_VEHICLE) { + WP(w,depot_d).sel = INVALID_VEHICLE; + TrainDepotMoveVehicle(v, sel, gdvp.head); + } else if (v != NULL) { + int image; + + switch (WP(w, depot_d).type) { + case VEH_Train: image = GetTrainImage(v, DIR_W); break; + case VEH_Road: image = GetRoadVehImage(v, DIR_W); break; + case VEH_Ship: image = GetShipImage(v, DIR_W); break; + case VEH_Aircraft: image = GetAircraftImage(v, DIR_W); break; + default: NOT_REACHED(); image = 0; + } + + WP(w, depot_d).sel = v->index; + SetWindowDirty(w); + SetObjectToPlaceWnd(GetVehiclePalette(v) | image, 4, w); + } + } + break; + + case MODE_SHOW_VEHICLE: // show info window + ShowVehicleViewWindow(v); + break; + + case MODE_START_STOP: { // click start/stop flag + uint command; + + switch (WP(w, depot_d).type) { + case VEH_Train: command = CMD_START_STOP_TRAIN | CMD_MSG(STR_883B_CAN_T_STOP_START_TRAIN); break; + case VEH_Road: command = CMD_START_STOP_ROADVEH | CMD_MSG(STR_9015_CAN_T_STOP_START_ROAD_VEHICLE); break; + case VEH_Ship: command = CMD_START_STOP_SHIP | CMD_MSG(STR_9818_CAN_T_STOP_START_SHIP); break; + case VEH_Aircraft: command = CMD_START_STOP_AIRCRAFT | CMD_MSG(STR_A016_CAN_T_STOP_START_AIRCRAFT); break; + default: NOT_REACHED(); command = 0; + } + DoCommandP(v->tile, v->index, 0, NULL, command); + } + break; + + default: NOT_REACHED(); + } +} + +/** + * Clones a vehicle + * @param *v is the original vehicle to clone + * @param *w is the window of the depot where the clone is build + */ +static void HandleCloneVehClick(const Vehicle *v, const Window *w) +{ + uint error_str; + + if (v == NULL) return; + + if (v->type == VEH_Train && !IsFrontEngine(v)) { + v = GetFirstVehicleInChain(v); + /* Do nothing when clicking on a train in depot with no loc attached */ + if (!IsFrontEngine(v)) return; + } + + switch (v->type) { + case VEH_Train: error_str = CMD_MSG(STR_882B_CAN_T_BUILD_RAILROAD_VEHICLE); break; + case VEH_Road: error_str = CMD_MSG(STR_9009_CAN_T_BUILD_ROAD_VEHICLE); break; + case VEH_Ship: error_str = CMD_MSG(STR_980D_CAN_T_BUILD_SHIP); break; + case VEH_Aircraft: error_str = CMD_MSG(STR_A008_CAN_T_BUILD_AIRCRAFT); break; + default: return; + } + + DoCommandP(w->window_number, v->index, _ctrl_pressed ? 1 : 0, CcCloneVehicle, CMD_CLONE_VEHICLE | error_str); + + ResetObjectToPlace(); +} + +static void ClonePlaceObj(const Window *w) +{ + const Vehicle *v = CheckMouseOverVehicle(); + + if (v != NULL) HandleCloneVehClick(v, w); +} + +static void DepotWndProc(Window *w, WindowEvent *e) +{ + switch (e->event) { + case WE_CREATE: + WP(w, depot_d).vehicle_list = NULL; + WP(w, depot_d).wagon_list = NULL; + WP(w, depot_d).engine_count = 0; + WP(w, depot_d).wagon_count = 0; + break; + + case WE_PAINT: + /* Generate the vehicle list + * It's ok to use the wagon pointers for non-trains as they will be ignored */ + BuildDepotVehicleList(WP(w, depot_d).type, w->window_number, + &WP(w, depot_d).vehicle_list, &WP(w, depot_d).engine_list_length, &WP(w, depot_d).engine_count, + &WP(w, depot_d).wagon_list, &WP(w, depot_d).wagon_list_length, &WP(w, depot_d).wagon_count); + DrawDepotWindow(w); + break; + + case WE_CLICK: + switch (e->we.click.widget) { + case DEPOT_WIDGET_MATRIX: // List + DepotClick(w, e->we.click.pt.x, e->we.click.pt.y); + break; + + case DEPOT_WIDGET_BUILD: // Build vehicle + ResetObjectToPlace(); + switch (WP(w, depot_d).type) { + case VEH_Train: ShowBuildTrainWindow(w->window_number); break; + case VEH_Road: ShowBuildRoadVehWindow(w->window_number); break; + case VEH_Ship: ShowBuildShipWindow(w->window_number); break; + case VEH_Aircraft: ShowBuildAircraftWindow(w->window_number); break; + default: NOT_REACHED(); + } + break; + + case DEPOT_WIDGET_CLONE: // Clone button + InvalidateWidget(w, DEPOT_WIDGET_CLONE); + TOGGLEBIT(w->click_state, DEPOT_WIDGET_CLONE); + + if (HASBIT(w->click_state, DEPOT_WIDGET_CLONE)) { + _place_clicked_vehicle = NULL; + SetObjectToPlaceWnd(SPR_CURSOR_CLONE, VHM_RECT, w); + } else { + ResetObjectToPlace(); + } + break; + + case DEPOT_WIDGET_LOCATION: ScrollMainWindowToTile(w->window_number); break; + } + break; + + case WE_PLACE_OBJ: { + ClonePlaceObj(w); + } break; + + case WE_ABORT_PLACE_OBJ: { + CLRBIT(w->click_state, DEPOT_WIDGET_CLONE); + InvalidateWidget(w, DEPOT_WIDGET_CLONE); + } break; + + /* check if a vehicle in a depot was clicked.. */ + case WE_MOUSELOOP: { + const Vehicle *v = _place_clicked_vehicle; + + /* since OTTD checks all open depot windows, we will make sure that it triggers the one with a clicked clone button */ + if (v != NULL && HASBIT(w->click_state, DEPOT_WIDGET_CLONE)) { + _place_clicked_vehicle = NULL; + HandleCloneVehClick(v, w); + } + } break; + + case WE_DESTROY: + DeleteWindowById(WC_BUILD_VEHICLE, w->window_number); + free((void*)WP(w, depot_d).vehicle_list); + free((void*)WP(w, depot_d).wagon_list); + break; + + case WE_DRAGDROP: + switch (e->we.click.widget) { + case DEPOT_WIDGET_MATRIX: { + Vehicle *v; + VehicleID sel = WP(w, depot_d).sel; + + WP(w, depot_d).sel = INVALID_VEHICLE; + SetWindowDirty(w); + + if (WP(w, depot_d).type == VEH_Train) { + GetDepotVehiclePtData gdvp; + + if (GetVehicleFromDepotWndPt(w, e->we.dragdrop.pt.x, e->we.dragdrop.pt.y, &v, &gdvp) == 0 && + sel != INVALID_VEHICLE) { + if (gdvp.wagon != NULL && gdvp.wagon->index == sel && _ctrl_pressed) { + DoCommandP(GetVehicle(sel)->tile, GetVehicle(sel)->index, true, NULL, CMD_REVERSE_TRAIN_DIRECTION | CMD_MSG(STR_9033_CAN_T_MAKE_VEHICLE_TURN)); + } else if (gdvp.wagon == NULL || gdvp.wagon->index != sel) { + TrainDepotMoveVehicle(gdvp.wagon, sel, gdvp.head); + } else if (gdvp.head != NULL && IsFrontEngine(gdvp.head)) { + ShowTrainViewWindow(gdvp.head); + } + } + } else if (GetVehicleFromDepotWndPt(w, e->we.dragdrop.pt.x, e->we.dragdrop.pt.y, &v, NULL) == 0 && + v != NULL && + sel == v->index) { + ShowVehicleViewWindow(v); + } + } break; + + case DEPOT_WIDGET_SELL: case DEPOT_WIDGET_SELL_ALL: + if (!HASBIT(w->disabled_state, DEPOT_WIDGET_SELL) && + WP(w, depot_d).sel != INVALID_VEHICLE) { + Vehicle *v; + uint command; + int sell_cmd; + bool is_engine; + + if (HASBIT(w->disabled_state, e->we.click.widget)) return; + if (WP(w, depot_d).sel == INVALID_VEHICLE) return; + + HandleButtonClick(w, e->we.click.widget); + + v = GetVehicle(WP(w, depot_d).sel); + WP(w, depot_d).sel = INVALID_VEHICLE; + SetWindowDirty(w); + + sell_cmd = (v->type == VEH_Train && (e->we.click.widget == DEPOT_WIDGET_SELL_ALL || _ctrl_pressed)) ? 1 : 0; + + is_engine = (!(v->type == VEH_Train && !IsFrontEngine(v))); + + if (is_engine) { + _backup_orders_tile = v->tile; + BackupVehicleOrders(v, _backup_orders_data); + } + + switch (v->type) { + case VEH_Train: command = CMD_SELL_RAIL_WAGON | CMD_MSG(STR_8839_CAN_T_SELL_RAILROAD_VEHICLE); break; + case VEH_Road: command = CMD_SELL_ROAD_VEH | CMD_MSG(STR_9014_CAN_T_SELL_ROAD_VEHICLE); break; + case VEH_Ship: command = CMD_SELL_SHIP | CMD_MSG(STR_980C_CAN_T_SELL_SHIP); break; + case VEH_Aircraft: command = CMD_SELL_AIRCRAFT | CMD_MSG(STR_A01C_CAN_T_SELL_AIRCRAFT); break; + default: NOT_REACHED(); command = 0; + } + + if (!DoCommandP(v->tile, v->index, sell_cmd, NULL, command) && is_engine) _backup_orders_tile = 0; + } + break; + default: + WP(w, depot_d).sel = INVALID_VEHICLE; + SetWindowDirty(w); + } + break; + + case WE_RESIZE: + w->vscroll.cap += e->we.sizing.diff.y / (int)w->resize.step_height; + w->hscroll.cap += e->we.sizing.diff.x / (int)w->resize.step_width; + w->widget[DEPOT_WIDGET_MATRIX].data = (w->vscroll.cap << 8) + (WP(w, depot_d).type == VEH_Train ? 1 : w->hscroll.cap); + break; + } +} + +static void SetupStringsForDepotWindow(Window *w, byte type) +{ + switch (type) { + case VEH_Train: + w->widget[DEPOT_WIDGET_CAPTION].data = STR_8800_TRAIN_DEPOT; + w->widget[DEPOT_WIDGET_SELL].tooltips = STR_8841_DRAG_TRAIN_VEHICLE_TO_HERE; + w->widget[DEPOT_WIDGET_MATRIX].tooltips = STR_883F_TRAINS_CLICK_ON_TRAIN_FOR; + w->widget[DEPOT_WIDGET_BUILD].data = STR_8815_NEW_VEHICLES; + w->widget[DEPOT_WIDGET_BUILD].tooltips = STR_8840_BUILD_NEW_TRAIN_VEHICLE; + w->widget[DEPOT_WIDGET_CLONE].data = STR_CLONE_TRAIN; + w->widget[DEPOT_WIDGET_CLONE].tooltips = STR_CLONE_TRAIN_DEPOT_INFO; + w->widget[DEPOT_WIDGET_LOCATION].tooltips = STR_8842_CENTER_MAIN_VIEW_ON_TRAIN; + break; + + case VEH_Road: + w->widget[DEPOT_WIDGET_CAPTION].data = STR_9003_ROAD_VEHICLE_DEPOT; + w->widget[DEPOT_WIDGET_SELL].tooltips = STR_9024_DRAG_ROAD_VEHICLE_TO_HERE; + w->widget[DEPOT_WIDGET_MATRIX].tooltips = STR_9022_VEHICLES_CLICK_ON_VEHICLE; + w->widget[DEPOT_WIDGET_BUILD].data = STR_9004_NEW_VEHICLES; + w->widget[DEPOT_WIDGET_BUILD].tooltips = STR_9023_BUILD_NEW_ROAD_VEHICLE; + w->widget[DEPOT_WIDGET_CLONE].data = STR_CLONE_ROAD_VEHICLE; + w->widget[DEPOT_WIDGET_CLONE].tooltips = STR_CLONE_ROAD_VEHICLE_DEPOT_INFO; + w->widget[DEPOT_WIDGET_LOCATION].tooltips = STR_9025_CENTER_MAIN_VIEW_ON_ROAD; + break; + + case VEH_Ship: + w->widget[DEPOT_WIDGET_CAPTION].data = STR_9803_SHIP_DEPOT; + w->widget[DEPOT_WIDGET_SELL].tooltips = STR_9821_DRAG_SHIP_TO_HERE_TO_SELL; + w->widget[DEPOT_WIDGET_MATRIX].tooltips = STR_981F_SHIPS_CLICK_ON_SHIP_FOR; + w->widget[DEPOT_WIDGET_BUILD].data = STR_9804_NEW_SHIPS; + w->widget[DEPOT_WIDGET_BUILD].tooltips = STR_9820_BUILD_NEW_SHIP; + w->widget[DEPOT_WIDGET_CLONE].data = STR_CLONE_SHIP; + w->widget[DEPOT_WIDGET_CLONE].tooltips = STR_CLONE_SHIP_DEPOT_INFO; + w->widget[DEPOT_WIDGET_LOCATION].tooltips = STR_9822_CENTER_MAIN_VIEW_ON_SHIP; + break; + + case VEH_Aircraft: + w->widget[DEPOT_WIDGET_CAPTION].data = STR_A002_AIRCRAFT_HANGAR; + w->widget[DEPOT_WIDGET_SELL].tooltips = STR_A023_DRAG_AIRCRAFT_TO_HERE_TO; + w->widget[DEPOT_WIDGET_MATRIX].tooltips = STR_A021_AIRCRAFT_CLICK_ON_AIRCRAFT; + w->widget[DEPOT_WIDGET_BUILD].data = STR_A003_NEW_AIRCRAFT; + w->widget[DEPOT_WIDGET_BUILD].tooltips = STR_A022_BUILD_NEW_AIRCRAFT; + w->widget[DEPOT_WIDGET_CLONE].data = STR_CLONE_AIRCRAFT; + w->widget[DEPOT_WIDGET_CLONE].tooltips = STR_CLONE_AIRCRAFT_INFO_HANGAR_WINDOW; + w->widget[DEPOT_WIDGET_LOCATION].tooltips = STR_A024_CENTER_MAIN_VIEW_ON_HANGAR; + break; + } +} + +/** Opens a depot window + * @param tile The tile where the depot/hangar is located + * @param type The type of vehicles in the depot + */ +void ShowDepotWindow(TileIndex tile, byte type) +{ + Window *w; + + switch (type) { + case VEH_Train: w = AllocateWindowDescFront(&_train_depot_desc, tile); break; + case VEH_Road: w = AllocateWindowDescFront(&_road_depot_desc, tile); break; + case VEH_Ship: w = AllocateWindowDescFront(&_ship_depot_desc, tile); break; + case VEH_Aircraft: w = AllocateWindowDescFront(&_aircraft_depot_desc, tile); break; + default: NOT_REACHED(); w = NULL; + } + + if (w != NULL) { + int16 horizontal = 0, vertical = 0; + w->caption_color = GetTileOwner(tile); + WP(w, depot_d).type = type; + WP(w, depot_d).sel = INVALID_VEHICLE; + _backup_orders_tile = 0; + + /* Resize the window according to the vehicle type */ + switch (type) { + case VEH_Train: + horizontal = 56; + vertical = 48; + w->vscroll.cap = 6; + w->hscroll.cap = 10 * 29; + w->resize.step_width = 1; + w->resize.step_height = 14; + w->widget[DEPOT_WIDGET_MATRIX].bottom -= 12; // Make room for the horizontal scrollbar + break; + + case VEH_Road: + horizontal = 10; + vertical = -6; + w->vscroll.cap = 3; + w->hscroll.cap = 5; + w->resize.step_width = 56; + w->resize.step_height = 14; + break; + + case VEH_Ship: + w->vscroll.cap = 2; + w->hscroll.cap = 3; + w->resize.step_width = 90; + w->resize.step_height = 24; + break; + + case VEH_Aircraft: + horizontal = 26; + w->vscroll.cap = 2; + w->hscroll.cap = 4; + w->resize.step_width = 74; + w->resize.step_height = 24; + break; + + default: NOT_REACHED(); + } + + SetupStringsForDepotWindow(w, type); + + w->widget[DEPOT_WIDGET_MATRIX].data = + (w->vscroll.cap * 0x100) // number of rows to draw on the background + + (type == VEH_Train ? 1 : w->hscroll.cap); // number of boxes in each row. Trains always have just one + + if (type != VEH_Train) { + SETBIT(w->hidden_state, DEPOT_WIDGET_H_SCROLL); + SETBIT(w->hidden_state, DEPOT_WIDGET_SELL_ALL); + } + + /* Move the widgets to their right locations + * Note: it's signed values so negative will make the widget move left and not right, or up instead of down */ + if (horizontal != 0) { + byte i; + + for (i = 0; i < lengthof(left); i++) w->widget[left[i]].left += horizontal; + for (i = 0; i < lengthof(right); i++) w->widget[right[i]].right += horizontal; + } + + if (vertical != 0) { + byte i; + + for (i = 0; i < lengthof(top); i++) w->widget[top[i]].top += vertical; + for (i = 0; i < lengthof(bottom); i++) w->widget[bottom[i]].bottom += vertical; + } + + /* We got the widget moved around. Now we will make some widgets to fill the gab between some widgets in equal sizes */ + + /* Make the buttons in the bottom equal in size */ + w->widget[DEPOT_WIDGET_BUILD].right = w->widget[DEPOT_WIDGET_LOCATION].right / 3; + w->widget[DEPOT_WIDGET_LOCATION].left = w->widget[DEPOT_WIDGET_BUILD].right * 2; + w->widget[DEPOT_WIDGET_CLONE].left = w->widget[DEPOT_WIDGET_BUILD].right + 1; + w->widget[DEPOT_WIDGET_CLONE].right = w->widget[DEPOT_WIDGET_LOCATION].left - 1; + + if (type == VEH_Train) { + /* Divide the size of DEPOT_WIDGET_SELL into two equally big buttons so DEPOT_WIDGET_SELL and DEPOT_WIDGET_SELL_ALL will get the same size. + * This way it will stay the same even if DEPOT_WIDGET_SELL_ALL is resized for some reason */ + w->widget[DEPOT_WIDGET_SELL_ALL].bottom = w->widget[DEPOT_WIDGET_SELL].bottom; + w->widget[DEPOT_WIDGET_SELL_ALL].top = ((w->widget[DEPOT_WIDGET_SELL_ALL].bottom - w->widget[DEPOT_WIDGET_SELL].top) / 2) + w->widget[DEPOT_WIDGET_SELL].top; + w->widget[DEPOT_WIDGET_SELL].bottom = w->widget[DEPOT_WIDGET_SELL_ALL].top - 1; + } + } +} |