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 <list>
#include <algorithm>
#include <functional>
 
#include "vehiclelist.h"
#include "vehicle_type.h"
#include "viewport_type.h"
#include "company_type.h"
#include "tile_type.h"
#include "widget_type.h"
#include "core/smallvec_type.hpp"
#include "core/smallmap_type.hpp"
#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)
 
struct WidgetDimensions {
  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 modalpopup;   
 
  int pressed;              
  int vsep_normal;          
  int vsep_wide;            
  int hsep_normal;          
  int hsep_wide;            
  int hsep_indent;          
 
  static const WidgetDimensions unscaled; 
  static WidgetDimensions scaled;         
};
 
/* widget.cpp */
void DrawFrameRect(int left, int top, int right, int bottom, Colours colour, FrameFlags flags);
 
static 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);
 
/* 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(WindowPosition default_pos, const char *ini_key, int16 def_width_trad, int16 def_height_trad,
      WindowClass window_class, WindowClass parent_class, uint32 flags,
      const NWidgetPart *nwid_parts, int16 nwid_length, HotkeyList *hotkeys = nullptr);
 
  ~WindowDesc();
 
  WindowPosition default_pos;    
  WindowClass cls;               
  WindowClass parent_cls;        
  const char *ini_key;           
  uint32 flags;                  
  const NWidgetPart *nwid_parts; 
  int16 nwid_length;             
  HotkeyList *hotkeys;           
 
  bool pref_sticky;              
  int16 pref_width;              
  int16 pref_height;             
 
  int16 GetDefaultWidth() const;
  int16 GetDefaultHeight() const;
 
  static void LoadFromConfig();
  static void SaveToConfig();
 
private:
  int16 default_width_trad;      
  int16 default_height_trad;     
 
  WindowDesc(const WindowDesc &other);
};
 
enum WindowDefaultFlag {
  WDF_CONSTRUCTION    =   1 << 0, 
  WDF_MODAL           =   1 << 1, 
  WDF_NO_FOCUS        =   1 << 2, 
};
 
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 scrollpos_x;        
  int32 scrollpos_y;        
  int32 dest_scrollpos_x;   
  int32 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;  
 
  /* 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; 
 
  uint8 timeout_timer;      
  uint8 white_border_timer; 
 
  int left;   
  int top;    
  int width;  
  int height; 
 
  ResizeInfo resize;  
 
  Owner owner;        
 
  ViewportData *viewport;          
  const NWidgetCore *nested_focus; 
  SmallMap<int, QueryString*> querystrings; 
  NWidgetBase *nested_root;        
  NWidgetBase **nested_array;      
  uint nested_array_size;          
  NWidgetStacked *shade_select;    
  Dimension unshaded_size;         
 
  int mouse_capture_widget;        
 
  Window *parent;                  
  WindowList::iterator z_position;
 
  template <class NWID>
  inline const NWID *GetWidget(uint widnum) const;
  template <class NWID>
  inline NWID *GetWidget(uint widnum);
 
  const Scrollbar *GetScrollbar(uint widnum) const;
  Scrollbar *GetScrollbar(uint widnum);
 
  const QueryString *GetQueryString(uint widnum) const;
  QueryString *GetQueryString(uint widnum);
  void UpdateQueryStringSize();
 
  virtual const char *GetFocusedText() const;
  virtual const char *GetCaret() const;
  virtual const char *GetMarkedText(size_t *length) const;
  virtual Point GetCaretPosition() const;
  virtual Rect GetTextBoundingRect(const char *from, const char *to) const;
  virtual const char *GetTextCharacterAtPosition(const Point &pt) const;
 
  void InitNested(WindowNumber number = 0);
  void CreateNestedTree(bool fill_nested = true);
  void FinishInitNested(WindowNumber window_number = 0);
 
  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(byte widget_index, TextColour highlighted_colour);
  bool IsWidgetHighlighted(byte widget_index) const;
 
  inline void SetWidgetDisabledState(byte widget_index, bool disab_stat)
  {
    assert(widget_index < this->nested_array_size);
    if (this->nested_array[widget_index] != nullptr) this->GetWidget<NWidgetCore>(widget_index)->SetDisabled(disab_stat);
  }
 
  inline void DisableWidget(byte widget_index)
  {
    SetWidgetDisabledState(widget_index, true);
  }
 
  inline void EnableWidget(byte widget_index)
  {
    SetWidgetDisabledState(widget_index, false);
  }
 
  inline bool IsWidgetDisabled(byte widget_index) const
  {
    assert(widget_index < this->nested_array_size);
    return this->GetWidget<NWidgetCore>(widget_index)->IsDisabled();
  }
 
  inline bool IsWidgetFocused(byte widget_index) const
  {
    return this->nested_focus != nullptr && this->nested_focus->index == widget_index;
  }
 
  inline bool IsWidgetGloballyFocused(byte widget_index) const
  {
    return _focused_window == this && IsWidgetFocused(widget_index);
  }
 
  inline void SetWidgetLoweredState(byte widget_index, bool lowered_stat)
  {
    assert(widget_index < this->nested_array_size);
    this->GetWidget<NWidgetCore>(widget_index)->SetLowered(lowered_stat);
  }
 
  inline void ToggleWidgetLoweredState(byte widget_index)
  {
    assert(widget_index < this->nested_array_size);
    bool lowered_state = this->GetWidget<NWidgetCore>(widget_index)->IsLowered();
    this->GetWidget<NWidgetCore>(widget_index)->SetLowered(!lowered_state);
  }
 
  inline void LowerWidget(byte widget_index)
  {
    SetWidgetLoweredState(widget_index, true);
  }
 
  inline void RaiseWidget(byte widget_index)
  {
    SetWidgetLoweredState(widget_index, false);
  }
 
  inline bool IsWidgetLowered(byte widget_index) const
  {
    assert(widget_index < this->nested_array_size);
    return this->GetWidget<NWidgetCore>(widget_index)->IsLowered();
  }
 
  void UnfocusFocusedWidget();
  bool SetFocusedWidget(int widget_index);
 
  EventState HandleEditBoxKey(int wid, WChar key, uint16 keycode);
  virtual void InsertTextString(int wid, const char *str, bool marked, const char *caret, const char *insert_location, const char *replacement_end);
 
  void HandleButtonClick(byte widget);
  int GetRowFromWidget(int clickpos, int widget, int padding, int line_height = -1) const;
 
  void RaiseButtons(bool autoraise = false);
  void CDECL SetWidgetsDisabledState(bool disab_stat, int widgets, ...);
  void CDECL SetWidgetsLoweredState(bool lowered_stat, int widgets, ...);
  void SetWidgetDirty(byte widget_index) const;
 
  void DrawWidgets() const;
  void DrawViewport() const;
  void DrawSortButtonState(int widget, SortButtonState state) const;
  static int SortButtonWidth();
 
  void CloseChildWindows(WindowClass wc = WC_INVALID) const;
  virtual void Close();
  static void DeleteClosedWindows();
 
  void SetDirty() const;
  void ReInit(int rx = 0, int ry = 0);
 
  inline bool IsShaded() const
  {
    return this->shade_select != nullptr && this->shade_select->shown_plane == SZSP_HORIZONTAL;
  }
 
  void SetShaded(bool make_shaded);
 
  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 sm_width, int16 sm_height, int window_number);
 
  virtual void OnPaint()
  {
    this->DrawWidgets();
  }
 
  virtual void DrawWidget(const Rect &r, int widget) const {}
 
  virtual void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize) {}
 
  virtual void SetStringParameters(int widget) const {}
 
  virtual void OnFocus();
 
  virtual void OnFocusLost();
 
  virtual EventState OnKeyPress(WChar key, uint16 keycode) { return ES_NOT_HANDLED; }
 
  virtual EventState OnHotkey(int hotkey);
 
  virtual EventState OnCTRLStateChange() { return ES_NOT_HANDLED; }
 
 
  virtual void OnClick(Point pt, int widget, int click_count) {}
 
  virtual bool OnRightClick(Point pt, int widget) { return false; }
 
  virtual void OnHover(Point pt, int widget) {}
 
  virtual bool OnTooltip(Point pt, int widget, TooltipCloseCondition close_cond) { return false; }
 
  virtual void OnMouseDrag(Point pt, int widget) {}
 
  virtual void OnDragDrop(Point pt, int widget) {}
 
  virtual void OnScroll(Point delta) {}
 
  virtual void OnMouseOver(Point pt, int widget) {}
 
  virtual void OnMouseWheel(int wheel) {}
 
 
  virtual void OnMouseLoop() {}
 
  virtual void OnGameTick() {}
 
  virtual void OnHundredthTick() {}
 
  virtual void OnRealtimeTick(uint delta_ms) {}
 
  virtual void OnTimeout() {}
 
 
  virtual void OnResize() {}
 
  virtual void OnDropdownSelect(int widget, int index) {}
 
  virtual void OnDropdownClose(Point pt, int widget, int index, bool instant_close);
 
  virtual void OnEditboxChanged(int widget) {}
 
  virtual void OnQueryTextFinished(char *str) {}
 
  virtual void OnInvalidateData(int data = 0, bool gui_scope = true) {}
 
  virtual void OnPlaceObject(Point pt, TileIndex tile) {}
 
  virtual bool OnVehicleSelect(const struct Vehicle *v) { return false; }
 
  virtual bool OnVehicleSelect(VehicleList::const_iterator begin, VehicleList::const_iterator end) { return false; }
 
  virtual void OnPlaceObjectAbort() {}
 
 
  virtual void OnPlaceDrag(ViewportPlaceMethod select_method, ViewportDragDropSelectionProcess select_proc, Point pt) {}
 
  virtual void OnPlaceMouseUp(ViewportPlaceMethod select_method, ViewportDragDropSelectionProcess select_proc, Point pt, TileIndex start_tile, TileIndex end_tile) {}
 
  virtual void OnPlacePresize(Point pt, 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(uint widnum)
{
  if (widnum >= this->nested_array_size || this->nested_array[widnum] == nullptr) return nullptr;
  NWID *nwid = dynamic_cast<NWID *>(this->nested_array[widnum]);
  assert(nwid != nullptr);
  return nwid;
}
 
template <>
inline const NWidgetBase *Window::GetWidget<NWidgetBase>(uint widnum) const
{
  if (widnum >= this->nested_array_size) return nullptr;
  return this->nested_array[widnum];
}
 
template <class NWID>
inline const NWID *Window::GetWidget(uint 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() override;
};
 
Window *BringWindowToFrontById(WindowClass cls, WindowNumber number);
Window *FindWindowFromPt(int x, int y);
 
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, uint paramcount = 0, const uint64 params[] = nullptr, TooltipCloseCondition close_tooltip = TCC_HOVER);
 
/* widget.cpp */
int 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 */