|
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 } |