9624
|
1 |
/* $Id$ */
|
|
2 |
|
|
3 |
/** @file group_gui.cpp */
|
|
4 |
|
|
5 |
#include "stdafx.h"
|
|
6 |
#include "openttd.h"
|
|
7 |
#include "functions.h"
|
|
8 |
#include "table/strings.h"
|
|
9 |
#include "table/sprites.h"
|
|
10 |
#include "window.h"
|
|
11 |
#include "gui.h"
|
|
12 |
#include "gfx.h"
|
|
13 |
#include "vehicle.h"
|
|
14 |
#include "command.h"
|
|
15 |
#include "engine.h"
|
|
16 |
#include "vehicle_gui.h"
|
|
17 |
#include "depot.h"
|
|
18 |
#include "train.h"
|
|
19 |
#include "date.h"
|
|
20 |
#include "group.h"
|
|
21 |
#include "helpers.hpp"
|
|
22 |
#include "viewport.h"
|
|
23 |
#include "strings.h"
|
|
24 |
#include "debug.h"
|
|
25 |
|
|
26 |
|
|
27 |
struct Sorting {
|
|
28 |
Listing aircraft;
|
|
29 |
Listing roadveh;
|
|
30 |
Listing ship;
|
|
31 |
Listing train;
|
|
32 |
};
|
|
33 |
|
|
34 |
static Sorting _sorting;
|
|
35 |
|
|
36 |
|
|
37 |
static void BuildGroupList(grouplist_d* gl, PlayerID owner, VehicleType vehicle_type)
|
|
38 |
{
|
|
39 |
const Group** list;
|
|
40 |
const Group *g;
|
|
41 |
uint n = 0;
|
|
42 |
|
|
43 |
if (!(gl->l.flags & VL_REBUILD)) return;
|
|
44 |
|
|
45 |
list = MallocT<const Group*>(GetGroupArraySize());
|
|
46 |
if (list == NULL) {
|
|
47 |
error("Could not allocate memory for the group-sorting-list");
|
|
48 |
}
|
|
49 |
|
|
50 |
FOR_ALL_GROUPS(g) {
|
|
51 |
if (g->owner == owner && g->vehicle_type == vehicle_type) list[n++] = g;
|
|
52 |
}
|
|
53 |
|
|
54 |
free((void*)gl->sort_list);
|
|
55 |
gl->sort_list = MallocT<const Group *>(n);
|
|
56 |
if (n != 0 && gl->sort_list == NULL) {
|
|
57 |
error("Could not allocate memory for the group-sorting-list");
|
|
58 |
}
|
|
59 |
gl->l.list_length = n;
|
|
60 |
|
|
61 |
for (uint i = 0; i < n; ++i) gl->sort_list[i] = list[i];
|
|
62 |
free((void*)list);
|
|
63 |
|
|
64 |
gl->l.flags &= ~VL_REBUILD;
|
|
65 |
gl->l.flags |= VL_RESORT;
|
|
66 |
}
|
|
67 |
|
|
68 |
|
|
69 |
static int CDECL GroupNameSorter(const void *a, const void *b)
|
|
70 |
{
|
|
71 |
static const Group *last_group[2] = { NULL, NULL };
|
|
72 |
static char last_name[2][64] = { "", "" };
|
|
73 |
|
|
74 |
const Group *ga = *(const Group**)a;
|
|
75 |
const Group *gb = *(const Group**)b;
|
|
76 |
int r;
|
|
77 |
|
|
78 |
if (ga != last_group[0]) {
|
|
79 |
last_group[0] = ga;
|
|
80 |
SetDParam(0, ga->index);
|
|
81 |
GetString(last_name[0], ga->string_id, lastof(last_name[0]));
|
|
82 |
}
|
|
83 |
|
|
84 |
if (gb != last_group[1]) {
|
|
85 |
last_group[1] = gb;
|
|
86 |
SetDParam(0, gb->index);
|
|
87 |
GetString(last_name[1], gb->string_id, lastof(last_name[1]));
|
|
88 |
}
|
|
89 |
|
|
90 |
r = strcmp(last_name[0], last_name[1]); // sort by name
|
|
91 |
|
|
92 |
if (r == 0) return ga->index - gb->index;
|
|
93 |
|
|
94 |
return r;
|
|
95 |
}
|
|
96 |
|
|
97 |
|
|
98 |
static void SortGroupList(grouplist_d *gl)
|
|
99 |
{
|
|
100 |
if (!(gl->l.flags & VL_RESORT)) return;
|
|
101 |
|
|
102 |
qsort((void*)gl->sort_list, gl->l.list_length, sizeof(gl->sort_list[0]), GroupNameSorter);
|
|
103 |
|
|
104 |
gl->l.resort_timer = DAY_TICKS * PERIODIC_RESORT_DAYS;
|
|
105 |
gl->l.flags &= ~VL_RESORT;
|
|
106 |
}
|
|
107 |
|
|
108 |
|
|
109 |
enum GroupListWidgets {
|
|
110 |
GRP_WIDGET_CLOSEBOX = 0,
|
|
111 |
GRP_WIDGET_CAPTION,
|
|
112 |
GRP_WIDGET_STICKY,
|
|
113 |
GRP_WIDGET_EMPTY_TOP_LEFT,
|
|
114 |
GRP_WIDGET_ALL_VEHICLES,
|
|
115 |
GRP_WIDGET_LIST_GROUP,
|
|
116 |
GRP_WIDGET_LIST_GROUP_SCROLLBAR,
|
|
117 |
GRP_WIDGET_SORT_BY_ORDER,
|
|
118 |
GRP_WIDGET_SORT_BY_TEXT,
|
|
119 |
GRP_WIDGET_SORT_BY_DROPDOWN,
|
|
120 |
GRP_WIDGET_EMPTY_TOP_RIGHT,
|
|
121 |
GRP_WIDGET_LIST_VEHICLE,
|
|
122 |
GRP_WIDGET_LIST_VEHICLE_SCROLLBAR,
|
|
123 |
GRP_WIDGET_CREATE_GROUP,
|
|
124 |
GRP_WIDGET_DELETE_GROUP,
|
|
125 |
GRP_WIDGET_RENAME_GROUP,
|
|
126 |
GRP_WIDGET_EMPTY1,
|
|
127 |
GRP_WIDGET_REPLACE_PROTECTION,
|
|
128 |
GRP_WIDGET_EMPTY2,
|
|
129 |
GRP_WIDGET_AVAILABLE_VEHICLES,
|
|
130 |
GRP_WIDGET_MANAGE_VEHICLES,
|
|
131 |
GRP_WIDGET_MANAGE_VEHICLES_DROPDOWN,
|
|
132 |
GRP_WIDGET_STOP_ALL,
|
|
133 |
GRP_WIDGET_START_ALL,
|
|
134 |
GRP_WIDGET_EMPTY_BOTTOM_RIGHT,
|
|
135 |
GRP_WIDGET_RESIZE,
|
|
136 |
};
|
|
137 |
|
|
138 |
|
|
139 |
static const Widget _group_widgets[] = {
|
|
140 |
{ WWT_CLOSEBOX, RESIZE_NONE, 14, 0, 10, 0, 13, STR_00C5, STR_018B_CLOSE_WINDOW},
|
|
141 |
{ WWT_CAPTION, RESIZE_RIGHT, 14, 11, 513, 0, 13, 0x0, STR_018C_WINDOW_TITLE_DRAG_THIS},
|
|
142 |
{ WWT_STICKYBOX, RESIZE_LR, 14, 514, 525, 0, 13, 0x0, STR_STICKY_BUTTON},
|
|
143 |
{ WWT_PANEL, RESIZE_NONE, 14, 0, 200, 14, 25, 0x0, STR_NULL},
|
|
144 |
{ WWT_PANEL, RESIZE_NONE, 14, 0, 200, 26, 39, 0x0, STR_NULL},
|
|
145 |
{ WWT_MATRIX, RESIZE_BOTTOM, 14, 0, 188, 39, 220, 0x701, STR_GROUPS_CLICK_ON_GROUP_FOR_TIP},
|
|
146 |
{ WWT_SCROLLBAR, RESIZE_BOTTOM, 14, 189, 200, 26, 220, 0x0, STR_0190_SCROLL_BAR_SCROLLS_LIST},
|
|
147 |
{ WWT_PUSHTXTBTN, RESIZE_NONE, 14, 201, 281, 14, 25, STR_SORT_BY, STR_SORT_ORDER_TIP},
|
|
148 |
{ WWT_PANEL, RESIZE_NONE, 14, 282, 435, 14, 25, 0x0, STR_SORT_CRITERIA_TIP},
|
|
149 |
{ WWT_TEXTBTN, RESIZE_NONE, 14, 436, 447, 14, 25, STR_0225, STR_SORT_CRITERIA_TIP},
|
|
150 |
{ WWT_PANEL, RESIZE_RIGHT, 14, 448, 525, 14, 25, 0x0, STR_NULL},
|
|
151 |
{ WWT_MATRIX, RESIZE_RB, 14, 201, 513, 26, 233, 0x701, STR_NULL},
|
|
152 |
{ WWT_SCROLL2BAR, RESIZE_LRB, 14, 514, 525, 26, 233, 0x0, STR_0190_SCROLL_BAR_SCROLLS_LIST},
|
|
153 |
{ WWT_PUSHIMGBTN, RESIZE_TB, 14, 0, 23, 221, 245, 0x0, STR_GROUP_CREATE_TIP},
|
|
154 |
{ WWT_PUSHIMGBTN, RESIZE_TB, 14, 24, 47, 221, 245, 0x0, STR_GROUP_DELETE_TIP},
|
|
155 |
{ WWT_PUSHIMGBTN, RESIZE_TB, 14, 48, 71, 221, 245, 0x0, STR_GROUP_RENAME_TIP},
|
|
156 |
{ WWT_PANEL, RESIZE_TB, 14, 72, 164, 221, 245, 0x0, STR_NULL},
|
|
157 |
{ WWT_PUSHIMGBTN, RESIZE_TB, 14, 165, 188, 221, 245, 0x0, STR_GROUP_REPLACE_PROTECTION_TIP},
|
|
158 |
{ WWT_PANEL, RESIZE_TB, 14, 189, 200, 221, 245, 0x0, STR_NULL},
|
|
159 |
{ WWT_PUSHTXTBTN, RESIZE_TB, 14, 201, 306, 234, 245, 0x0, STR_AVAILABLE_ENGINES_TIP},
|
|
160 |
{ WWT_TEXTBTN, RESIZE_TB, 14, 307, 411, 234, 245, STR_MANAGE_LIST, STR_MANAGE_LIST_TIP},
|
|
161 |
{ WWT_TEXTBTN, RESIZE_TB, 14, 412, 423, 234, 245, STR_0225, STR_MANAGE_LIST_TIP},
|
|
162 |
{ WWT_PUSHIMGBTN, RESIZE_TB, 14, 424, 435, 234, 245, SPR_FLAG_VEH_STOPPED, STR_MASS_STOP_LIST_TIP},
|
|
163 |
{ WWT_PUSHIMGBTN, RESIZE_TB, 14, 436, 447, 234, 245, SPR_FLAG_VEH_RUNNING, STR_MASS_START_LIST_TIP},
|
|
164 |
{ WWT_PANEL, RESIZE_RTB, 14, 448, 513, 234, 245, 0x0, STR_NULL},
|
|
165 |
{ WWT_RESIZEBOX, RESIZE_LRTB, 14, 514, 525, 234, 245, 0x0, STR_RESIZE_BUTTON},
|
|
166 |
{ WIDGETS_END},
|
|
167 |
};
|
|
168 |
|
|
169 |
|
|
170 |
static void CreateVehicleGroupWindow(Window *w)
|
|
171 |
{
|
|
172 |
const PlayerID owner = (PlayerID)GB(w->window_number, 0, 8);
|
|
173 |
groupveh_d *gv = &WP(w, groupveh_d);
|
|
174 |
grouplist_d *gl = &WP(w, groupveh_d).gl;
|
|
175 |
|
|
176 |
w->caption_color = owner;
|
|
177 |
w->hscroll.cap = 10 * 29;
|
|
178 |
w->resize.step_width = 1;
|
|
179 |
|
|
180 |
switch (gv->vehicle_type) {
|
|
181 |
default: NOT_REACHED();
|
|
182 |
case VEH_TRAIN:
|
|
183 |
case VEH_ROAD:
|
|
184 |
w->vscroll.cap = 14;
|
|
185 |
w->vscroll2.cap = 8;
|
|
186 |
w->resize.step_height = PLY_WND_PRC__SIZE_OF_ROW_SMALL;
|
|
187 |
break;
|
|
188 |
case VEH_SHIP:
|
|
189 |
case VEH_AIRCRAFT:
|
|
190 |
w->vscroll.cap = 10;
|
|
191 |
w->vscroll2.cap = 4;
|
|
192 |
w->resize.step_height = PLY_WND_PRC__SIZE_OF_ROW_BIG2;
|
|
193 |
break;
|
|
194 |
}
|
|
195 |
|
|
196 |
w->widget[GRP_WIDGET_LIST_GROUP].data = (w->vscroll.cap << 8) + 1;
|
|
197 |
w->widget[GRP_WIDGET_LIST_VEHICLE].data = (w->vscroll2.cap << 8) + 1;
|
|
198 |
|
|
199 |
switch (gv->vehicle_type) {
|
|
200 |
default: NOT_REACHED(); break;
|
|
201 |
case VEH_TRAIN: gv->_sorting = &_sorting.train; break;
|
|
202 |
case VEH_ROAD: gv->_sorting = &_sorting.roadveh; break;
|
|
203 |
case VEH_SHIP: gv->_sorting = &_sorting.ship; break;
|
|
204 |
case VEH_AIRCRAFT: gv->_sorting = &_sorting.aircraft; break;
|
|
205 |
}
|
|
206 |
|
|
207 |
gv->sort_list = NULL;
|
|
208 |
gv->vehicle_type = (VehicleType)GB(w->window_number, 11, 5);
|
|
209 |
gv->l.sort_type = gv->_sorting->criteria;
|
|
210 |
gv->l.flags = VL_REBUILD | (gv->_sorting->order ? VL_DESC : VL_NONE);
|
|
211 |
gv->l.resort_timer = DAY_TICKS * PERIODIC_RESORT_DAYS; // Set up resort timer
|
|
212 |
|
|
213 |
gl->sort_list = NULL;
|
|
214 |
gl->l.flags = VL_REBUILD | VL_NONE;
|
|
215 |
gl->l.resort_timer = DAY_TICKS * PERIODIC_RESORT_DAYS; // Set up resort timer
|
|
216 |
|
|
217 |
gv->group_sel = DEFAULT_GROUP;
|
|
218 |
|
|
219 |
switch (gv->vehicle_type) {
|
|
220 |
case VEH_TRAIN:
|
|
221 |
w->widget[GRP_WIDGET_LIST_VEHICLE].tooltips = STR_883D_TRAINS_CLICK_ON_TRAIN_FOR;
|
|
222 |
w->widget[GRP_WIDGET_AVAILABLE_VEHICLES].data = STR_AVAILABLE_TRAINS;
|
|
223 |
|
|
224 |
w->widget[GRP_WIDGET_CREATE_GROUP].data = SPR_GROUP_CREATE_TRAIN;
|
|
225 |
w->widget[GRP_WIDGET_RENAME_GROUP].data = SPR_GROUP_RENAME_TRAIN;
|
|
226 |
w->widget[GRP_WIDGET_DELETE_GROUP].data = SPR_GROUP_DELETE_TRAIN;
|
|
227 |
break;
|
|
228 |
|
|
229 |
case VEH_ROAD:
|
|
230 |
w->widget[GRP_WIDGET_LIST_VEHICLE].tooltips = STR_901A_ROAD_VEHICLES_CLICK_ON;
|
|
231 |
w->widget[GRP_WIDGET_AVAILABLE_VEHICLES].data = STR_AVAILABLE_ROAD_VEHICLES;
|
|
232 |
|
|
233 |
w->widget[GRP_WIDGET_CREATE_GROUP].data = SPR_GROUP_CREATE_ROADVEH;
|
|
234 |
w->widget[GRP_WIDGET_RENAME_GROUP].data = SPR_GROUP_RENAME_ROADVEH;
|
|
235 |
w->widget[GRP_WIDGET_DELETE_GROUP].data = SPR_GROUP_DELETE_ROADVEH;
|
|
236 |
break;
|
|
237 |
|
|
238 |
case VEH_SHIP:
|
|
239 |
w->widget[GRP_WIDGET_LIST_VEHICLE].tooltips = STR_9823_SHIPS_CLICK_ON_SHIP_FOR;
|
|
240 |
w->widget[GRP_WIDGET_AVAILABLE_VEHICLES].data = STR_AVAILABLE_SHIPS;
|
|
241 |
|
|
242 |
w->widget[GRP_WIDGET_CREATE_GROUP].data = SPR_GROUP_CREATE_SHIP;
|
|
243 |
w->widget[GRP_WIDGET_RENAME_GROUP].data = SPR_GROUP_RENAME_SHIP;
|
|
244 |
w->widget[GRP_WIDGET_DELETE_GROUP].data = SPR_GROUP_DELETE_SHIP;
|
|
245 |
break;
|
|
246 |
|
|
247 |
case VEH_AIRCRAFT:
|
|
248 |
w->widget[GRP_WIDGET_LIST_VEHICLE].tooltips = STR_A01F_AIRCRAFT_CLICK_ON_AIRCRAFT;
|
|
249 |
w->widget[GRP_WIDGET_AVAILABLE_VEHICLES].data = STR_AVAILABLE_AIRCRAFT;
|
|
250 |
|
|
251 |
w->widget[GRP_WIDGET_CREATE_GROUP].data = SPR_GROUP_CREATE_AIRCRAFT;
|
|
252 |
w->widget[GRP_WIDGET_RENAME_GROUP].data = SPR_GROUP_RENAME_AIRCRAFT;
|
|
253 |
w->widget[GRP_WIDGET_DELETE_GROUP].data = SPR_GROUP_DELETE_AIRCRAFT;
|
|
254 |
break;
|
|
255 |
|
|
256 |
default: NOT_REACHED();
|
|
257 |
}
|
|
258 |
}
|
|
259 |
|
|
260 |
/**
|
|
261 |
* Update/redraw the group action dropdown
|
|
262 |
* @param w the window the dropdown belongs to
|
|
263 |
* @param gid the currently selected group in the window
|
|
264 |
*/
|
|
265 |
static void UpdateGroupActionDropdown(Window *w, GroupID gid, bool refresh = true)
|
|
266 |
{
|
|
267 |
if (refresh && !IsWindowWidgetLowered(w, GRP_WIDGET_MANAGE_VEHICLES_DROPDOWN)) return;
|
|
268 |
|
|
269 |
static StringID action_str[] = {
|
|
270 |
STR_REPLACE_VEHICLES,
|
|
271 |
STR_SEND_FOR_SERVICING,
|
|
272 |
STR_SEND_TRAIN_TO_DEPOT,
|
|
273 |
STR_NULL,
|
|
274 |
STR_NULL,
|
|
275 |
INVALID_STRING_ID
|
|
276 |
};
|
|
277 |
|
|
278 |
action_str[3] = IsDefaultGroupID(gid) ? INVALID_STRING_ID : STR_GROUP_ADD_SHARED_VEHICLE;
|
|
279 |
action_str[4] = IsDefaultGroupID(gid) ? INVALID_STRING_ID : STR_GROUP_REMOVE_ALL_VEHICLES;
|
|
280 |
|
|
281 |
ShowDropDownMenu(w, action_str, 0, GRP_WIDGET_MANAGE_VEHICLES_DROPDOWN, 0, 0);
|
|
282 |
}
|
|
283 |
|
|
284 |
/**
|
|
285 |
* bitmask for w->window_number
|
|
286 |
* 0-7 PlayerID (owner)
|
|
287 |
* 11-15 vehicle type
|
|
288 |
**/
|
|
289 |
static void GroupWndProc(Window *w, WindowEvent *e)
|
|
290 |
{
|
|
291 |
const PlayerID owner = (PlayerID)GB(w->window_number, 0, 8);
|
|
292 |
const Player *p = GetPlayer(owner);
|
|
293 |
groupveh_d *gv = &WP(w, groupveh_d);
|
|
294 |
grouplist_d *gl = &WP(w, groupveh_d).gl;
|
|
295 |
|
|
296 |
gv->vehicle_type = (VehicleType)GB(w->window_number, 11, 5);
|
|
297 |
|
|
298 |
switch(e->event) {
|
|
299 |
case WE_INVALIDATE_DATA:
|
|
300 |
gv->l.flags |= VL_REBUILD;
|
|
301 |
gl->l.flags |= VL_REBUILD;
|
|
302 |
UpdateGroupActionDropdown(w, gv->group_sel);
|
|
303 |
SetWindowDirty(w);
|
|
304 |
break;
|
|
305 |
|
|
306 |
case WE_CREATE:
|
|
307 |
CreateVehicleGroupWindow(w);
|
|
308 |
break;
|
|
309 |
|
|
310 |
case WE_PAINT: {
|
|
311 |
int x = 203;
|
|
312 |
int y2 = PLY_WND_PRC__OFFSET_TOP_WIDGET;
|
|
313 |
int y1 = PLY_WND_PRC__OFFSET_TOP_WIDGET + 2;
|
|
314 |
int max;
|
|
315 |
int i;
|
|
316 |
|
|
317 |
/* If we select the default group, gv->list will contain all vehicles of the player
|
|
318 |
* else gv->list will contain all vehicles which belong to the selected group */
|
|
319 |
BuildVehicleList(gv, owner, gv->group_sel, IsDefaultGroupID(gv->group_sel) ? VLW_STANDARD : VLW_GROUP_LIST);
|
|
320 |
SortVehicleList(gv);
|
|
321 |
|
|
322 |
|
|
323 |
BuildGroupList(gl, owner, gv->vehicle_type);
|
|
324 |
SortGroupList(gl);
|
|
325 |
|
|
326 |
SetVScrollCount(w, gl->l.list_length);
|
|
327 |
SetVScroll2Count(w, gv->l.list_length);
|
|
328 |
|
|
329 |
/* Disable all lists management button when the list is empty */
|
|
330 |
SetWindowWidgetsDisabledState(w, gv->l.list_length == 0,
|
|
331 |
GRP_WIDGET_STOP_ALL,
|
|
332 |
GRP_WIDGET_START_ALL,
|
|
333 |
GRP_WIDGET_MANAGE_VEHICLES,
|
|
334 |
GRP_WIDGET_MANAGE_VEHICLES_DROPDOWN,
|
|
335 |
WIDGET_LIST_END);
|
|
336 |
|
|
337 |
/* Disable the group specific function when we select the default group */
|
|
338 |
SetWindowWidgetsDisabledState(w, IsDefaultGroupID(gv->group_sel),
|
|
339 |
GRP_WIDGET_DELETE_GROUP,
|
|
340 |
GRP_WIDGET_RENAME_GROUP,
|
|
341 |
GRP_WIDGET_REPLACE_PROTECTION,
|
|
342 |
WIDGET_LIST_END);
|
|
343 |
|
|
344 |
/* If selected_group == DEFAULT_GROUP, draw the standard caption
|
|
345 |
We list all vehicles */
|
|
346 |
if (IsDefaultGroupID(gv->group_sel)) {
|
|
347 |
SetDParam(0, p->name_1);
|
|
348 |
SetDParam(1, p->name_2);
|
|
349 |
SetDParam(2, gv->l.list_length);
|
|
350 |
|
|
351 |
switch (gv->vehicle_type) {
|
|
352 |
case VEH_TRAIN:
|
|
353 |
w->widget[GRP_WIDGET_CAPTION].data = STR_881B_TRAINS;
|
|
354 |
w->widget[GRP_WIDGET_REPLACE_PROTECTION].data = SPR_GROUP_REPLACE_OFF_TRAIN;
|
|
355 |
break;
|
|
356 |
case VEH_ROAD:
|
|
357 |
w->widget[GRP_WIDGET_CAPTION].data = STR_9001_ROAD_VEHICLES;
|
|
358 |
w->widget[GRP_WIDGET_REPLACE_PROTECTION].data = SPR_GROUP_REPLACE_OFF_ROADVEH;
|
|
359 |
break;
|
|
360 |
case VEH_SHIP:
|
|
361 |
w->widget[GRP_WIDGET_CAPTION].data = STR_9805_SHIPS;
|
|
362 |
w->widget[GRP_WIDGET_REPLACE_PROTECTION].data = SPR_GROUP_REPLACE_OFF_SHIP;
|
|
363 |
break;
|
|
364 |
case VEH_AIRCRAFT:
|
|
365 |
w->widget[GRP_WIDGET_CAPTION].data = STR_A009_AIRCRAFT;
|
|
366 |
w->widget[GRP_WIDGET_REPLACE_PROTECTION].data = SPR_GROUP_REPLACE_OFF_AIRCRAFT;
|
|
367 |
break;
|
|
368 |
default: NOT_REACHED(); break;
|
|
369 |
}
|
|
370 |
} else {
|
|
371 |
const Group *g = GetGroup(gv->group_sel);
|
|
372 |
|
|
373 |
SetDParam(0, g->index);
|
|
374 |
SetDParam(1, g->num_vehicle);
|
|
375 |
|
|
376 |
switch (gv->vehicle_type) {
|
|
377 |
case VEH_TRAIN:
|
|
378 |
w->widget[GRP_WIDGET_CAPTION].data = STR_GROUP_TRAINS_CAPTION;
|
|
379 |
w->widget[GRP_WIDGET_REPLACE_PROTECTION].data = (g->replace_protection) ? SPR_GROUP_REPLACE_ON_TRAIN : SPR_GROUP_REPLACE_OFF_TRAIN;
|
|
380 |
break;
|
|
381 |
case VEH_ROAD:
|
|
382 |
w->widget[GRP_WIDGET_CAPTION].data = STR_GROUP_ROADVEH_CAPTION;
|
|
383 |
w->widget[GRP_WIDGET_REPLACE_PROTECTION].data = (g->replace_protection) ? SPR_GROUP_REPLACE_ON_ROADVEH : SPR_GROUP_REPLACE_OFF_ROADVEH;
|
|
384 |
break;
|
|
385 |
case VEH_SHIP:
|
|
386 |
w->widget[GRP_WIDGET_CAPTION].data = STR_GROUP_SHIPS_CAPTION;
|
|
387 |
w->widget[GRP_WIDGET_REPLACE_PROTECTION].data = (g->replace_protection) ? SPR_GROUP_REPLACE_ON_SHIP : SPR_GROUP_REPLACE_OFF_SHIP;
|
|
388 |
break;
|
|
389 |
case VEH_AIRCRAFT:
|
|
390 |
w->widget[GRP_WIDGET_CAPTION].data = STR_GROUP_AIRCRAFTS_CAPTION;
|
|
391 |
w->widget[GRP_WIDGET_REPLACE_PROTECTION].data = (g->replace_protection) ? SPR_GROUP_REPLACE_ON_AIRCRAFT : SPR_GROUP_REPLACE_OFF_AIRCRAFT;
|
|
392 |
break;
|
|
393 |
default: NOT_REACHED(); break;
|
|
394 |
}
|
|
395 |
}
|
|
396 |
|
|
397 |
|
|
398 |
DrawWindowWidgets(w);
|
|
399 |
|
|
400 |
/* Draw Matrix Group
|
|
401 |
* The selected group is drawn in white */
|
|
402 |
StringID str;
|
|
403 |
|
|
404 |
switch (gv->vehicle_type) {
|
|
405 |
case VEH_TRAIN: str = STR_GROUP_ALL_TRAINS; break;
|
|
406 |
case VEH_ROAD: str = STR_GROUP_ALL_ROADS; break;
|
|
407 |
case VEH_SHIP: str = STR_GROUP_ALL_SHIPS; break;
|
|
408 |
case VEH_AIRCRAFT: str = STR_GROUP_ALL_AIRCRAFTS; break;
|
|
409 |
default: NOT_REACHED(); break;
|
|
410 |
}
|
|
411 |
DrawString(10, y1, str, IsDefaultGroupID(gv->group_sel) ? 12 : 16);
|
|
412 |
|
|
413 |
max = min(w->vscroll.pos + w->vscroll.cap, gl->l.list_length);
|
|
414 |
for (i = w->vscroll.pos ; i < max ; ++i) {
|
|
415 |
const Group *g = gl->sort_list[i];
|
|
416 |
|
|
417 |
assert(g->owner == owner);
|
|
418 |
|
|
419 |
y1 += PLY_WND_PRC__SIZE_OF_ROW_TINY;
|
|
420 |
|
|
421 |
/* draw the selected group in white, else we draw it in black */
|
|
422 |
SetDParam(0, g->index);
|
|
423 |
DrawString(10, y1, STR_SV_GROUP_NAME, (gv->group_sel == g->index) ? 12 : 16);
|
|
424 |
|
|
425 |
/* draw the number of vehicles of the group */
|
|
426 |
SetDParam(0, g->num_vehicle);
|
|
427 |
DrawStringRightAligned(187, y1 + 1, STR_GROUP_TINY_NUM, (gv->group_sel == g->index) ? 12 : 16);
|
|
428 |
}
|
|
429 |
|
|
430 |
/* Draw Matrix Vehicle according to the vehicle list built before */
|
|
431 |
DrawString(285, 15, _vehicle_sort_listing[gv->l.sort_type], 0x10);
|
|
432 |
DoDrawString(gv->l.flags & VL_DESC ? DOWNARROW : UPARROW, 269, 15, 0x10);
|
|
433 |
|
|
434 |
max = min(w->vscroll2.pos + w->vscroll2.cap, gv->l.list_length);
|
|
435 |
for (i = w->vscroll2.pos ; i < max ; ++i) {
|
|
436 |
const Vehicle* v = gv->sort_list[i];
|
|
437 |
StringID str;
|
|
438 |
|
|
439 |
assert(v->type == gv->vehicle_type && v->owner == owner);
|
|
440 |
|
|
441 |
DrawVehicleImage(v, x + 19, y2 + 6, w->hscroll.cap, 0, gv->vehicle_sel);
|
|
442 |
DrawVehicleProfitButton(v, x, y2 + 13);
|
|
443 |
|
|
444 |
if (IsVehicleInDepot(v)) {
|
|
445 |
str = STR_021F;
|
|
446 |
} else {
|
|
447 |
str = v->age > v->max_age - 366 ? STR_00E3 : STR_00E2;
|
|
448 |
}
|
|
449 |
SetDParam(0, v->unitnumber);
|
|
450 |
DrawString(x, y2 + 2, str, 0);
|
|
451 |
|
|
452 |
if (w->resize.step_height == PLY_WND_PRC__SIZE_OF_ROW_BIG2) DrawSmallOrderList(v, x + 138, y2);
|
|
453 |
|
|
454 |
if (v->profit_this_year < 0) {
|
|
455 |
str = v->profit_last_year < 0 ?
|
|
456 |
STR_PROFIT_BAD_THIS_YEAR_BAD_LAST_YEAR :
|
|
457 |
STR_PROFIT_BAD_THIS_YEAR_GOOD_LAST_YEAR;
|
|
458 |
} else {
|
|
459 |
str = v->profit_last_year < 0 ?
|
|
460 |
STR_PROFIT_GOOD_THIS_YEAR_BAD_LAST_YEAR :
|
|
461 |
STR_PROFIT_GOOD_THIS_YEAR_GOOD_LAST_YEAR;
|
|
462 |
}
|
|
463 |
|
|
464 |
SetDParam(0, v->profit_this_year);
|
|
465 |
SetDParam(1, v->profit_last_year);
|
|
466 |
DrawString(x + 19, y2 + w->resize.step_height - 8, str, 0);
|
|
467 |
|
|
468 |
if (IsValidGroupID(v->group_id)) {
|
|
469 |
SetDParam(0, v->group_id);
|
|
470 |
DrawString(x + 19, y2, STR_GROUP_TINY_NAME, 16);
|
|
471 |
}
|
|
472 |
|
|
473 |
y2 += w->resize.step_height;
|
|
474 |
}
|
|
475 |
|
|
476 |
break;
|
|
477 |
}
|
|
478 |
|
|
479 |
case WE_CLICK:
|
|
480 |
switch(e->we.click.widget) {
|
|
481 |
case GRP_WIDGET_SORT_BY_ORDER: // Flip sorting method ascending/descending
|
|
482 |
gv->l.flags ^= VL_DESC;
|
|
483 |
gv->l.flags |= VL_RESORT;
|
|
484 |
|
|
485 |
gv->_sorting->order = !!(gv->l.flags & VL_DESC);
|
|
486 |
SetWindowDirty(w);
|
|
487 |
break;
|
|
488 |
|
|
489 |
case GRP_WIDGET_SORT_BY_TEXT:
|
|
490 |
case GRP_WIDGET_SORT_BY_DROPDOWN: // Select sorting criteria dropdown menu
|
|
491 |
ShowDropDownMenu(w, _vehicle_sort_listing, gv->l.sort_type, GRP_WIDGET_SORT_BY_DROPDOWN, 0, 0);
|
|
492 |
return;
|
|
493 |
|
|
494 |
case GRP_WIDGET_ALL_VEHICLES: // All vehicles button
|
|
495 |
if (!IsDefaultGroupID(gv->group_sel)) {
|
|
496 |
gv->group_sel = DEFAULT_GROUP;
|
|
497 |
gv->l.flags |= VL_REBUILD;
|
|
498 |
UpdateGroupActionDropdown(w, gv->group_sel);
|
|
499 |
SetWindowDirty(w);
|
|
500 |
}
|
|
501 |
break;
|
|
502 |
|
|
503 |
case GRP_WIDGET_LIST_GROUP: { // Matrix Group
|
|
504 |
uint16 id_g = (e->we.click.pt.y - PLY_WND_PRC__OFFSET_TOP_WIDGET - 13) / PLY_WND_PRC__SIZE_OF_ROW_TINY;
|
|
505 |
|
|
506 |
if (id_g >= w->vscroll.cap) return;
|
|
507 |
|
|
508 |
id_g += w->vscroll.pos;
|
|
509 |
|
|
510 |
if (id_g >= gl->l.list_length) return;
|
|
511 |
|
|
512 |
gv->group_sel = gl->sort_list[id_g]->index;;
|
|
513 |
|
|
514 |
gv->l.flags |= VL_REBUILD;
|
|
515 |
UpdateGroupActionDropdown(w, gv->group_sel);
|
|
516 |
SetWindowDirty(w);
|
|
517 |
break;
|
|
518 |
}
|
|
519 |
|
|
520 |
case GRP_WIDGET_LIST_VEHICLE: { // Matrix Vehicle
|
|
521 |
uint32 id_v = (e->we.click.pt.y - PLY_WND_PRC__OFFSET_TOP_WIDGET) / (int)w->resize.step_height;
|
|
522 |
const Vehicle *v;
|
|
523 |
|
|
524 |
if (id_v >= w->vscroll2.cap) return; // click out of bounds
|
|
525 |
|
|
526 |
id_v += w->vscroll2.pos;
|
|
527 |
|
|
528 |
if (id_v >= gv->l.list_length) return; // click out of list bound
|
|
529 |
|
|
530 |
v = gv->sort_list[id_v];
|
|
531 |
|
|
532 |
gv->vehicle_sel = v->index;
|
|
533 |
|
|
534 |
if (IsValidVehicle(v)) {
|
|
535 |
CursorID image;
|
|
536 |
|
|
537 |
switch (gv->vehicle_type) {
|
|
538 |
case VEH_TRAIN: image = GetTrainImage(v, DIR_W); break;
|
|
539 |
case VEH_ROAD: image = GetRoadVehImage(v, DIR_W); break;
|
|
540 |
case VEH_SHIP: image = GetShipImage(v, DIR_W); break;
|
|
541 |
case VEH_AIRCRAFT: image = GetAircraftImage(v, DIR_W); break;
|
|
542 |
default: NOT_REACHED(); break;
|
|
543 |
}
|
|
544 |
|
|
545 |
SetObjectToPlaceWnd(image, GetVehiclePalette(v), 4, w);
|
|
546 |
}
|
|
547 |
|
|
548 |
SetWindowDirty(w);
|
|
549 |
break;
|
|
550 |
}
|
|
551 |
|
|
552 |
case GRP_WIDGET_CREATE_GROUP: // Create a new group
|
|
553 |
DoCommandP(0, gv->vehicle_type, 0, NULL, CMD_CREATE_GROUP | CMD_MSG(STR_GROUP_CAN_T_CREATE));
|
|
554 |
break;
|
|
555 |
|
|
556 |
case GRP_WIDGET_DELETE_GROUP: { // Delete the selected group
|
|
557 |
GroupID group = gv->group_sel;
|
|
558 |
gv->group_sel = DEFAULT_GROUP;
|
|
559 |
|
|
560 |
DoCommandP(0, group, 0, NULL, CMD_DELETE_GROUP | CMD_MSG(STR_GROUP_CAN_T_DELETE));
|
|
561 |
break;
|
|
562 |
}
|
|
563 |
|
|
564 |
case GRP_WIDGET_RENAME_GROUP: { // Rename the selected roup
|
|
565 |
assert(!IsDefaultGroupID(gv->group_sel));
|
|
566 |
|
|
567 |
const Group *g = GetGroup(gv->group_sel);
|
|
568 |
|
|
569 |
SetDParam(0, g->index);
|
|
570 |
ShowQueryString(g->string_id, STR_GROUP_RENAME_CAPTION, 31, 150, w, CS_ALPHANUMERAL);
|
|
571 |
} break;
|
|
572 |
|
|
573 |
|
|
574 |
case GRP_WIDGET_AVAILABLE_VEHICLES:
|
|
575 |
ShowBuildVehicleWindow(0, gv->vehicle_type);
|
|
576 |
break;
|
|
577 |
|
|
578 |
case GRP_WIDGET_MANAGE_VEHICLES:
|
|
579 |
case GRP_WIDGET_MANAGE_VEHICLES_DROPDOWN: {
|
|
580 |
UpdateGroupActionDropdown(w, gv->group_sel, false);
|
|
581 |
break;
|
|
582 |
}
|
|
583 |
|
|
584 |
|
|
585 |
case GRP_WIDGET_START_ALL:
|
|
586 |
case GRP_WIDGET_STOP_ALL: { // Start/stop all vehicles of the list
|
|
587 |
DoCommandP(0, gv->group_sel, ((IsDefaultGroupID(gv->group_sel) ? VLW_STANDARD : VLW_GROUP_LIST) & VLW_MASK)
|
|
588 |
| (1 << 6)
|
|
589 |
| (e->we.click.widget == GRP_WIDGET_START_ALL ? (1 << 5) : 0)
|
|
590 |
| gv->vehicle_type, NULL, CMD_MASS_START_STOP);
|
|
591 |
|
|
592 |
break;
|
|
593 |
}
|
|
594 |
|
|
595 |
case GRP_WIDGET_REPLACE_PROTECTION:
|
|
596 |
if (!IsDefaultGroupID(gv->group_sel)) {
|
|
597 |
const Group *g = GetGroup(gv->group_sel);
|
|
598 |
|
|
599 |
DoCommandP(0, gv->group_sel, !g->replace_protection, NULL, CMD_SET_GROUP_REPLACE_PROTECTION);
|
|
600 |
}
|
|
601 |
break;
|
|
602 |
}
|
|
603 |
|
|
604 |
break;
|
|
605 |
|
|
606 |
case WE_DRAGDROP: {
|
|
607 |
switch (e->we.click.widget) {
|
|
608 |
case GRP_WIDGET_ALL_VEHICLES: // All trains
|
|
609 |
DoCommandP(0, DEFAULT_GROUP, gv->vehicle_sel, NULL, CMD_ADD_VEHICLE_GROUP | CMD_MSG(STR_GROUP_CAN_T_ADD_VEHICLE));
|
|
610 |
|
|
611 |
gv->vehicle_sel = INVALID_VEHICLE;
|
|
612 |
|
|
613 |
SetWindowDirty(w);
|
|
614 |
|
|
615 |
break;
|
|
616 |
|
|
617 |
case GRP_WIDGET_LIST_GROUP: { // Maxtrix group
|
|
618 |
uint16 id_g = (e->we.click.pt.y - PLY_WND_PRC__OFFSET_TOP_WIDGET - 13) / PLY_WND_PRC__SIZE_OF_ROW_TINY;
|
|
619 |
const VehicleID vindex = gv->vehicle_sel;
|
|
620 |
|
|
621 |
gv->vehicle_sel = INVALID_VEHICLE;
|
|
622 |
|
|
623 |
SetWindowDirty(w);
|
|
624 |
|
|
625 |
if (id_g >= w->vscroll.cap) return;
|
|
626 |
|
|
627 |
id_g += w->vscroll.pos;
|
|
628 |
|
|
629 |
if (id_g >= gl->l.list_length) return;
|
|
630 |
|
|
631 |
DoCommandP(0, gl->sort_list[id_g]->index, vindex, NULL, CMD_ADD_VEHICLE_GROUP | CMD_MSG(STR_GROUP_CAN_T_ADD_VEHICLE));
|
|
632 |
|
|
633 |
break;
|
|
634 |
}
|
|
635 |
|
|
636 |
case GRP_WIDGET_LIST_VEHICLE: { // Maxtrix vehicle
|
|
637 |
uint32 id_v = (e->we.click.pt.y - PLY_WND_PRC__OFFSET_TOP_WIDGET) / (int)w->resize.step_height;
|
|
638 |
const Vehicle *v;
|
|
639 |
const VehicleID vindex = gv->vehicle_sel;
|
|
640 |
|
|
641 |
gv->vehicle_sel = INVALID_VEHICLE;
|
|
642 |
|
|
643 |
SetWindowDirty(w);
|
|
644 |
|
|
645 |
if (id_v >= w->vscroll2.cap) return; // click out of bounds
|
|
646 |
|
|
647 |
id_v += w->vscroll2.pos;
|
|
648 |
|
|
649 |
if (id_v >= gv->l.list_length) return; // click out of list bound
|
|
650 |
|
|
651 |
v = gv->sort_list[id_v];
|
|
652 |
|
|
653 |
if (vindex == v->index) {
|
|
654 |
switch (gv->vehicle_type) {
|
|
655 |
default: NOT_REACHED(); break;
|
|
656 |
case VEH_TRAIN: ShowTrainViewWindow(v); break;
|
|
657 |
case VEH_ROAD: ShowRoadVehViewWindow(v); break;
|
|
658 |
case VEH_SHIP: ShowShipViewWindow(v); break;
|
|
659 |
case VEH_AIRCRAFT: ShowAircraftViewWindow(v); break;
|
|
660 |
}
|
|
661 |
}
|
|
662 |
|
|
663 |
break;
|
|
664 |
}
|
|
665 |
}
|
|
666 |
break;
|
|
667 |
}
|
|
668 |
|
|
669 |
case WE_ON_EDIT_TEXT:
|
|
670 |
if (!StrEmpty(e->we.edittext.str)) {
|
|
671 |
_cmd_text = e->we.edittext.str;
|
|
672 |
|
|
673 |
DoCommandP(0, gv->group_sel, 0, NULL, CMD_RENAME_GROUP | CMD_MSG(STR_GROUP_CAN_T_RENAME));
|
|
674 |
}
|
|
675 |
break;
|
|
676 |
|
|
677 |
case WE_RESIZE:
|
|
678 |
w->hscroll.cap += e->we.sizing.diff.x;
|
|
679 |
w->vscroll.cap += e->we.sizing.diff.y / PLY_WND_PRC__SIZE_OF_ROW_TINY;
|
|
680 |
w->vscroll2.cap += e->we.sizing.diff.y / (int)w->resize.step_height;
|
|
681 |
|
|
682 |
w->widget[GRP_WIDGET_LIST_GROUP].data = (w->vscroll.cap << 8) + 1;
|
|
683 |
w->widget[GRP_WIDGET_LIST_VEHICLE].data = (w->vscroll2.cap << 8) + 1;
|
|
684 |
break;
|
|
685 |
|
|
686 |
|
|
687 |
case WE_DROPDOWN_SELECT: // we have selected a dropdown item in the list
|
|
688 |
switch (e->we.dropdown.button) {
|
|
689 |
case GRP_WIDGET_SORT_BY_DROPDOWN:
|
|
690 |
if (gv->l.sort_type != e->we.dropdown.index) {
|
|
691 |
gv->l.flags |= VL_RESORT;
|
|
692 |
gv->l.sort_type = e->we.dropdown.index;
|
|
693 |
gv->_sorting->criteria = gv->l.sort_type;
|
|
694 |
}
|
|
695 |
break;
|
|
696 |
|
|
697 |
case GRP_WIDGET_MANAGE_VEHICLES_DROPDOWN:
|
|
698 |
assert(gv->l.list_length != 0);
|
|
699 |
|
|
700 |
switch (e->we.dropdown.index) {
|
|
701 |
case 0: // Replace window
|
|
702 |
ShowReplaceGroupVehicleWindow(gv->group_sel, gv->vehicle_type);
|
|
703 |
break;
|
|
704 |
case 1: // Send for servicing
|
|
705 |
DoCommandP(0, gv->group_sel, ((IsDefaultGroupID(gv->group_sel) ? VLW_STANDARD : VLW_GROUP_LIST) & VLW_MASK)
|
|
706 |
| DEPOT_MASS_SEND
|
|
707 |
| DEPOT_SERVICE, NULL, GetCmdSendToDepot(gv->vehicle_type));
|
|
708 |
break;
|
|
709 |
case 2: // Send to Depots
|
|
710 |
DoCommandP(0, gv->group_sel, ((IsDefaultGroupID(gv->group_sel) ? VLW_STANDARD : VLW_GROUP_LIST) & VLW_MASK)
|
|
711 |
| DEPOT_MASS_SEND, NULL, GetCmdSendToDepot(gv->vehicle_type));
|
|
712 |
break;
|
|
713 |
case 3: // Add shared Vehicles
|
|
714 |
assert(!IsDefaultGroupID(gv->group_sel));
|
|
715 |
|
|
716 |
DoCommandP(0, gv->group_sel, gv->vehicle_type, NULL, CMD_ADD_SHARED_VEHICLE_GROUP | CMD_MSG(STR_GROUP_CAN_T_ADD_SHARED_VEHICLE));
|
|
717 |
break;
|
|
718 |
case 4: // Remove all Vehicles from the selected group
|
|
719 |
assert(!IsDefaultGroupID(gv->group_sel));
|
|
720 |
|
|
721 |
DoCommandP(0, gv->group_sel, gv->vehicle_type, NULL, CMD_REMOVE_ALL_VEHICLES_GROUP | CMD_MSG(STR_GROUP_CAN_T_REMOVE_ALL_VEHICLES));
|
|
722 |
break;
|
|
723 |
default: NOT_REACHED();
|
|
724 |
}
|
|
725 |
break;
|
|
726 |
|
|
727 |
default: NOT_REACHED();
|
|
728 |
}
|
|
729 |
|
|
730 |
SetWindowDirty(w);
|
|
731 |
break;
|
|
732 |
|
|
733 |
|
|
734 |
case WE_DESTROY:
|
|
735 |
free((void*)gv->sort_list);
|
|
736 |
free((void*)gl->sort_list);
|
|
737 |
break;
|
|
738 |
|
|
739 |
|
|
740 |
case WE_TICK: // resort the lists every 20 seconds orso (10 days)
|
|
741 |
if (--gv->l.resort_timer == 0) {
|
|
742 |
gv->l.resort_timer = DAY_TICKS * PERIODIC_RESORT_DAYS;
|
|
743 |
gv->l.flags |= VL_RESORT;
|
|
744 |
SetWindowDirty(w);
|
|
745 |
}
|
|
746 |
if (--gl->l.resort_timer == 0) {
|
|
747 |
gl->l.resort_timer = DAY_TICKS * PERIODIC_RESORT_DAYS;
|
|
748 |
gl->l.flags |= VL_RESORT;
|
|
749 |
SetWindowDirty(w);
|
|
750 |
}
|
|
751 |
break;
|
|
752 |
}
|
|
753 |
}
|
|
754 |
|
|
755 |
|
|
756 |
static const WindowDesc _group_desc = {
|
|
757 |
WDP_AUTO, WDP_AUTO, 526, 246,
|
|
758 |
WC_TRAINS_LIST, WC_NONE,
|
|
759 |
WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS | WDF_STICKY_BUTTON | WDF_RESIZABLE,
|
|
760 |
_group_widgets,
|
|
761 |
GroupWndProc
|
|
762 |
};
|
|
763 |
|
|
764 |
void ShowPlayerGroup(PlayerID player, VehicleType vehicle_type)
|
|
765 |
{
|
|
766 |
WindowClass wc;
|
|
767 |
|
|
768 |
switch (vehicle_type) {
|
|
769 |
default: NOT_REACHED();
|
|
770 |
case VEH_TRAIN: wc = WC_TRAINS_LIST; break;
|
|
771 |
case VEH_ROAD: wc = WC_ROADVEH_LIST; break;
|
|
772 |
case VEH_SHIP: wc = WC_SHIPS_LIST; break;
|
|
773 |
case VEH_AIRCRAFT: wc = WC_AIRCRAFT_LIST; break;
|
|
774 |
}
|
|
775 |
|
|
776 |
WindowNumber num = (vehicle_type << 11) | VLW_GROUP_LIST | player;
|
|
777 |
DeleteWindowById(wc, num);
|
|
778 |
Window *w = AllocateWindowDescFront(&_group_desc, num);
|
|
779 |
if (w == NULL) return;
|
|
780 |
|
|
781 |
w->window_class = wc;
|
|
782 |
|
|
783 |
switch (vehicle_type) {
|
|
784 |
default: NOT_REACHED();
|
|
785 |
case VEH_ROAD:
|
|
786 |
ResizeWindow(w, -66, 0);
|
|
787 |
/* FALL THROUGH */
|
|
788 |
case VEH_TRAIN:
|
|
789 |
w->resize.height = w->height - (PLY_WND_PRC__SIZE_OF_ROW_SMALL * 4); // Minimum of 4 vehicles
|
|
790 |
break;
|
|
791 |
|
|
792 |
case VEH_SHIP:
|
|
793 |
case VEH_AIRCRAFT:
|
|
794 |
ResizeWindow(w, -66, -52);
|
|
795 |
w->resize.height = w->height; // Minimum of 4 vehicles
|
|
796 |
break;
|
|
797 |
}
|
|
798 |
|
|
799 |
/* Set the minimum window size to the current window size */
|
|
800 |
w->resize.width = w->width;
|
|
801 |
}
|