window_gui.h

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef WINDOW_GUI_H
#define WINDOW_GUI_H
 
#include "vehiclelist.h"
#include "vehicle_type.h"
#include "viewport_type.h"
#include "company_type.h"
#include "tile_type.h"
#include "widget_type.h"
#include "string_type.h"
 
enum class FrameFlag : uint8_t {
  Transparent, 
  BorderOnly, 
  Lowered, 
  Darkened, 
};
using FrameFlags = EnumBitSet<FrameFlag, uint8_t>;
 
class WidgetDimensions {
public:
  RectPadding imgbtn;        
  RectPadding inset;         
  RectPadding vscrollbar;    
  RectPadding hscrollbar;    
  RectPadding bevel;         
  RectPadding fullbevel;     
  RectPadding framerect;     
  RectPadding frametext;     
  RectPadding matrix;        
  RectPadding shadebox;      
  RectPadding stickybox;     
  RectPadding debugbox;      
  RectPadding defsizebox;    
  RectPadding resizebox;     
  RectPadding closebox;      
  RectPadding captiontext;   
  RectPadding dropdowntext;  
  RectPadding dropdownlist;  
  RectPadding modalpopup;    
  RectPadding picker;        
  RectPadding sparse;        
  RectPadding sparse_resize; 
 
  int vsep_picker;          
  int vsep_normal;          
  int vsep_sparse;          
  int vsep_wide;            
  int hsep_normal;          
  int hsep_wide;            
  int hsep_indent;          
 
  static const WidgetDimensions unscaled; 
  static WidgetDimensions scaled;         
 
  static constexpr float ASPECT_LOCATION = 12.f / 14.f;
  static constexpr float ASPECT_RENAME = 12.f / 14.f;
  static constexpr float ASPECT_SETTINGS_BUTTON = 21.f / 12.f;
  static constexpr float ASPECT_TOGGLE_SIZE = 12.f / 14.f;
  static constexpr float ASPECT_LEFT_RIGHT_BUTTON = 8.f / 12.f;
  static constexpr float ASPECT_UP_DOWN_BUTTON = 11.f / 12.f;
  static constexpr float ASPECT_VEHICLE_ICON = 15.f / 12.f;
  static constexpr float ASPECT_VEHICLE_FLAG = 11.f / 12.f;
 
private:
  static constexpr uint WD_SHADEBOX_WIDTH = 12; 
  static constexpr uint WD_STICKYBOX_WIDTH = 12; 
  static constexpr uint WD_DEBUGBOX_WIDTH = 12; 
  static constexpr uint WD_DEFSIZEBOX_WIDTH = 12; 
  static constexpr uint WD_RESIZEBOX_WIDTH = 12; 
  static constexpr uint WD_CLOSEBOX_WIDTH = 11; 
  static constexpr uint WD_CAPTION_HEIGHT = 14; 
  static constexpr uint WD_DROPDOWN_HEIGHT = 12; 
 
  friend NWidgetLeaf;
};
 
inline constexpr WidgetDimensions WidgetDimensions::unscaled = {
  .imgbtn        = { .left =  1, .top =  1, .right =  1, .bottom =  1},
  .inset         = { .left =  2, .top =  1, .right =  2, .bottom =  1},
  .vscrollbar    = { .left =  2, .top =  3, .right =  2, .bottom =  3},
  .hscrollbar    = { .left =  3, .top =  2, .right =  3, .bottom =  2},
  .bevel         = { .left =  1, .top =  1, .right =  1, .bottom =  1},
  .fullbevel     = { .left =  1, .top =  1, .right =  1, .bottom =  1},
  .framerect     = { .left =  2, .top =  1, .right =  2, .bottom =  1},
  .frametext     = { .left =  6, .top =  6, .right =  6, .bottom =  6},
  .matrix        = { .left =  2, .top =  3, .right =  2, .bottom =  1},
  .shadebox      = { .left =  2, .top =  3, .right =  2, .bottom =  3},
  .stickybox     = { .left =  2, .top =  3, .right =  2, .bottom =  3},
  .debugbox      = { .left =  2, .top =  3, .right =  2, .bottom =  3},
  .defsizebox    = { .left =  2, .top =  3, .right =  2, .bottom =  3},
  .resizebox     = { .left =  2, .top =  2, .right =  2, .bottom =  2},
  .closebox      = { .left =  2, .top =  2, .right =  1, .bottom =  2},
  .captiontext   = { .left =  2, .top =  2, .right =  2, .bottom =  2},
  .dropdowntext  = { .left =  2, .top =  1, .right =  2, .bottom =  1},
  .dropdownlist  = { .left =  1, .top =  2, .right =  1, .bottom =  2},
  .modalpopup    = { .left = 20, .top = 10, .right = 20, .bottom = 10},
  .picker        = { .left =  3, .top =  3, .right =  3, .bottom =  3},
  .sparse        = { .left = 10, .top =  8, .right = 10, .bottom =  8},
  .sparse_resize = { .left = 10, .top =  8, .right = 10, .bottom =  0},
  .vsep_picker   = 1,
  .vsep_normal   = 2,
  .vsep_sparse   = 4,
  .vsep_wide     = 8,
  .hsep_normal   = 2,
  .hsep_wide     = 6,
  .hsep_indent   = 10,
};
 
/* widget.cpp */
void DrawFrameRect(int left, int top, int right, int bottom, Colours colour, FrameFlags flags);
 
inline void DrawFrameRect(const Rect &r, Colours colour, FrameFlags flags)
{
  DrawFrameRect(r.left, r.top, r.right, r.bottom, colour, flags);
}
 
void DrawCaption(const Rect &r, Colours colour, Owner owner, TextColour text_colour, std::string_view str, StringAlignment align, FontSize fs);
 
/* window.cpp */
using WindowList = std::list<Window *>;
extern WindowList _z_windows;
extern Window *_focused_window;
 
 
enum WindowPosition : uint8_t {
  WDP_MANUAL,        
  WDP_AUTO,          
  WDP_CENTER,        
  WDP_ALIGN_TOOLBAR, 
};
 
enum class WindowDefaultFlag : uint8_t {
  Construction, 
  Modal, 
  NoFocus, 
  NoClose, 
};
using WindowDefaultFlags = EnumBitSet<WindowDefaultFlag, uint8_t>;
 
Point GetToolbarAlignedWindowPosition(int window_width);
 
struct HotkeyList;
 
struct WindowDesc {
 
  WindowDesc(WindowPosition default_pos, const char *ini_key, int16_t def_width_trad, int16_t def_height_trad,
      WindowClass window_class, WindowClass parent_class, WindowDefaultFlags flags,
      const std::span<const NWidgetPart> nwid_parts, HotkeyList *hotkeys = nullptr,
      const std::source_location location = std::source_location::current());
 
  ~WindowDesc();
 
  const std::source_location source_location; 
  const WindowPosition default_pos; 
  const WindowClass cls; 
  const WindowClass parent_cls; 
  const char *ini_key; 
  const WindowDefaultFlags flags; 
  const std::span<const NWidgetPart> nwid_parts; 
  const HotkeyList *hotkeys; 
 
  bool pref_sticky = false; 
  int16_t pref_width = 0; 
  int16_t pref_height = 0; 
 
  int16_t GetDefaultWidth() const;
  int16_t GetDefaultHeight() const;
 
  static void LoadFromConfig();
  static void SaveToConfig();
 
private:
  const int16_t default_width_trad; 
  const int16_t default_height_trad; 
 
  WindowDesc(const WindowDesc &) = delete;
  WindowDesc& operator=(const WindowDesc &) = delete;
};
 
struct ResizeInfo {
  uint step_width;  
  uint step_height; 
};
 
enum SortButtonState : uint8_t {
  SBS_OFF,  
  SBS_DOWN, 
  SBS_UP,   
};
 
enum class WindowFlag : uint8_t {
  Timeout,          
 
  Dragging,         
  SizingRight,      
  SizingLeft,       
 
  Sticky,           
  DisableVpScroll,  
  WhiteBorder,      
  Highlighted,      
  Centred,          
};
using WindowFlags = EnumBitSet<WindowFlag, uint16_t>;
 
static const int TIMEOUT_DURATION = 7; 
static const int WHITE_BORDER_DURATION = 3; 
 
struct ViewportData : Viewport {
  VehicleID follow_vehicle; 
  int32_t scrollpos_x;        
  int32_t scrollpos_y;        
  int32_t dest_scrollpos_x;   
  int32_t dest_scrollpos_y;   
 
  void CancelFollow(const Window &viewport_window);
};
 
struct QueryString;
 
/* misc_gui.cpp */
enum TooltipCloseCondition : uint8_t {
  TCC_RIGHT_CLICK,
  TCC_HOVER,
  TCC_NONE,
  TCC_EXIT_VIEWPORT,
};
 
struct Window {
private:
  static std::vector<Window *> closed_windows;
 
protected:
  void InitializeData(WindowNumber window_number);
  void InitializePositionSize(int x, int y, int min_width, int min_height);
  virtual void FindWindowPlacementAndResize(int def_width, int def_height);
 
  std::vector<int> scheduled_invalidation_data{}; 
  bool scheduled_resize = false; 
 
  /* Protected to prevent deletion anywhere outside Window::DeleteClosedWindows(). */
  virtual ~Window();
 
public:
  Window(WindowDesc &desc);
 
  inline void *operator new[](size_t size) = delete;
 
  WindowDesc &window_desc; 
  WindowFlags flags{}; 
  WindowClass window_class{}; 
  WindowNumber window_number = 0; 
 
  int scale = 0; 
 
  uint8_t timeout_timer = 0; 
  uint8_t white_border_timer = 0; 
 
  int left = 0; 
  int top = 0; 
  int width = 0; 
  int height = 0; 
 
  ResizeInfo resize{}; 
 
  Owner owner = INVALID_OWNER; 
 
  ViewportData *viewport = nullptr; 
  const NWidgetCore *nested_focus = nullptr; 
  std::map<WidgetID, QueryString*> querystrings{}; 
  std::unique_ptr<NWidgetBase> nested_root{}; 
  WidgetLookup widget_lookup{}; 
  NWidgetStacked *shade_select = nullptr; 
  Dimension unshaded_size{}; 
 
  WidgetID mouse_capture_widget = -1; 
 
  Window *parent = nullptr; 
  WindowList::iterator z_position{};
 
  template <class NWID>
  inline const NWID *GetWidget(WidgetID widnum) const;
  template <class NWID>
  inline NWID *GetWidget(WidgetID widnum);
 
  const Scrollbar *GetScrollbar(WidgetID widnum) const;
  Scrollbar *GetScrollbar(WidgetID widnum);
 
  const QueryString *GetQueryString(WidgetID widnum) const;
  QueryString *GetQueryString(WidgetID widnum);
  void UpdateQueryStringSize();
 
  virtual const struct Textbuf *GetFocusedTextbuf() const;
  virtual Point GetCaretPosition() const;
  virtual Rect GetTextBoundingRect(const char *from, const char *to) const;
  virtual ptrdiff_t GetTextCharacterAtPosition(const Point &pt) const;
 
  void InitNested(WindowNumber number = 0);
  void CreateNestedTree();
  void FinishInitNested(WindowNumber window_number = 0);
 
  inline void SetTimeout()
  {
    this->flags.Set(WindowFlag::Timeout);
    this->timeout_timer = TIMEOUT_DURATION;
  }
 
  inline void SetWhiteBorder()
  {
    this->flags.Set(WindowFlag::WhiteBorder);
    this->white_border_timer = WHITE_BORDER_DURATION;
  }
 
  void DisableAllWidgetHighlight();
  void SetWidgetHighlight(WidgetID widget_index, TextColour highlighted_colour);
  bool IsWidgetHighlighted(WidgetID widget_index) const;
 
  inline void SetWidgetDisabledState(WidgetID widget_index, bool disab_stat)
  {
    NWidgetCore *nwid = this->GetWidget<NWidgetCore>(widget_index);
    if (nwid != nullptr) nwid->SetDisabled(disab_stat);
  }
 
  inline void DisableWidget(WidgetID widget_index)
  {
    SetWidgetDisabledState(widget_index, true);
  }
 
  inline void EnableWidget(WidgetID widget_index)
  {
    SetWidgetDisabledState(widget_index, false);
  }
 
  inline bool IsWidgetDisabled(WidgetID widget_index) const
  {
    return this->GetWidget<NWidgetCore>(widget_index)->IsDisabled();
  }
 
  inline bool IsWidgetFocused(WidgetID widget_index) const
  {
    return this->nested_focus != nullptr && this->nested_focus->GetIndex() == widget_index;
  }
 
  inline bool IsWidgetGloballyFocused(WidgetID widget_index) const
  {
    return _focused_window == this && IsWidgetFocused(widget_index);
  }
 
  inline void SetWidgetLoweredState(WidgetID widget_index, bool lowered_stat)
  {
    this->GetWidget<NWidgetCore>(widget_index)->SetLowered(lowered_stat);
  }
 
  inline void ToggleWidgetLoweredState(WidgetID widget_index)
  {
    bool lowered_state = this->GetWidget<NWidgetCore>(widget_index)->IsLowered();
    this->GetWidget<NWidgetCore>(widget_index)->SetLowered(!lowered_state);
  }
 
  inline void LowerWidget(WidgetID widget_index)
  {
    SetWidgetLoweredState(widget_index, true);
  }
 
  inline void RaiseWidget(WidgetID widget_index)
  {
    SetWidgetLoweredState(widget_index, false);
  }
 
  inline void RaiseWidgetWhenLowered(WidgetID widget_index)
  {
    if (this->IsWidgetLowered(widget_index)) {
      this->RaiseWidget(widget_index);
      this->SetWidgetDirty(widget_index);
    }
  }
 
  inline bool IsWidgetLowered(WidgetID widget_index) const
  {
    return this->GetWidget<NWidgetCore>(widget_index)->IsLowered();
  }
 
  void UnfocusFocusedWidget();
  bool SetFocusedWidget(WidgetID widget_index);
 
  EventState HandleEditBoxKey(WidgetID wid, char32_t key, uint16_t keycode);
  virtual void InsertTextString(WidgetID wid, const char *str, bool marked, const char *caret, const char *insert_location, const char *replacement_end);
 
  void HandleButtonClick(WidgetID widget);
  int GetRowFromWidget(int clickpos, WidgetID widget, int padding, int line_height = -1) const;
 
  void RaiseButtons(bool autoraise = false);
 
  template <typename... Args>
  void SetWidgetsDisabledState(bool disab_stat, Args... widgets)
  {
    (SetWidgetDisabledState(widgets, disab_stat), ...);
  }
 
  template <typename... Args>
  void SetWidgetsLoweredState(bool lowered_stat, Args... widgets)
  {
    (SetWidgetLoweredState(widgets, lowered_stat), ...);
  }
 
  template <typename... Args>
  void RaiseWidgetsWhenLowered(Args... widgets)
  {
    (this->RaiseWidgetWhenLowered(widgets), ...);
  }
 
  void SetWidgetDirty(WidgetID widget_index) const;
 
  void DrawWidgets() const;
  void DrawViewport() const;
  void DrawSortButtonState(WidgetID widget, SortButtonState state) const;
  static int SortButtonWidth();
 
  Window *FindChildWindow(WindowClass wc = WC_INVALID) const;
  void CloseChildWindows(WindowClass wc = WC_INVALID) const;
  virtual void Close(int data = 0);
  static void DeleteClosedWindows();
 
  void SetDirty() const;
  void ReInit(int rx = 0, int ry = 0, bool reposition = false);
 
  inline bool IsShaded() const
  {
    return this->shade_select != nullptr && this->shade_select->shown_plane == SZSP_HORIZONTAL;
  }
 
  void SetShaded(bool make_shaded);
 
  void ScheduleResize();
  void ProcessScheduledResize();
  void InvalidateData(int data = 0, bool gui_scope = true);
  void ProcessScheduledInvalidations();
  void ProcessHighlightedInvalidations();
 
  /*** Event handling ***/
 
  virtual void OnInit() { }
 
  virtual void ApplyDefaults();
 
  virtual Point OnInitialPosition(int16_t sm_width, int16_t sm_height, int window_number);
 
  virtual void OnPaint()
  {
    this->DrawWidgets();
  }
 
  virtual void DrawWidget([[maybe_unused]] const Rect &r, [[maybe_unused]] WidgetID widget) const {}
 
  virtual void UpdateWidgetSize([[maybe_unused]] WidgetID widget, [[maybe_unused]] Dimension &size, [[maybe_unused]] const Dimension &padding, [[maybe_unused]] Dimension &fill, [[maybe_unused]] Dimension &resize) {}
 
  virtual std::string GetWidgetString([[maybe_unused]] WidgetID widget, StringID stringid) const;
 
  virtual void OnFocus();
 
  virtual void OnFocusLost(bool closing);
 
  virtual EventState OnKeyPress([[maybe_unused]] char32_t key, [[maybe_unused]] uint16_t keycode) { return ES_NOT_HANDLED; }
 
  virtual EventState OnHotkey(int hotkey);
 
  virtual EventState OnCTRLStateChange() { return ES_NOT_HANDLED; }
 
 
  virtual void OnClick([[maybe_unused]] Point pt, [[maybe_unused]] WidgetID widget, [[maybe_unused]] int click_count) {}
 
  virtual bool OnRightClick([[maybe_unused]] Point pt, [[maybe_unused]] WidgetID widget) { return false; }
 
  virtual void OnHover([[maybe_unused]] Point pt, [[maybe_unused]] WidgetID widget) {}
 
  virtual bool OnTooltip([[maybe_unused]] Point pt, [[maybe_unused]] WidgetID widget, [[maybe_unused]] TooltipCloseCondition close_cond) { return false; }
 
  virtual void OnMouseDrag([[maybe_unused]] Point pt, [[maybe_unused]] WidgetID widget) {}
 
  virtual void OnDragDrop([[maybe_unused]] Point pt, [[maybe_unused]] WidgetID widget) {}
 
  virtual void OnScroll([[maybe_unused]] Point delta) {}
 
  virtual void OnMouseOver([[maybe_unused]] Point pt, [[maybe_unused]] WidgetID widget) {}
 
  virtual void OnMouseWheel([[maybe_unused]] int wheel) {}
 
 
  virtual void OnMouseLoop() {}
 
  virtual void OnGameTick() {}
 
  virtual void OnRealtimeTick([[maybe_unused]] uint delta_ms) {}
 
  virtual void OnTimeout() {}
 
 
  virtual void OnResize() {}
 
  virtual void OnDropdownSelect([[maybe_unused]] WidgetID widget, [[maybe_unused]] int index) {}
 
  virtual void OnDropdownClose(Point pt, WidgetID widget, int index, bool instant_close);
 
  virtual void OnEditboxChanged([[maybe_unused]] WidgetID widget) {}
 
  virtual void OnQueryTextFinished([[maybe_unused]] std::optional<std::string> str) {}
 
  virtual void OnInvalidateData([[maybe_unused]] int data = 0, [[maybe_unused]] bool gui_scope = true) {}
 
  virtual void OnPlaceObject([[maybe_unused]] Point pt, [[maybe_unused]] TileIndex tile) {}
 
  virtual bool OnVehicleSelect([[maybe_unused]] const struct Vehicle *v) { return false; }
 
  virtual bool OnVehicleSelect([[maybe_unused]] VehicleList::const_iterator begin, [[maybe_unused]] VehicleList::const_iterator end) { return false; }
 
  virtual void OnPlaceObjectAbort() {}
 
 
  virtual void OnPlaceDrag([[maybe_unused]] ViewportPlaceMethod select_method, [[maybe_unused]] ViewportDragDropSelectionProcess select_proc, [[maybe_unused]] Point pt) {}
 
  virtual void OnPlaceMouseUp([[maybe_unused]] ViewportPlaceMethod select_method, [[maybe_unused]] ViewportDragDropSelectionProcess select_proc, [[maybe_unused]] Point pt, [[maybe_unused]] TileIndex start_tile, [[maybe_unused]] TileIndex end_tile) {}
 
  virtual void OnPlacePresize([[maybe_unused]] Point pt, [[maybe_unused]] TileIndex tile) {}
 
  /*** End of the event handling ***/
 
  virtual bool IsNewGRFInspectable() const { return false; }
 
  virtual void ShowNewGRFInspectWindow() const { NOT_REACHED(); }
 
  template <bool TtoBack>
  struct WindowIterator {
    typedef Window *value_type;
    typedef value_type *pointer;
    typedef value_type &reference;
    typedef size_t difference_type;
    typedef std::forward_iterator_tag iterator_category;
 
    explicit WindowIterator(WindowList::iterator start) : it(start)
    {
      this->Validate();
    }
    explicit WindowIterator(const Window *w) : it(w->z_position) {}
 
    bool operator==(const WindowIterator &other) const { return this->it == other.it; }
    Window * operator*() const { return *this->it; }
    WindowIterator & operator++() { this->Next(); this->Validate(); return *this; }
 
    bool IsEnd() const { return this->it == _z_windows.end(); }
 
  private:
    WindowList::iterator it;
    void Validate()
    {
      while (!this->IsEnd() && *this->it == nullptr) this->Next();
    }
    void Next()
    {
      if constexpr (!TtoBack) {
        ++this->it;
      } else if (this->it == _z_windows.begin()) {
        this->it = _z_windows.end();
      } else {
        --this->it;
      }
    }
  };
  using IteratorToFront = WindowIterator<false>; 
  using IteratorToBack = WindowIterator<true>; 
 
  template <bool Tfront>
  struct AllWindows {
    AllWindows() {}
    WindowIterator<Tfront> begin()
    {
      if constexpr (Tfront) {
        auto back = _z_windows.end();
        if (back != _z_windows.begin()) --back;
        return WindowIterator<Tfront>(back);
      } else {
        return WindowIterator<Tfront>(_z_windows.begin());
      }
    }
    WindowIterator<Tfront> end() { return WindowIterator<Tfront>(_z_windows.end()); }
  };
  using Iterate = AllWindows<false>; 
  using IterateFromBack = AllWindows<false>; 
  using IterateFromFront = AllWindows<true>; 
};
 
template <class It, class Pred>
inline bool AllEqual(It begin, It end, Pred pred)
{
  return std::adjacent_find(begin, end, std::not_fn(pred)) == end;
}
 
template <class NWID>
inline NWID *Window::GetWidget(WidgetID widnum)
{
  auto it = this->widget_lookup.find(widnum);
  if (it == std::end(this->widget_lookup)) return nullptr;
  NWID *nwid = dynamic_cast<NWID *>(it->second);
  assert(nwid != nullptr);
  return nwid;
}
 
template <>
inline const NWidgetBase *Window::GetWidget<NWidgetBase>(WidgetID widnum) const
{
  auto it = this->widget_lookup.find(widnum);
  if (it == std::end(this->widget_lookup)) return nullptr;
  return it->second;
}
 
template <class NWID>
inline const NWID *Window::GetWidget(WidgetID widnum) const
{
  return const_cast<Window *>(this)->GetWidget<NWID>(widnum);
}
 
 
class PickerWindowBase : public Window {
 
public:
  PickerWindowBase(WindowDesc &desc, Window *parent) : Window(desc)
  {
    this->parent = parent;
  }
 
  void Close([[maybe_unused]] int data = 0) override;
};
 
Window *BringWindowToFrontById(WindowClass cls, WindowNumber number);
Window *FindWindowFromPt(int x, int y);
 
template <typename Twindow, bool Treturn_existing = false, typename... Targs>
Twindow *AllocateWindowDescFront(WindowDesc &desc, WindowNumber window_number, Targs... extra_arguments)
{
  Twindow *w = static_cast<Twindow *>(BringWindowToFrontById(desc.cls, window_number));
  if (w != nullptr) return Treturn_existing ? w : nullptr;
  return new Twindow(desc, window_number, std::forward<Targs>(extra_arguments)...);
}
 
void RelocateAllWindows(int neww, int newh);
 
void GuiShowTooltips(Window *parent, EncodedString &&text, TooltipCloseCondition close_tooltip);
 
/* widget.cpp */
WidgetID GetWidgetFromPos(const Window *w, int x, int y);
 
extern Point _cursorpos_drag_start;
 
extern int _scrollbar_start_pos;
extern int _scrollbar_size;
extern uint8_t _scroller_click_timeout;
 
extern bool _scrolling_viewport;
extern bool _mouse_hovering;
 
enum SpecialMouseMode : uint8_t {
  WSM_NONE,     
  WSM_DRAGDROP, 
  WSM_SIZING,   
  WSM_PRESIZE,  
  WSM_DRAGGING, 
};
extern SpecialMouseMode _special_mouse_mode;
 
void SetFocusedWindow(Window *w);
 
void ScrollbarClickHandler(Window *w, NWidgetCore *nw, int x, int y);
Rect ScrollRect(Rect r, const Scrollbar &sb, int resize_step = 1);
 
#endif /* WINDOW_GUI_H */