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 FrameFlags {
  FR_NONE         =  0,
  FR_TRANSPARENT  =  1 << 0,  
  FR_BORDERONLY   =  1 << 4,  
  FR_LOWERED      =  1 << 5,  
  FR_DARKENED     =  1 << 6,  
};
 
DECLARE_ENUM_AS_BIT_SET(FrameFlags)
 
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;         
 
private:
  enum WidgetDrawDistances {
    WD_SHADEBOX_WIDTH   = 12, 
    WD_STICKYBOX_WIDTH  = 12, 
    WD_DEBUGBOX_WIDTH   = 12, 
    WD_DEFSIZEBOX_WIDTH = 12, 
    WD_RESIZEBOX_WIDTH  = 12, 
    WD_CLOSEBOX_WIDTH   = 11, 
 
    WD_CAPTION_HEIGHT   = 14, 
    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, StringID str, StringAlignment align, FontSize fs);
 
/* window.cpp */
using WindowList = std::list<Window *>;
extern WindowList _z_windows;
extern Window *_focused_window;
 
 
enum WindowPosition {
  WDP_MANUAL,        
  WDP_AUTO,          
  WDP_CENTER,        
  WDP_ALIGN_TOOLBAR, 
};
 
Point GetToolbarAlignedWindowPosition(int window_width);
 
struct HotkeyList;
 
struct WindowDesc : ZeroedMemoryAllocator {
 
  WindowDesc(const char * const file, const int line, WindowPosition default_pos, const char *ini_key, int16_t def_width_trad, int16_t def_height_trad,
      WindowClass window_class, WindowClass parent_class, uint32_t flags,
      const NWidgetPart *nwid_begin, const NWidgetPart *nwid_end, HotkeyList *hotkeys = nullptr);
 
  ~WindowDesc();
 
  const char * const file; 
  const int line; 
  WindowPosition default_pos;    
  WindowClass cls;               
  WindowClass parent_cls;        
  const char *ini_key;           
  uint32_t flags;                  
  const NWidgetPart *nwid_begin; 
  const NWidgetPart *nwid_end; 
  HotkeyList *hotkeys;           
 
  bool pref_sticky;              
  int16_t pref_width;              
  int16_t pref_height;             
 
  int16_t GetDefaultWidth() const;
  int16_t GetDefaultHeight() const;
 
  static void LoadFromConfig();
  static void SaveToConfig();
 
private:
  int16_t default_width_trad;      
  int16_t default_height_trad;     
 
  WindowDesc(const WindowDesc &other);
};
 
enum WindowDefaultFlag {
  WDF_CONSTRUCTION    =   1 << 0, 
  WDF_MODAL           =   1 << 1, 
  WDF_NO_FOCUS        =   1 << 2, 
  WDF_NO_CLOSE        =   1 << 3, 
};
 
struct ResizeInfo {
  uint step_width;  
  uint step_height; 
};
 
enum SortButtonState {
  SBS_OFF,  
  SBS_DOWN, 
  SBS_UP,   
};
 
enum WindowFlags {
  WF_TIMEOUT           = 1 <<  0, 
 
  WF_DRAGGING          = 1 <<  3, 
  WF_SIZING_RIGHT      = 1 <<  4, 
  WF_SIZING_LEFT       = 1 <<  5, 
  WF_SIZING            = WF_SIZING_RIGHT | WF_SIZING_LEFT, 
  WF_STICKY            = 1 <<  6, 
  WF_DISABLE_VP_SCROLL = 1 <<  7, 
  WF_WHITE_BORDER      = 1 <<  8, 
  WF_HIGHLIGHTED       = 1 <<  9, 
  WF_CENTERED          = 1 << 10, 
};
DECLARE_ENUM_AS_BIT_SET(WindowFlags)
 
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;   
};
 
struct QueryString;
 
/* misc_gui.cpp */
enum TooltipCloseCondition {
  TCC_RIGHT_CLICK,
  TCC_HOVER,
  TCC_NONE,
  TCC_EXIT_VIEWPORT,
};
 
struct Window : ZeroedMemoryAllocator {
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; 
 
  /* 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; 
 
  int scale; 
 
  uint8_t timeout_timer;      
  uint8_t white_border_timer; 
 
  int left;   
  int top;    
  int width;  
  int height; 
 
  ResizeInfo resize;  
 
  Owner owner;        
 
  ViewportData *viewport;          
  const NWidgetCore *nested_focus; 
  std::map<WidgetID, QueryString*> querystrings; 
  std::unique_ptr<NWidgetBase> nested_root; 
  WidgetLookup widget_lookup; 
  NWidgetStacked *shade_select;    
  Dimension unshaded_size;         
 
  WidgetID mouse_capture_widget;   
 
  Window *parent;                  
  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);
 
  template<typename T, std::enable_if_t<std::is_base_of<StrongTypedefBase, T>::value, int> = 0>
  void FinishInitNested(T number)
  {
    this->FinishInitNested(number.base());
  }
 
  inline void SetTimeout()
  {
    this->flags |= WF_TIMEOUT;
    this->timeout_timer = TIMEOUT_DURATION;
  }
 
  inline void SetWhiteBorder()
  {
    this->flags |= WF_WHITE_BORDER;
    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->index == 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(byte 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();
 
  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 void SetStringParameters([[maybe_unused]] WidgetID widget) 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]] char *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; }
    bool operator!=(const WindowIterator &other) const { return !(*this == other); }
    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 T, std::enable_if_t<std::is_base_of<StrongTypedefBase, T>::value, int> = 0>
Window *BringWindowToFrontById(WindowClass cls, T number)
{
  return BringWindowToFrontById(cls, number.base());
}
 
template <typename Wcls>
Wcls *AllocateWindowDescFront(WindowDesc *desc, int window_number, bool return_existing = false)
{
  Wcls *w = static_cast<Wcls *>(BringWindowToFrontById(desc->cls, window_number));
  if (w != nullptr) return return_existing ? w : nullptr;
  return new Wcls(desc, window_number);
}
 
void RelocateAllWindows(int neww, int newh);
 
void GuiShowTooltips(Window *parent, StringID str, TooltipCloseCondition close_tooltip, uint paramcount = 0);
 
/* 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 byte _scroller_click_timeout;
 
extern bool _scrolling_viewport;
extern bool _mouse_hovering;
 
enum SpecialMouseMode {
  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);
 
#endif /* WINDOW_GUI_H */