|
1 /* $Id$ */ |
|
2 |
|
3 /** @file window_gui.h Functions, definitions and such used only by the GUI. */ |
|
4 |
|
5 #ifndef WINDOW_GUI_H |
|
6 #define WINDOW_GUI_H |
|
7 |
|
8 #include "macros.h" |
|
9 #include "string.h" |
|
10 #include "order.h" |
|
11 #include "rail_type.h" |
|
12 #include "road_type.h" |
|
13 #include "airport.h" |
|
14 #include "vehicle.h" |
|
15 #include "viewport.h" |
|
16 |
|
17 /** |
|
18 * The maximum number of windows that can be opened. |
|
19 */ |
|
20 static const int MAX_NUMBER_OF_WINDOWS = 25; |
|
21 |
|
22 struct WindowEvent; |
|
23 |
|
24 typedef void WindowProc(Window *w, WindowEvent *e); |
|
25 |
|
26 /* How the resize system works: |
|
27 First, you need to add a WWT_RESIZEBOX to the widgets, and you need |
|
28 to add the flag WDF_RESIZABLE to the window. Now the window is ready |
|
29 to resize itself. |
|
30 As you may have noticed, all widgets have a RESIZE_XXX in their line. |
|
31 This lines controls how the widgets behave on resize. RESIZE_NONE means |
|
32 it doesn't do anything. Any other option let's one of the borders |
|
33 move with the changed width/height. So if a widget has |
|
34 RESIZE_RIGHT, and the window is made 5 pixels wider by the user, |
|
35 the right of the window will also be made 5 pixels wider. |
|
36 Now, what if you want to clamp a widget to the bottom? Give it the flag |
|
37 RESIZE_TB. This is RESIZE_TOP + RESIZE_BOTTOM. Now if the window gets |
|
38 5 pixels bigger, both the top and bottom gets 5 bigger, so the whole |
|
39 widgets moves downwards without resizing, and appears to be clamped |
|
40 to the bottom. Nice aint it? |
|
41 You should know one more thing about this system. Most windows can't |
|
42 handle an increase of 1 pixel. So there is a step function, which |
|
43 let the windowsize only be changed by X pixels. You configure this |
|
44 after making the window, like this: |
|
45 w->resize.step_height = 10; |
|
46 Now the window will only change in height in steps of 10. |
|
47 You can also give a minimum width and height. The default value is |
|
48 the default height/width of the window itself. You can change this |
|
49 AFTER window-creation, with: |
|
50 w->resize.width or w->resize.height. |
|
51 That was all.. good luck, and enjoy :) -- TrueLight */ |
|
52 |
|
53 enum ResizeFlag { |
|
54 RESIZE_NONE = 0, ///< no resize required |
|
55 |
|
56 RESIZE_LEFT = 1, ///< left resize flag |
|
57 RESIZE_RIGHT = 2, ///< rigth resize flag |
|
58 RESIZE_TOP = 4, ///< top resize flag |
|
59 RESIZE_BOTTOM = 8, ///< bottom resize flag |
|
60 |
|
61 RESIZE_LR = RESIZE_LEFT | RESIZE_RIGHT, ///< combination of left and right resize flags |
|
62 RESIZE_RB = RESIZE_RIGHT | RESIZE_BOTTOM, ///< combination of right and bottom resize flags |
|
63 RESIZE_TB = RESIZE_TOP | RESIZE_BOTTOM, ///< combination of top and bottom resize flags |
|
64 RESIZE_LRB = RESIZE_LEFT | RESIZE_RIGHT | RESIZE_BOTTOM, ///< combination of left, right and bottom resize flags |
|
65 RESIZE_LRTB = RESIZE_LEFT | RESIZE_RIGHT | RESIZE_TOP | RESIZE_BOTTOM, ///< combination of all resize flags |
|
66 RESIZE_RTB = RESIZE_RIGHT | RESIZE_TOP | RESIZE_BOTTOM, ///< combination of right, top and bottom resize flag |
|
67 |
|
68 /* The following flags are used by the system to specify what is disabled, hidden, or clicked |
|
69 * They are used in the same place as the above RESIZE_x flags, Widget visual_flags. |
|
70 * These states are used in exceptions. If nothing is specified, they will indicate |
|
71 * Enabled, visible or unclicked widgets*/ |
|
72 WIDG_DISABLED = 4, ///< widget is greyed out, not available |
|
73 WIDG_HIDDEN = 5, ///< widget is made invisible |
|
74 WIDG_LOWERED = 6, ///< widget is paint lowered, a pressed button in fact |
|
75 }; |
|
76 |
|
77 enum { |
|
78 WIDGET_LIST_END = -1, ///< indicate the end of widgets' list for vararg functions |
|
79 }; |
|
80 |
|
81 struct Widget { |
|
82 byte type; ///< Widget type, see WindowWidgetTypes |
|
83 byte display_flags; ///< Resize direction, alignment, etc. during resizing, see ResizeFlags |
|
84 byte color; ///< Widget colour, see docs/ottd-colourtext-palette.png |
|
85 int16 left, right, top, bottom; ///< The position offsets inside the window |
|
86 uint16 data; ///< The String/Image or special code (list-matrixes) of a widget |
|
87 StringID tooltips; ///< Tooltips that are shown when rightclicking on a widget |
|
88 }; |
|
89 |
|
90 enum FrameFlags { |
|
91 FR_NONE = 0, |
|
92 FR_TRANSPARENT = 1 << 0, ///< Makes the background transparent if set |
|
93 FR_BORDERONLY = 1 << 4, ///< Draw border only, no background |
|
94 FR_LOWERED = 1 << 5, ///< If set the frame is lowered and the background color brighter (ie. buttons when pressed) |
|
95 FR_DARKENED = 1 << 6, ///< If set the background is darker, allows for lowered frames with normal background color when used with FR_LOWERED (ie. dropdown boxes) |
|
96 }; |
|
97 |
|
98 DECLARE_ENUM_AS_BIT_SET(FrameFlags); |
|
99 |
|
100 void DrawFrameRect(int left, int top, int right, int bottom, int color, FrameFlags flags); |
|
101 |
|
102 enum WindowEventCodes { |
|
103 WE_CREATE, |
|
104 WE_DESTROY, |
|
105 WE_PAINT, |
|
106 WE_KEYPRESS, |
|
107 WE_CLICK, |
|
108 WE_DOUBLE_CLICK, |
|
109 WE_RCLICK, |
|
110 WE_MOUSEOVER, |
|
111 WE_MOUSELOOP, |
|
112 WE_MOUSEWHEEL, |
|
113 WE_TICK, |
|
114 WE_4, |
|
115 WE_TIMEOUT, |
|
116 WE_PLACE_OBJ, |
|
117 WE_ABORT_PLACE_OBJ, |
|
118 WE_ON_EDIT_TEXT, |
|
119 WE_ON_EDIT_TEXT_CANCEL, |
|
120 WE_POPUPMENU_SELECT, |
|
121 WE_POPUPMENU_OVER, |
|
122 WE_DRAGDROP, |
|
123 WE_PLACE_DRAG, |
|
124 WE_PLACE_MOUSEUP, |
|
125 WE_PLACE_PRESIZE, |
|
126 WE_DROPDOWN_SELECT, |
|
127 WE_RESIZE, |
|
128 WE_MESSAGE, |
|
129 WE_SCROLL, |
|
130 WE_INVALIDATE_DATA, |
|
131 }; |
|
132 |
|
133 struct WindowEvent { |
|
134 byte event; |
|
135 union { |
|
136 struct { |
|
137 void *data; |
|
138 } create; |
|
139 |
|
140 struct { |
|
141 Point pt; |
|
142 int widget; |
|
143 } click; |
|
144 |
|
145 struct { |
|
146 Point pt; |
|
147 TileIndex tile; |
|
148 TileIndex starttile; |
|
149 ViewportPlaceMethod select_method; |
|
150 byte select_proc; |
|
151 } place; |
|
152 |
|
153 struct { |
|
154 Point pt; |
|
155 int widget; |
|
156 } dragdrop; |
|
157 |
|
158 struct { |
|
159 Point size; |
|
160 Point diff; |
|
161 } sizing; |
|
162 |
|
163 struct { |
|
164 char *str; |
|
165 } edittext; |
|
166 |
|
167 struct { |
|
168 Point pt; |
|
169 } popupmenu; |
|
170 |
|
171 struct { |
|
172 int button; |
|
173 int index; |
|
174 } dropdown; |
|
175 |
|
176 struct { |
|
177 Point pt; |
|
178 int widget; |
|
179 } mouseover; |
|
180 |
|
181 struct { |
|
182 bool cont; ///< continue the search? (default true) |
|
183 uint16 key; ///< 16-bit Unicode value of the key |
|
184 uint16 keycode; ///< untranslated key (including shift-state) |
|
185 } keypress; |
|
186 |
|
187 struct { |
|
188 int msg; ///< message to be sent |
|
189 int wparam; ///< additional message-specific information |
|
190 int lparam; ///< additional message-specific information |
|
191 } message; |
|
192 |
|
193 struct { |
|
194 Point delta; ///< delta position against position of last call |
|
195 } scroll; |
|
196 |
|
197 struct { |
|
198 int wheel; ///< how much was 'wheel'd' |
|
199 } wheel; |
|
200 } we; |
|
201 }; |
|
202 |
|
203 struct WindowDesc { |
|
204 int16 left, top, minimum_width, minimum_height, default_width, default_height; |
|
205 WindowClass cls; |
|
206 WindowClass parent_cls; |
|
207 uint32 flags; |
|
208 const Widget *widgets; |
|
209 WindowProc *proc; |
|
210 }; |
|
211 |
|
212 enum WindowDefaultFlag { |
|
213 WDF_STD_TOOLTIPS = 1 << 0, ///< use standard routine when displaying tooltips |
|
214 WDF_DEF_WIDGET = 1 << 1, ///< default widget control for some widgets in the on click event |
|
215 WDF_STD_BTN = 1 << 2, ///< default handling for close and drag widgets (widget no 0 and 1) |
|
216 |
|
217 WDF_UNCLICK_BUTTONS = 1 << 4, ///< Unclick buttons when the window event times out */ |
|
218 WDF_STICKY_BUTTON = 1 << 5, ///< Set window to sticky mode; they are not closed unless closed with 'X' (widget 2) |
|
219 WDF_RESIZABLE = 1 << 6, ///< A window can be resized |
|
220 WDF_MODAL = 1 << 7, ///< The window is a modal child of some other window, meaning the parent is 'inactive' |
|
221 }; |
|
222 |
|
223 /* can be used as x or y coordinates to cause a specific placement */ |
|
224 enum WindowDefaultPosition { |
|
225 WDP_AUTO = -1, ///< Find a place automatically |
|
226 WDP_CENTER = -2, ///< Center the window (left/right or top/bottom) |
|
227 WDP_ALIGN_TBR = -3, ///< Align the right side of the window with the right side of the main toolbar |
|
228 WDP_ALIGN_TBL = -4, ///< Align the left side of the window with the left side of the main toolbar |
|
229 }; |
|
230 |
|
231 struct Textbuf { |
|
232 char *buf; ///< buffer in which text is saved |
|
233 uint16 maxlength, maxwidth; ///< the maximum size of the buffer. Maxwidth specifies screensize in pixels, maxlength is in bytes |
|
234 uint16 length, width; ///< the current size of the string. Width specifies screensize in pixels, length is in bytes |
|
235 bool caret; ///< is the caret ("_") visible or not |
|
236 uint16 caretpos; ///< the current position of the caret in the buffer, in bytes |
|
237 uint16 caretxoffs; ///< the current position of the caret in pixels |
|
238 }; |
|
239 |
|
240 #define WP(ptr, str) (*(str*)(ptr)->custom) |
|
241 /* You cannot 100% reliably calculate the biggest custom struct as |
|
242 * the number of pointers in it and alignment will have a huge impact. |
|
243 * 96 is the largest window-size for 64-bit machines currently */ |
|
244 #define WINDOW_CUSTOM_SIZE 96 |
|
245 |
|
246 struct Scrollbar { |
|
247 uint16 count, cap, pos; |
|
248 }; |
|
249 |
|
250 struct ResizeInfo { |
|
251 uint width; ///< Minimum width and height |
|
252 uint height; |
|
253 uint step_width; ///< In how big steps the width and height go |
|
254 uint step_height; |
|
255 }; |
|
256 |
|
257 struct WindowMessage { |
|
258 int msg; |
|
259 int wparam; |
|
260 int lparam; |
|
261 }; |
|
262 |
|
263 struct Window { |
|
264 uint16 flags4; |
|
265 WindowClass window_class; |
|
266 WindowNumber window_number; |
|
267 |
|
268 int left, top; |
|
269 int width, height; |
|
270 |
|
271 Scrollbar hscroll, vscroll, vscroll2; |
|
272 ResizeInfo resize; |
|
273 |
|
274 byte caption_color; |
|
275 |
|
276 WindowProc *wndproc; |
|
277 ViewPort *viewport; |
|
278 const Widget *original_widget; |
|
279 Widget *widget; |
|
280 uint widget_count; |
|
281 uint32 desc_flags; |
|
282 |
|
283 WindowMessage message; |
|
284 Window *parent; |
|
285 byte custom[WINDOW_CUSTOM_SIZE]; |
|
286 |
|
287 void HandleButtonClick(byte widget); |
|
288 |
|
289 void SetWidgetDisabledState(byte widget_index, bool disab_stat); |
|
290 void DisableWidget(byte widget_index); |
|
291 void EnableWidget(byte widget_index); |
|
292 bool IsWidgetDisabled(byte widget_index) const; |
|
293 void SetWidgetHiddenState(byte widget_index, bool hidden_stat); |
|
294 void HideWidget(byte widget_index); |
|
295 void ShowWidget(byte widget_index); |
|
296 bool IsWidgetHidden(byte widget_index) const; |
|
297 void SetWidgetLoweredState(byte widget_index, bool lowered_stat); |
|
298 void ToggleWidgetLoweredState(byte widget_index); |
|
299 void LowerWidget(byte widget_index); |
|
300 void RaiseWidget(byte widget_index); |
|
301 bool IsWidgetLowered(byte widget_index) const; |
|
302 |
|
303 void RaiseButtons(); |
|
304 void CDECL SetWidgetsDisabledState(bool disab_stat, int widgets, ...); |
|
305 void CDECL SetWidgetsHiddenState(bool hidden_stat, int widgets, ...); |
|
306 void CDECL SetWidgetsLoweredState(bool lowered_stat, int widgets, ...); |
|
307 void InvalidateWidget(byte widget_index) const; |
|
308 }; |
|
309 |
|
310 struct querystr_d { |
|
311 StringID caption; |
|
312 Textbuf text; |
|
313 const char *orig; |
|
314 CharSetFilter afilter; |
|
315 bool handled; |
|
316 }; |
|
317 assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(querystr_d)); |
|
318 |
|
319 struct chatquerystr_d : public querystr_d { |
|
320 int dest; |
|
321 }; |
|
322 assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(chatquerystr_d)); |
|
323 |
|
324 struct menu_d { |
|
325 byte item_count; ///< follow_vehicle |
|
326 byte sel_index; ///< scrollpos_x |
|
327 byte main_button; ///< scrollpos_y |
|
328 byte action_id; |
|
329 StringID string_id; ///< unk30 |
|
330 uint16 checked_items; ///< unk32 |
|
331 byte disabled_items; |
|
332 }; |
|
333 assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(menu_d)); |
|
334 |
|
335 struct def_d { |
|
336 int16 data_1, data_2, data_3; |
|
337 int16 data_4, data_5; |
|
338 bool close; |
|
339 byte byte_1; |
|
340 }; |
|
341 assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(def_d)); |
|
342 |
|
343 struct void_d { |
|
344 void *data; |
|
345 }; |
|
346 assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(void_d)); |
|
347 |
|
348 struct tree_d { |
|
349 uint16 base; |
|
350 uint16 count; |
|
351 }; |
|
352 assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tree_d)); |
|
353 |
|
354 struct tooltips_d { |
|
355 StringID string_id; |
|
356 byte paramcount; |
|
357 uint64 params[5]; |
|
358 }; |
|
359 assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tooltips_d)); |
|
360 |
|
361 struct buildvehicle_d { |
|
362 VehicleType vehicle_type; |
|
363 union { |
|
364 RailTypeByte railtype; |
|
365 AirportFTAClass::Flags flags; |
|
366 RoadTypes roadtypes; |
|
367 } filter; |
|
368 byte sel_index; ///< deprecated value, used for 'unified' ship and road |
|
369 bool descending_sort_order; |
|
370 byte sort_criteria; |
|
371 bool regenerate_list; |
|
372 EngineID sel_engine; |
|
373 EngineID rename_engine; |
|
374 EngineList eng_list; |
|
375 }; |
|
376 assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(buildvehicle_d)); |
|
377 |
|
378 struct replaceveh_d { |
|
379 byte sel_index[2]; |
|
380 EngineID sel_engine[2]; |
|
381 uint16 count[2]; |
|
382 bool wagon_btnstate; ///< true means engine is selected |
|
383 EngineList list[2]; |
|
384 bool update_left; |
|
385 bool update_right; |
|
386 bool init_lists; |
|
387 GroupID sel_group; |
|
388 }; |
|
389 assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(replaceveh_d)); |
|
390 |
|
391 struct depot_d { |
|
392 VehicleID sel; |
|
393 VehicleType type; |
|
394 bool generate_list; |
|
395 uint16 engine_list_length; |
|
396 uint16 wagon_list_length; |
|
397 uint16 engine_count; |
|
398 uint16 wagon_count; |
|
399 Vehicle **vehicle_list; |
|
400 Vehicle **wagon_list; |
|
401 }; |
|
402 assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(depot_d)); |
|
403 |
|
404 struct order_d { |
|
405 int sel; |
|
406 }; |
|
407 assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(order_d)); |
|
408 |
|
409 struct vehicledetails_d { |
|
410 byte tab; |
|
411 }; |
|
412 assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vehicledetails_d)); |
|
413 |
|
414 struct smallmap_d { |
|
415 int32 scroll_x; |
|
416 int32 scroll_y; |
|
417 int32 subscroll; |
|
418 }; |
|
419 assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(smallmap_d)); |
|
420 |
|
421 /* player face selection window */ |
|
422 struct facesel_d { |
|
423 PlayerFace face; // player face bits |
|
424 bool advanced; // advance player face selection window |
|
425 }; |
|
426 assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(facesel_d)); |
|
427 |
|
428 struct refit_d { |
|
429 int sel; |
|
430 struct RefitOption *cargo; |
|
431 struct RefitList *list; |
|
432 uint length; |
|
433 VehicleOrderID order; |
|
434 }; |
|
435 assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(refit_d)); |
|
436 |
|
437 struct vp_d { |
|
438 VehicleID follow_vehicle; |
|
439 int32 scrollpos_x; |
|
440 int32 scrollpos_y; |
|
441 int32 dest_scrollpos_x; |
|
442 int32 dest_scrollpos_y; |
|
443 }; |
|
444 assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vp_d)); |
|
445 |
|
446 struct news_d { |
|
447 uint16 follow_vehicle; |
|
448 int32 scrollpos_x; |
|
449 int32 scrollpos_y; |
|
450 int32 dest_scrollpos_x; |
|
451 int32 dest_scrollpos_y; |
|
452 NewsItem *ni; |
|
453 }; |
|
454 assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(news_d)); |
|
455 |
|
456 struct highscore_d { |
|
457 uint32 background_img; |
|
458 int8 rank; |
|
459 }; |
|
460 assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(highscore_d)); |
|
461 |
|
462 struct scroller_d { |
|
463 int height; |
|
464 uint16 counter; |
|
465 }; |
|
466 assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(scroller_d)); |
|
467 |
|
468 enum SortListFlags { |
|
469 VL_NONE = 0, ///< no sort |
|
470 VL_DESC = 1 << 0, ///< sort descending or ascending |
|
471 VL_RESORT = 1 << 1, ///< instruct the code to resort the list in the next loop |
|
472 VL_REBUILD = 1 << 2, ///< create sort-listing to use for qsort and friends |
|
473 VL_END = 1 << 3, |
|
474 }; |
|
475 |
|
476 DECLARE_ENUM_AS_BIT_SET(SortListFlags); |
|
477 |
|
478 struct Listing { |
|
479 bool order; ///< Ascending/descending |
|
480 byte criteria; ///< Sorting criteria |
|
481 }; |
|
482 |
|
483 struct list_d { |
|
484 uint16 list_length; ///< length of the list being sorted |
|
485 byte sort_type; ///< what criteria to sort on |
|
486 SortListFlags flags; ///< used to control sorting/resorting/etc. |
|
487 uint16 resort_timer; ///< resort list after a given amount of ticks if set |
|
488 }; |
|
489 assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(list_d)); |
|
490 |
|
491 struct message_d { |
|
492 int msg; |
|
493 int wparam; |
|
494 int lparam; |
|
495 }; |
|
496 assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(message_d)); |
|
497 |
|
498 struct dropdown_d { |
|
499 uint32 disabled_state; |
|
500 uint32 hidden_state; |
|
501 WindowClass parent_wnd_class; |
|
502 WindowNumber parent_wnd_num; |
|
503 byte parent_button; |
|
504 byte num_items; |
|
505 byte selected_index; |
|
506 const StringID *items; |
|
507 byte click_delay; |
|
508 bool drag_mode; |
|
509 }; |
|
510 assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(dropdown_d)); |
|
511 |
|
512 struct vehiclelist_d { |
|
513 const Vehicle** sort_list; // List of vehicles (sorted) |
|
514 Listing *_sorting; // pointer to the appropiate subcategory of _sorting |
|
515 uint16 length_of_sort_list; // Keeps track of how many vehicle pointers sort list got space for |
|
516 VehicleType vehicle_type; // The vehicle type that is sorted |
|
517 list_d l; // General list struct |
|
518 }; |
|
519 assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vehiclelist_d)); |
|
520 |
|
521 struct grouplist_d { |
|
522 const Group **sort_list; |
|
523 list_d l; // General list struct |
|
524 }; |
|
525 assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(grouplist_d)); |
|
526 |
|
527 struct groupveh_d : vehiclelist_d { |
|
528 GroupID group_sel; |
|
529 VehicleID vehicle_sel; |
|
530 |
|
531 grouplist_d gl; |
|
532 }; |
|
533 assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(groupveh_d)); |
|
534 |
|
535 /****************** THESE ARE NOT WIDGET TYPES!!!!! *******************/ |
|
536 enum WindowWidgetBehaviours { |
|
537 WWB_PUSHBUTTON = 1 << 5, |
|
538 |
|
539 WWB_MASK = 0xE0, |
|
540 }; |
|
541 |
|
542 |
|
543 enum WindowWidgetTypes { |
|
544 WWT_EMPTY, |
|
545 |
|
546 WWT_PANEL, ///< simple depressed panel |
|
547 WWT_INSET, ///< pressed (inset) panel, most commonly used as combo box _text_ area |
|
548 WWT_IMGBTN, ///< button with image |
|
549 WWT_IMGBTN_2, ///< button with diff image when clicked |
|
550 |
|
551 WWT_TEXTBTN, ///< button with text |
|
552 WWT_TEXTBTN_2, ///< button with diff text when clicked |
|
553 WWT_LABEL, ///< centered label |
|
554 WWT_TEXT, ///< pure simple text |
|
555 WWT_MATRIX, |
|
556 WWT_SCROLLBAR, |
|
557 WWT_FRAME, ///< frame |
|
558 WWT_CAPTION, |
|
559 |
|
560 WWT_HSCROLLBAR, |
|
561 WWT_STICKYBOX, |
|
562 WWT_SCROLL2BAR, ///< 2nd vertical scrollbar |
|
563 WWT_RESIZEBOX, |
|
564 WWT_CLOSEBOX, |
|
565 WWT_LAST, ///< Last Item. use WIDGETS_END to fill up padding!! |
|
566 |
|
567 WWT_MASK = 0x1F, |
|
568 |
|
569 WWT_PUSHBTN = WWT_PANEL | WWB_PUSHBUTTON, |
|
570 WWT_PUSHTXTBTN = WWT_TEXTBTN | WWB_PUSHBUTTON, |
|
571 WWT_PUSHIMGBTN = WWT_IMGBTN | WWB_PUSHBUTTON, |
|
572 }; |
|
573 |
|
574 #define WIDGETS_END WWT_LAST, RESIZE_NONE, 0, 0, 0, 0, 0, 0, STR_NULL |
|
575 |
|
576 enum WindowFlags { |
|
577 WF_TIMEOUT_SHL = 0, |
|
578 WF_TIMEOUT_MASK = 7, |
|
579 WF_DRAGGING = 1 << 3, |
|
580 WF_SCROLL_UP = 1 << 4, |
|
581 WF_SCROLL_DOWN = 1 << 5, |
|
582 WF_SCROLL_MIDDLE = 1 << 6, |
|
583 WF_HSCROLL = 1 << 7, |
|
584 WF_SIZING = 1 << 8, |
|
585 WF_STICKY = 1 << 9, |
|
586 |
|
587 WF_DISABLE_VP_SCROLL = 1 << 10, |
|
588 |
|
589 WF_WHITE_BORDER_ONE = 1 << 11, |
|
590 WF_WHITE_BORDER_MASK = 1 << 12 | WF_WHITE_BORDER_ONE, |
|
591 WF_SCROLL2 = 1 << 13, |
|
592 }; |
|
593 |
|
594 /* window.cpp */ |
|
595 void CallWindowEventNP(Window *w, int event); |
|
596 void CallWindowTickEvent(); |
|
597 |
|
598 /** |
|
599 * Marks the window as dirty for repaint. |
|
600 * |
|
601 * @ingroup dirty |
|
602 */ |
|
603 void SetWindowDirty(const Window *w); |
|
604 void SendWindowMessage(WindowClass wnd_class, WindowNumber wnd_num, int msg, int wparam, int lparam); |
|
605 void SendWindowMessageClass(WindowClass wnd_class, int msg, int wparam, int lparam); |
|
606 |
|
607 Window *FindWindowById(WindowClass cls, WindowNumber number); |
|
608 void DeleteWindow(Window *w); |
|
609 void DeletePlayerWindows(PlayerID pi); |
|
610 void ChangeWindowOwner(PlayerID old_player, PlayerID new_player); |
|
611 Window *BringWindowToFrontById(WindowClass cls, WindowNumber number); |
|
612 Window *FindWindowFromPt(int x, int y); |
|
613 |
|
614 bool IsWindowOfPrototype(const Window *w, const Widget *widget); |
|
615 void AssignWidgetToWindow(Window *w, const Widget *widget); |
|
616 Window *AllocateWindow( |
|
617 int x, |
|
618 int y, |
|
619 int width, |
|
620 int height, |
|
621 WindowProc *proc, |
|
622 WindowClass cls, |
|
623 const Widget *widget, |
|
624 void *data = NULL); |
|
625 |
|
626 Window *AllocateWindowDesc(const WindowDesc *desc, void *data = NULL); |
|
627 Window *AllocateWindowDescFront(const WindowDesc *desc, int window_number, void *data = NULL); |
|
628 |
|
629 void DrawWindowViewport(const Window *w); |
|
630 void ResizeWindow(Window *w, int x, int y); |
|
631 |
|
632 void InitWindowSystem(); |
|
633 void UnInitWindowSystem(); |
|
634 void ResetWindowSystem(); |
|
635 int GetMenuItemIndex(const Window *w, int x, int y); |
|
636 void InputLoop(); |
|
637 void InvalidateThisWindowData(Window *w); |
|
638 void InvalidateWindowData(WindowClass cls, WindowNumber number); |
|
639 void RelocateAllWindows(int neww, int newh); |
|
640 int PositionMainToolbar(Window *w); |
|
641 |
|
642 /* misc_gui.cpp */ |
|
643 void GuiShowTooltipsWithArgs(StringID str, uint paramcount, const uint64 params[]); |
|
644 static inline void GuiShowTooltips(StringID str) |
|
645 { |
|
646 GuiShowTooltipsWithArgs(str, 0, NULL); |
|
647 } |
|
648 |
|
649 /* widget.cpp */ |
|
650 int GetWidgetFromPos(const Window *w, int x, int y); |
|
651 void DrawWindowWidgets(const Window *w); |
|
652 void ShowDropDownMenu(Window *w, const StringID *strings, int selected, int button, uint32 disabled_mask, uint32 hidden_mask); |
|
653 |
|
654 |
|
655 Window *GetCallbackWnd(); |
|
656 void DeleteNonVitalWindows(); |
|
657 void DeleteAllNonVitalWindows(); |
|
658 void HideVitalWindows(); |
|
659 void ShowVitalWindows(); |
|
660 Window **FindWindowZPosition(const Window *w); |
|
661 |
|
662 /* window.cpp */ |
|
663 extern Window *_z_windows[]; |
|
664 extern Window **_last_z_window; |
|
665 #define FOR_ALL_WINDOWS(wz) for (wz = _z_windows; wz != _last_z_window; wz++) |
|
666 |
|
667 VARDEF Point _cursorpos_drag_start; |
|
668 |
|
669 VARDEF int _scrollbar_start_pos; |
|
670 VARDEF int _scrollbar_size; |
|
671 VARDEF byte _scroller_click_timeout; |
|
672 |
|
673 VARDEF bool _scrolling_scrollbar; |
|
674 VARDEF bool _scrolling_viewport; |
|
675 VARDEF bool _popup_menu_active; |
|
676 |
|
677 VARDEF byte _special_mouse_mode; |
|
678 enum SpecialMouseMode { |
|
679 WSM_NONE = 0, |
|
680 WSM_DRAGDROP = 1, |
|
681 WSM_SIZING = 2, |
|
682 WSM_PRESIZE = 3, |
|
683 }; |
|
684 |
|
685 void ScrollbarClickHandler(Window *w, const Widget *wi, int x, int y); |
|
686 |
|
687 /** Evenly distribute some widgets when resizing horizontally (often a button row) |
|
688 * The widgets are presumed to be in a line and numberef from left to right (without gaps) |
|
689 * @param w widow to modify |
|
690 * @param left The leftmost widget to resize |
|
691 * @param right The rightmost widget to resize. Since right side of it is used, remember to set it to RESIZE_RIGHT |
|
692 */ |
|
693 void ResizeButtons(Window *w, byte left, byte right); |
|
694 |
|
695 |
|
696 /** |
|
697 * Sets the enabled/disabled status of a widget. |
|
698 * By default, widgets are enabled. |
|
699 * On certain conditions, they have to be disabled. |
|
700 * @param widget_index : index of this widget in the window |
|
701 * @param disab_stat : status to use ie: disabled = true, enabled = false |
|
702 */ |
|
703 inline void Window::SetWidgetDisabledState(byte widget_index, bool disab_stat) |
|
704 { |
|
705 assert(widget_index < this->widget_count); |
|
706 SB(this->widget[widget_index].display_flags, WIDG_DISABLED, 1, !!disab_stat); |
|
707 } |
|
708 |
|
709 /** |
|
710 * Sets a widget to disabled. |
|
711 * @param widget_index : index of this widget in the window |
|
712 */ |
|
713 inline void Window::DisableWidget(byte widget_index) |
|
714 { |
|
715 SetWidgetDisabledState(widget_index, true); |
|
716 } |
|
717 |
|
718 /** |
|
719 * Sets a widget to Enabled. |
|
720 * @param widget_index : index of this widget in the window |
|
721 */ |
|
722 inline void Window::EnableWidget(byte widget_index) |
|
723 { |
|
724 SetWidgetDisabledState(widget_index, false); |
|
725 } |
|
726 |
|
727 /** |
|
728 * Gets the enabled/disabled status of a widget. |
|
729 * @param widget_index : index of this widget in the window |
|
730 * @return status of the widget ie: disabled = true, enabled = false |
|
731 */ |
|
732 inline bool Window::IsWidgetDisabled(byte widget_index) const |
|
733 { |
|
734 assert(widget_index < this->widget_count); |
|
735 return HasBit(this->widget[widget_index].display_flags, WIDG_DISABLED); |
|
736 } |
|
737 |
|
738 /** |
|
739 * Sets the hidden/shown status of a widget. |
|
740 * By default, widgets are visible. |
|
741 * On certain conditions, they have to be hidden. |
|
742 * @param widget_index index of this widget in the window |
|
743 * @param hidden_stat status to use ie. hidden = true, visible = false |
|
744 */ |
|
745 inline void Window::SetWidgetHiddenState(byte widget_index, bool hidden_stat) |
|
746 { |
|
747 assert(widget_index < this->widget_count); |
|
748 SB(this->widget[widget_index].display_flags, WIDG_HIDDEN, 1, !!hidden_stat); |
|
749 } |
|
750 |
|
751 /** |
|
752 * Sets a widget hidden. |
|
753 * @param widget_index : index of this widget in the window |
|
754 */ |
|
755 inline void Window::HideWidget(byte widget_index) |
|
756 { |
|
757 SetWidgetHiddenState(widget_index, true); |
|
758 } |
|
759 |
|
760 /** |
|
761 * Sets a widget visible. |
|
762 * @param widget_index : index of this widget in the window |
|
763 */ |
|
764 inline void Window::ShowWidget(byte widget_index) |
|
765 { |
|
766 SetWidgetHiddenState(widget_index, false); |
|
767 } |
|
768 |
|
769 /** |
|
770 * Gets the visibility of a widget. |
|
771 * @param widget_index : index of this widget in the window |
|
772 * @return status of the widget ie: hidden = true, visible = false |
|
773 */ |
|
774 inline bool Window::IsWidgetHidden(byte widget_index) const |
|
775 { |
|
776 assert(widget_index < this->widget_count); |
|
777 return HasBit(this->widget[widget_index].display_flags, WIDG_HIDDEN); |
|
778 } |
|
779 |
|
780 /** |
|
781 * Sets the lowered/raised status of a widget. |
|
782 * @param widget_index : index of this widget in the window |
|
783 * @param lowered_stat : status to use ie: lowered = true, raised = false |
|
784 */ |
|
785 inline void Window::SetWidgetLoweredState(byte widget_index, bool lowered_stat) |
|
786 { |
|
787 assert(widget_index < this->widget_count); |
|
788 SB(this->widget[widget_index].display_flags, WIDG_LOWERED, 1, !!lowered_stat); |
|
789 } |
|
790 |
|
791 /** |
|
792 * Invert the lowered/raised status of a widget. |
|
793 * @param widget_index : index of this widget in the window |
|
794 */ |
|
795 inline void Window::ToggleWidgetLoweredState(byte widget_index) |
|
796 { |
|
797 assert(widget_index < this->widget_count); |
|
798 ToggleBit(this->widget[widget_index].display_flags, WIDG_LOWERED); |
|
799 } |
|
800 |
|
801 /** |
|
802 * Marks a widget as lowered. |
|
803 * @param widget_index : index of this widget in the window |
|
804 */ |
|
805 inline void Window::LowerWidget(byte widget_index) |
|
806 { |
|
807 SetWidgetLoweredState(widget_index, true); |
|
808 } |
|
809 |
|
810 /** |
|
811 * Marks a widget as raised. |
|
812 * @param widget_index : index of this widget in the window |
|
813 */ |
|
814 inline void Window::RaiseWidget(byte widget_index) |
|
815 { |
|
816 SetWidgetLoweredState(widget_index, false); |
|
817 } |
|
818 |
|
819 /** |
|
820 * Gets the lowered state of a widget. |
|
821 * @param widget_index : index of this widget in the window |
|
822 * @return status of the widget ie: lowered = true, raised= false |
|
823 */ |
|
824 inline bool Window::IsWidgetLowered(byte widget_index) const |
|
825 { |
|
826 assert(widget_index < this->widget_count); |
|
827 return HasBit(this->widget[widget_index].display_flags, WIDG_LOWERED); |
|
828 } |
|
829 |
|
830 #endif /* WINDOW_GUI_H */ |