diff options
author | rubidium <rubidium@openttd.org> | 2007-01-02 19:19:48 +0000 |
---|---|---|
committer | rubidium <rubidium@openttd.org> | 2007-01-02 19:19:48 +0000 |
commit | 66bbf336c6af7353ef0aeed58002c46543b30635 (patch) | |
tree | ad4a63860df2626b22f77e7dac712e958bea54cb /src/window.h | |
parent | ccc0a3f4dbf58c005b22341ac8874252924690cd (diff) | |
download | openttd-66bbf336c6af7353ef0aeed58002c46543b30635.tar.xz |
(svn r7759) -Merge: makefile rewrite. This merge features:
- A proper ./configure, so everything needs to be configured only once, not for every make.
- Usage of makedepend when available. This greatly reduces the time needed for generating the dependencies.
- A generator for all project files. There is a single file with sources, which is used to generate Makefiles and the project files for MSVC.
- Proper support for OSX universal binaries.
- Object files for non-MSVC compiles are also placed in separate directories, making is faster to switch between debug and release compiles and it does not touch the directory with the source files.
- Functionality to make a bundle of all needed files for for example a nightly or distribution of a binary with all needed GRFs and language files.
Note: as this merge moves almost all files, it is recommended to make a backup of your working copy before updating your working copy.
Diffstat (limited to 'src/window.h')
-rw-r--r-- | src/window.h | 843 |
1 files changed, 843 insertions, 0 deletions
diff --git a/src/window.h b/src/window.h new file mode 100644 index 000000000..2e6fd8b94 --- /dev/null +++ b/src/window.h @@ -0,0 +1,843 @@ +/* $Id$ */ + +#ifndef WINDOW_H +#define WINDOW_H + +#include "macros.h" +#include "string.h" +#include "order.h" + +typedef struct WindowEvent WindowEvent; + +typedef void WindowProc(Window *w, WindowEvent *e); + +/* How the resize system works: + First, you need to add a WWT_RESIZEBOX to the widgets, and you need + to add the flag WDF_RESIZABLE to the window. Now the window is ready + to resize itself. + As you may have noticed, all widgets have a RESIZE_XXX in their line. + This lines controls how the widgets behave on resize. RESIZE_NONE means + it doesn't do anything. Any other option let's one of the borders + move with the changed width/height. So if a widget has + RESIZE_RIGHT, and the window is made 5 pixels wider by the user, + the right of the window will also be made 5 pixels wider. + Now, what if you want to clamp a widget to the bottom? Give it the flag + RESIZE_TB. This is RESIZE_TOP + RESIZE_BOTTOM. Now if the window gets + 5 pixels bigger, both the top and bottom gets 5 bigger, so the whole + widgets moves downwards without resizing, and appears to be clamped + to the bottom. Nice aint it? + You should know one more thing about this system. Most windows can't + handle an increase of 1 pixel. So there is a step function, which + let the windowsize only be changed by X pixels. You configure this + after making the window, like this: + w->resize.step_height = 10; + Now the window will only change in height in steps of 10. + You can also give a minimum width and height. The default value is + the default height/width of the window itself. You can change this + AFTER window-creation, with: + w->resize.width or w->resize.height. + That was all.. good luck, and enjoy :) -- TrueLight */ + +enum ResizeFlags { + RESIZE_NONE = 0, + + RESIZE_LEFT = 1, + RESIZE_RIGHT = 2, + RESIZE_TOP = 4, + RESIZE_BOTTOM = 8, + + RESIZE_LR = RESIZE_LEFT | RESIZE_RIGHT, + RESIZE_RB = RESIZE_RIGHT | RESIZE_BOTTOM, + RESIZE_TB = RESIZE_TOP | RESIZE_BOTTOM, + RESIZE_LRB = RESIZE_LEFT | RESIZE_RIGHT | RESIZE_BOTTOM, + RESIZE_LRTB = RESIZE_LEFT | RESIZE_RIGHT | RESIZE_TOP | RESIZE_BOTTOM, + RESIZE_RTB = RESIZE_RIGHT | RESIZE_TOP | RESIZE_BOTTOM, + + /* The following flags are used by the system to specify what is disabled, hidden, or clicked + * They are used in the same place as the above RESIZE_x flags, Widget visual_flags. + * These states are used in exceptions. If nothing is specified, they will indicate + * Enabled, visible or unclicked widgets*/ + WIDG_DISABLED = 4, // widget is greyed out, not available + WIDG_HIDDEN = 5, // widget is made invisible + WIDG_LOWERED = 6, // widget is paint lowered, a pressed button in fact +} ResizeFlag; + +/* used to indicate the end of widgets' list for vararg functions */ +enum { + WIDGET_LIST_END = -1, +}; + +typedef struct Widget { + byte type; ///< Widget type, see @WindowWidgetTypes + byte display_flags; ///< Resize direction, alignment, etc. during resizing, see @ResizeFlags + byte color; ///< Widget colour, see docs/ottd-colourtext-palette.png + uint16 left, right, top, bottom; ///< The position offsets inside the window + uint16 data; ///< The String/Image or special code (list-matrixes) of a widget + StringID tooltips; ///< Tooltips that are shown when rightclicking on a widget +} Widget; + +typedef enum FrameFlags { + FR_TRANSPARENT = 0x01, ///< Makes the background transparent if set + FR_BORDERONLY = 0x10, ///< Draw border only, no background + FR_LOWERED = 0x20, ///< If set the frame is lowered and the background color brighter (ie. buttons when pressed) + FR_DARKENED = 0x40, ///< If set the background is darker, allows for lowered frames with normal background color when used with FR_LOWERED (ie. dropdown boxes) +} FrameFlags; + +void DrawFrameRect(int left, int top, int right, int bottom, int color, FrameFlags flags); + +enum WindowEventCodes { + WE_CREATE, + WE_DESTROY, + WE_PAINT, + WE_KEYPRESS, + WE_CLICK, + WE_RCLICK, + WE_MOUSEOVER, + WE_MOUSELOOP, + WE_MOUSEWHEEL, + WE_TICK, + WE_4, + WE_TIMEOUT, + WE_PLACE_OBJ, + WE_ABORT_PLACE_OBJ, + WE_ON_EDIT_TEXT, + WE_ON_EDIT_TEXT_CANCEL, + WE_POPUPMENU_SELECT, + WE_POPUPMENU_OVER, + WE_DRAGDROP, + WE_PLACE_DRAG, + WE_PLACE_MOUSEUP, + WE_PLACE_PRESIZE, + WE_DROPDOWN_SELECT, + WE_RESIZE, + WE_MESSAGE, + WE_SCROLL, + WE_INVALIDATE_DATA, +}; + +struct WindowEvent { + byte event; + union { + struct{ + Point pt; + int widget; + } click; + + struct { + Point pt; + TileIndex tile; + TileIndex starttile; + int userdata; + } place; + + struct { + Point pt; + int widget; + } dragdrop; + + struct { + Point size; + Point diff; + } sizing; + + struct { + char *str; + } edittext; + + struct { + Point pt; + } popupmenu; + + struct { + int button; + int index; + } dropdown; + + struct { + Point pt; + int widget; + } mouseover; + + struct { + bool cont; // continue the search? (default true) + uint16 key; // 16-bit Unicode value of the key + uint16 keycode;// untranslated key (including shift-state) + } keypress; + + struct { + uint msg; // message to be sent + uint wparam; // additional message-specific information + uint lparam; // additional message-specific information + } message; + + struct { + Point delta; // delta position against position of last call + } scroll; + + struct { + int wheel; // how much was 'wheel'd' + } wheel; + } we; +}; + +enum WindowKeyCodes { + WKC_SHIFT = 0x8000, + WKC_CTRL = 0x4000, + WKC_ALT = 0x2000, + WKC_META = 0x1000, + + // Special ones + WKC_NONE = 0, + WKC_ESC = 1, + WKC_BACKSPACE = 2, + WKC_INSERT = 3, + WKC_DELETE = 4, + + WKC_PAGEUP = 5, + WKC_PAGEDOWN = 6, + WKC_END = 7, + WKC_HOME = 8, + + // Arrow keys + WKC_LEFT = 9, + WKC_UP = 10, + WKC_RIGHT = 11, + WKC_DOWN = 12, + + // Return & tab + WKC_RETURN = 13, + WKC_TAB = 14, + + // Numerical keyboard + WKC_NUM_0 = 16, + WKC_NUM_1 = 17, + WKC_NUM_2 = 18, + WKC_NUM_3 = 19, + WKC_NUM_4 = 20, + WKC_NUM_5 = 21, + WKC_NUM_6 = 22, + WKC_NUM_7 = 23, + WKC_NUM_8 = 24, + WKC_NUM_9 = 25, + WKC_NUM_DIV = 26, + WKC_NUM_MUL = 27, + WKC_NUM_MINUS = 28, + WKC_NUM_PLUS = 29, + WKC_NUM_ENTER = 30, + WKC_NUM_DECIMAL = 31, + + // Space + WKC_SPACE = 32, + + // Function keys + WKC_F1 = 33, + WKC_F2 = 34, + WKC_F3 = 35, + WKC_F4 = 36, + WKC_F5 = 37, + WKC_F6 = 38, + WKC_F7 = 39, + WKC_F8 = 40, + WKC_F9 = 41, + WKC_F10 = 42, + WKC_F11 = 43, + WKC_F12 = 44, + + // backquote is the key left of "1" + // we only store this key here, no matter what character is really mapped to it + // on a particular keyboard. (US keyboard: ` and ~ ; German keyboard: ^ and °) + WKC_BACKQUOTE = 45, + WKC_PAUSE = 46, + + // 0-9 are mapped to 48-57 + // A-Z are mapped to 65-90 + // a-z are mapped to 97-122 +}; + +typedef struct WindowDesc { + int16 left, top, width, height; + WindowClass cls; + WindowClass parent_cls; + uint32 flags; + const Widget *widgets; + WindowProc *proc; +} WindowDesc; + +enum WindowDefaultFlag { + WDF_STD_TOOLTIPS = 1, /* use standard routine when displaying tooltips */ + WDF_DEF_WIDGET = 2, /* default widget control for some widgets in the on click event */ + WDF_STD_BTN = 4, /* default handling for close and drag widgets (widget no 0 and 1) */ + + WDF_UNCLICK_BUTTONS = 16, /* Unclick buttons when the window event times out */ + WDF_STICKY_BUTTON = 32, /* Set window to sticky mode; they are not closed unless closed with 'X' (widget 2) */ + WDF_RESIZABLE = 64, /* A window can be resized */ + WDF_MODAL = 128, /* The window is a modal child of some other window, meaning the parent is 'inactive' */ +}; + +/* can be used as x or y coordinates to cause a specific placement */ +enum WindowDefaultPosition { + WDP_AUTO = -1, ///< Find a place automatically + WDP_CENTER = -2, ///< Center the window (left/right or top/bottom) + WDP_ALIGN_TBR = -3, ///< Align the right side of the window with the right side of the main toolbar + WDP_ALIGN_TBL = -4, ///< Align the left side of the window with the left side of the main toolbar +}; + +typedef struct Textbuf { + char *buf; /* buffer in which text is saved */ + uint16 maxlength, maxwidth; /* the maximum size of the buffer. Maxwidth specifies screensize in pixels, maxlength is in bytes */ + uint16 length, width; /* the current size of the string. Width specifies screensize in pixels, length is in bytes */ + bool caret; /* is the caret ("_") visible or not */ + uint16 caretpos; /* the current position of the caret in the buffer, in bytes */ + uint16 caretxoffs; /* the current position of the caret in pixels */ +} Textbuf; + +#define WP(ptr,str) (*(str*)(ptr)->custom) +/* You cannot 100% reliably calculate the biggest custom struct as + * the number of pointers in it and alignment will have a huge impact. + * 96 is the largest window-size for 64-bit machines currently */ +#define WINDOW_CUSTOM_SIZE 96 + +typedef struct Scrollbar { + uint16 count, cap, pos; +} Scrollbar; + +typedef struct ResizeInfo { + uint width; /* Minimum width and height */ + uint height; + + uint step_width; /* In how big steps the width and height go */ + uint step_height; +} ResizeInfo; + +typedef struct WindowMessage { + int msg; + int wparam; + int lparam; +} WindowMessage; + +struct Window { + uint16 flags4; + WindowClass window_class; + WindowNumber window_number; + + int left, top; + int width, height; + + Scrollbar hscroll, vscroll, vscroll2; + ResizeInfo resize; + + byte caption_color; + + WindowProc *wndproc; + ViewPort *viewport; + const Widget *original_widget; + Widget *widget; + uint widget_count; + uint32 desc_flags; + + WindowMessage message; + Window *parent; + byte custom[WINDOW_CUSTOM_SIZE]; +}; + +typedef struct querystr_d { + StringID caption; + Textbuf text; + const char *orig; + CharSetFilter afilter; + bool handled; +} querystr_d; +assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(querystr_d)); + +typedef struct { + byte item_count; /* follow_vehicle */ + byte sel_index; /* scrollpos_x */ + byte main_button; /* scrollpos_y */ + byte action_id; + StringID string_id; /* unk30 */ + uint16 checked_items; /* unk32 */ + byte disabled_items; +} menu_d; +assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(menu_d)); + +typedef struct { + int16 data_1, data_2, data_3; + int16 data_4, data_5; + bool close; + byte byte_1; +} def_d; +assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(def_d)); + +typedef struct { + void *data; +} void_d; +assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(void_d)); + +typedef struct { + uint16 base; + uint16 count; +} tree_d; +assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tree_d)); + +typedef struct { + StringID string_id; + byte paramcount; + uint32 params[5]; +} tooltips_d; +assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tooltips_d)); + +typedef struct { + byte vehicle_type; + union { + byte railtype; + byte acc_planes; // AIRCRAFT_ONLY, ALL, HELICOPTERS_ONLY + } filter; + byte sel_index; // deprecated value, used for 'unified' ship and road + bool descending_sort_order; + byte sort_criteria; + EngineID sel_engine; + EngineID rename_engine; + EngineList eng_list; +} buildvehicle_d; +assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(buildvehicle_d)); + +typedef struct { + byte vehicletype; + byte sel_index[2]; + EngineID sel_engine[2]; + uint16 count[2]; + bool wagon_btnstate; // true means engine is selected +} replaceveh_d; +assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(replaceveh_d)); + +typedef struct { + VehicleID sel; + byte type; + bool generate_list; + uint16 engine_list_length; + uint16 wagon_list_length; + uint16 engine_count; + uint16 wagon_count; + Vehicle **vehicle_list; + Vehicle **wagon_list; +} depot_d; +assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(depot_d)); + +typedef struct { + int sel; +} order_d; +assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(order_d)); + +typedef struct { + byte tab; +} traindetails_d; +assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(traindetails_d)); + +typedef struct { + int32 scroll_x; + int32 scroll_y; + int32 subscroll; +} smallmap_d; +assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(smallmap_d)); + +typedef struct { + uint32 face; + byte gender; +} facesel_d; +assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(facesel_d)); + +typedef struct { + int sel; + struct RefitOption *cargo; + struct RefitList *list; + uint length; + VehicleOrderID order; +} refit_d; +assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(refit_d)); + +typedef struct { + VehicleID follow_vehicle; + int32 scrollpos_x; + int32 scrollpos_y; +} vp_d; +assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vp_d)); + +// vp2_d is the same as vp_d, except for the data_# values.. +typedef struct { + VehicleID follow_vehicle; + int32 scrollpos_x; + int32 scrollpos_y; + byte data_1; + byte data_2; + byte data_3; +} vp2_d; +assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vp2_d)); + +typedef struct { + uint16 follow_vehicle; + int32 scrollpos_x; + int32 scrollpos_y; + NewsItem *ni; +} news_d; +assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(news_d)); + +typedef struct { + uint32 background_img; + int8 rank; +} highscore_d; +assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(highscore_d)); + +typedef struct { + int height; + uint16 counter; +} scroller_d; +assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(scroller_d)); + +typedef enum SortListFlags { + VL_DESC = 0x01, // sort descending or ascending + VL_RESORT = 0x02, // instruct the code to resort the list in the next loop + VL_REBUILD = 0x04 // create sort-listing to use for qsort and friends +} SortListFlags; + +typedef struct Listing { + bool order; // Ascending/descending + byte criteria; // Sorting criteria +} Listing; + +typedef struct list_d { + uint16 list_length; // length of the list being sorted + byte sort_type; // what criteria to sort on + SortListFlags flags; // used to control sorting/resorting/etc. + uint16 resort_timer; // resort list after a given amount of ticks if set +} list_d; +assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(list_d)); + +typedef struct message_d { + int msg; + int wparam; + int lparam; +} message_d; +assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(message_d)); + +typedef struct dropdown_d { + uint32 disabled_state; + uint32 hidden_state; + WindowClass parent_wnd_class; + WindowNumber parent_wnd_num; + byte parent_button; + byte num_items; + byte selected_index; + const StringID *items; + byte click_delay; + bool drag_mode; +} dropdown_d; +assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(dropdown_d)); + + +/****************** THESE ARE NOT WIDGET TYPES!!!!! *******************/ +enum WindowWidgetBehaviours { + WWB_PUSHBUTTON = 1 << 5, + + WWB_MASK = 0xE0, +}; + + +enum WindowWidgetTypes { + WWT_EMPTY, + + WWT_PANEL, /* simple depressed panel */ + WWT_INSET, /* pressed (inset) panel, most commonly used as combo box _text_ area */ + WWT_IMGBTN, /* button with image */ + WWT_IMGBTN_2, /* button with diff image when clicked */ + + WWT_TEXTBTN, /* button with text */ + WWT_TEXTBTN_2, /* button with diff text when clicked */ + WWT_LABEL, /* centered label */ + WWT_MATRIX, + WWT_SCROLLBAR, + WWT_FRAME, /* frame */ + WWT_CAPTION, + + WWT_HSCROLLBAR, + WWT_STICKYBOX, + WWT_SCROLL2BAR, /* 2nd vertical scrollbar*/ + WWT_RESIZEBOX, + WWT_CLOSEBOX, + WWT_LAST, /* Last Item. use WIDGETS_END to fill up padding!! */ + + WWT_MASK = 0x1F, + + WWT_PUSHBTN = WWT_PANEL | WWB_PUSHBUTTON, + WWT_PUSHTXTBTN = WWT_TEXTBTN | WWB_PUSHBUTTON, + WWT_PUSHIMGBTN = WWT_IMGBTN | WWB_PUSHBUTTON, +}; + +#define WIDGETS_END WWT_LAST, RESIZE_NONE, 0, 0, 0, 0, 0, 0, STR_NULL + +enum WindowFlags { + WF_TIMEOUT_SHL = 0, + WF_TIMEOUT_MASK = 7, + WF_DRAGGING = 1 << 3, + WF_SCROLL_UP = 1 << 4, + WF_SCROLL_DOWN = 1 << 5, + WF_SCROLL_MIDDLE = 1 << 6, + WF_HSCROLL = 1 << 7, + WF_SIZING = 1 << 8, + WF_STICKY = 1 << 9, + + WF_DISABLE_VP_SCROLL = 1 << 10, + + WF_WHITE_BORDER_ONE = 1 << 11, + WF_WHITE_BORDER_MASK = 1 << 12 | WF_WHITE_BORDER_ONE, + WF_SCROLL2 = 1 << 13, +}; + +/* window.c */ +void CallWindowEventNP(Window *w, int event); +void CallWindowTickEvent(void); +void SetWindowDirty(const Window *w); +void SendWindowMessage(WindowClass wnd_class, WindowNumber wnd_num, uint msg, uint wparam, uint lparam); +void SendWindowMessageClass(WindowClass wnd_class, uint msg, uint wparam, uint lparam); + +Window *FindWindowById(WindowClass cls, WindowNumber number); +void DeleteWindow(Window *w); +void DeletePlayerWindows(PlayerID pi); +void ChangeWindowOwner(PlayerID old_player, PlayerID new_player); +Window *BringWindowToFrontById(WindowClass cls, WindowNumber number); +Window *FindWindowFromPt(int x, int y); + +bool IsWindowOfPrototype(const Window *w, const Widget *widget); +void AssignWidgetToWindow(Window *w, const Widget *widget); +Window *AllocateWindow( + int x, + int y, + int width, + int height, + WindowProc *proc, + WindowClass cls, + const Widget *widget); + +Window *AllocateWindowDesc(const WindowDesc *desc); +Window *AllocateWindowDescFront(const WindowDesc *desc, int window_number); + +void DrawWindowViewport(const Window *w); +void ResizeWindow(Window *w, int x, int y); + +/** + * Sets the enabled/disabled status of a widget. + * By default, widgets are enabled. + * On certain conditions, they have to be disabled. + * @param w : Window on which the widget is located + * @param widget_index : index of this widget in the window + * @param disab_stat : status to use ie: disabled = true, enabled = false + */ +static inline void SetWindowWidgetDisabledState(Window *w, byte widget_index, bool disab_stat) +{ + assert(widget_index < w->widget_count); + SB(w->widget[widget_index].display_flags, WIDG_DISABLED, 1, !!disab_stat); +} + +/** + * Sets a widget to disabled. + * @param w : Window on which the widget is located + * @param widget_index : index of this widget in the window + */ +static inline void DisableWindowWidget(Window *w, byte widget_index) +{ + SetWindowWidgetDisabledState(w, widget_index, true); +} + +/** + * Sets a widget to Enabled. + * @param w : Window on which the widget is located + * @param widget_index : index of this widget in the window + */ +static inline void EnableWindowWidget(Window *w, byte widget_index) +{ + SetWindowWidgetDisabledState(w, widget_index, false); +} + +/** + * Gets the enabled/disabled status of a widget. + * @param w : Window on which the widget is located + * @param widget_index : index of this widget in the window + * @return status of the widget ie: disabled = true, enabled = false + */ +static inline bool IsWindowWidgetDisabled(const Window *w, byte widget_index) +{ + assert(widget_index < w->widget_count); + return HASBIT(w->widget[widget_index].display_flags, WIDG_DISABLED); +} + +/** + * Sets the hidden/shown status of a widget. + * By default, widgets are visible. + * On certain conditions, they have to be hidden. + * @param w Window on which the widget is located + * @param widget_index index of this widget in the window + * @param hidden_stat status to use ie. hidden = true, visible = false + */ +static inline void SetWindowWidgetHiddenState(Window *w, byte widget_index, bool hidden_stat) +{ + assert(widget_index < w->widget_count); + SB(w->widget[widget_index].display_flags, WIDG_HIDDEN, 1, !!hidden_stat); +} + +/** + * Sets a widget hidden. + * @param w : Window on which the widget is located + * @param widget_index : index of this widget in the window + */ +static inline void HideWindowWidget(Window *w, byte widget_index) +{ + SetWindowWidgetHiddenState(w, widget_index, true); +} + +/** + * Sets a widget visible. + * @param w : Window on which the widget is located + * @param widget_index : index of this widget in the window + */ +static inline void ShowWindowWidget(Window *w, byte widget_index) +{ + SetWindowWidgetHiddenState(w, widget_index, false); +} + +/** + * Gets the visibility of a widget. + * @param w : Window on which the widget is located + * @param widget_index : index of this widget in the window + * @return status of the widget ie: hidden = true, visible = false + */ +static inline bool IsWindowWidgetHidden(const Window *w, byte widget_index) +{ + assert(widget_index < w->widget_count); + return HASBIT(w->widget[widget_index].display_flags, WIDG_HIDDEN); +} + +/** + * Sets the lowered/raised status of a widget. + * @param w : Window on which the widget is located + * @param widget_index : index of this widget in the window + * @param hidden_stat : status to use ie: lowered = true, raised = false + */ +static inline void SetWindowWidgetLoweredState(Window *w, byte widget_index, bool lowered_stat) +{ + assert(widget_index < w->widget_count); + SB(w->widget[widget_index].display_flags, WIDG_LOWERED, 1, !!lowered_stat); +} + +/** + * Invert the lowered/raised status of a widget. + * @param w : Window on which the widget is located + * @param widget_index : index of this widget in the window + */ +static inline void ToggleWidgetLoweredState(Window *w, byte widget_index) +{ + assert(widget_index < w->widget_count); + TOGGLEBIT(w->widget[widget_index].display_flags, WIDG_LOWERED); +} + +/** + * Marks a widget as lowered. + * @param w : Window on which the widget is located + * @param widget_index : index of this widget in the window + */ +static inline void LowerWindowWidget(Window *w, byte widget_index) +{ + SetWindowWidgetLoweredState(w, widget_index, true); +} + +/** + * Marks a widget as raised. + * @param w : Window on which the widget is located + * @param widget_index : index of this widget in the window + */ +static inline void RaiseWindowWidget(Window *w, byte widget_index) +{ + SetWindowWidgetLoweredState(w, widget_index, false); +} + +/** + * Gets the lowered state of a widget. + * @param w : Window on which the widget is located + * @param widget_index : index of this widget in the window + * @return status of the widget ie: lowered = true, raised= false + */ +static inline bool IsWindowWidgetLowered(const Window *w, byte widget_index) +{ + assert(widget_index < w->widget_count); + return HASBIT(w->widget[widget_index].display_flags, WIDG_LOWERED); +} + +void InitWindowSystem(void); +void UnInitWindowSystem(void); +void ResetWindowSystem(void); +int GetMenuItemIndex(const Window *w, int x, int y); +void InputLoop(void); +void HandleKeypress(uint32 key); +void HandleMouseEvents(void); +void UpdateWindows(void); +void InvalidateWidget(const Window *w, byte widget_index); +void InvalidateThisWindowData(Window *w); +void InvalidateWindowData(WindowClass cls, WindowNumber number); +void RaiseWindowButtons(Window *w); +void RelocateAllWindows(int neww, int newh); +int PositionMainToolbar(Window *w); +void CDECL SetWindowWidgetsDisabledState(Window *w, bool disab_stat, int widgets, ...); +void CDECL SetWindowWidgetsHiddenState(Window *w, bool hidden_stat, int widgets, ...); +void CDECL SetWindowWidgetsLoweredState(Window *w, bool lowered_stat, int widgets, ...); + +/* misc_gui.c*/ +void GuiShowTooltipsWithArgs(StringID str, uint paramcount, const uint params[]); +static inline void GuiShowTooltips(StringID str) +{ + GuiShowTooltipsWithArgs(str, 0, NULL); +} + +/* widget.c */ +int GetWidgetFromPos(const Window *w, int x, int y); +void DrawWindowWidgets(const Window *w); +void ShowDropDownMenu(Window *w, const StringID *strings, int selected, int button, uint32 disabled_mask, uint32 hidden_mask); + +void HandleButtonClick(Window *w, byte widget); + +Window *GetCallbackWnd(void); +void DeleteNonVitalWindows(void); +void DeleteAllNonVitalWindows(void); +void HideVitalWindows(void); +void ShowVitalWindows(void); +Window **FindWindowZPosition(const Window *w); + +/* window.c */ +extern Window *_z_windows[]; +extern Window **_last_z_window; +#define FOR_ALL_WINDOWS(wz) for (wz = _z_windows; wz != _last_z_window; wz++) + +VARDEF Point _cursorpos_drag_start; + +VARDEF bool _left_button_down; +VARDEF bool _left_button_clicked; + +VARDEF bool _right_button_down; +VARDEF bool _right_button_clicked; + +VARDEF int _scrollbar_start_pos; +VARDEF int _scrollbar_size; +VARDEF byte _scroller_click_timeout; + +VARDEF bool _scrolling_scrollbar; +VARDEF bool _scrolling_viewport; +VARDEF bool _popup_menu_active; + +VARDEF byte _special_mouse_mode; +enum SpecialMouseMode { + WSM_NONE = 0, + WSM_DRAGDROP = 1, + WSM_SIZING = 2, + WSM_PRESIZE = 3, +}; + +void ScrollbarClickHandler(Window *w, const Widget *wi, int x, int y); + +#endif /* WINDOW_H */ |