widget_type.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 WIDGET_TYPE_H
#define WIDGET_TYPE_H
 
#include "core/alloc_type.hpp"
#include "core/bitmath_func.hpp"
#include "core/math_func.hpp"
#include "strings_type.h"
#include "gfx_type.h"
#include "window_type.h"
 
static const int WIDGET_LIST_END = -1; 
 
enum MatrixWidgetValues {
  /* Number of column bits of the WWT_MATRIX widget data. */
  MAT_COL_START = 0, 
  MAT_COL_BITS  = 8, 
 
  /* Number of row bits of the WWT_MATRIX widget data. */
  MAT_ROW_START = 8, 
  MAT_ROW_BITS  = 8, 
};
 
enum ArrowWidgetValues {
  AWV_DECREASE, 
  AWV_INCREASE, 
  AWV_LEFT,     
  AWV_RIGHT,    
};
 
enum WidgetType {
  /* Window widget types. */
  WWT_EMPTY,      
 
  WWT_PANEL,      
  WWT_INSET,      
  WWT_IMGBTN,     
  WWT_IMGBTN_2,   
  WWT_ARROWBTN,   
  WWT_TEXTBTN,    
  WWT_TEXTBTN_2,  
  WWT_LABEL,      
  WWT_TEXT,       
  WWT_MATRIX,     
  WWT_FRAME,      
  WWT_CAPTION,    
 
  WWT_DEBUGBOX,   
  WWT_SHADEBOX,   
  WWT_DEFSIZEBOX, 
  WWT_STICKYBOX,  
 
  WWT_RESIZEBOX,  
  WWT_CLOSEBOX,   
  WWT_DROPDOWN,   
  WWT_EDITBOX,    
  WWT_LAST,       
 
  /* Nested widget types. */
  NWID_HORIZONTAL,      
  NWID_HORIZONTAL_LTR,  
  NWID_VERTICAL,        
  NWID_MATRIX,          
  NWID_SPACER,          
  NWID_SELECTION,       
  NWID_VIEWPORT,        
  NWID_BUTTON_DROPDOWN, 
  NWID_HSCROLLBAR,      
  NWID_VSCROLLBAR,      
 
  /* Nested widget part types. */
  WPT_RESIZE,       
  WPT_MINSIZE,      
  WPT_MINTEXTLINES, 
  WPT_FILL,         
  WPT_DATATIP,      
  WPT_PADDING,      
  WPT_PIPSPACE,     
  WPT_TEXTCOLOUR,   
  WPT_ALIGNMENT,    
  WPT_ENDCONTAINER, 
  WPT_FUNCTION,     
  WPT_SCROLLBAR,    
 
  /* Pushable window widget types. */
  WWT_MASK = 0x7F,
 
  WWB_PUSHBUTTON    = 1 << 7,
 
  WWT_PUSHBTN       = WWT_PANEL    | WWB_PUSHBUTTON,    
  WWT_PUSHTXTBTN    = WWT_TEXTBTN  | WWB_PUSHBUTTON,    
  WWT_PUSHIMGBTN    = WWT_IMGBTN   | WWB_PUSHBUTTON,    
  WWT_PUSHARROWBTN  = WWT_ARROWBTN | WWB_PUSHBUTTON,    
  NWID_PUSHBUTTON_DROPDOWN = NWID_BUTTON_DROPDOWN | WWB_PUSHBUTTON,
};
 
enum SizingType {
  ST_SMALLEST, 
  ST_RESIZE,   
};
 
/* Forward declarations. */
class NWidgetCore;
class Scrollbar;
 
class NWidgetBase : public ZeroedMemoryAllocator {
public:
  NWidgetBase(WidgetType tp);
 
  virtual void AdjustPaddingForZoom();
  virtual void SetupSmallestSize(Window *w, bool init_array) = 0;
  virtual void AssignSizePosition(SizingType sizing, uint x, uint y, uint given_width, uint given_height, bool rtl) = 0;
 
  virtual void FillNestedArray(NWidgetBase **array, uint length) = 0;
 
  virtual NWidgetCore *GetWidgetFromPos(int x, int y) = 0;
  virtual NWidgetBase *GetWidgetOfType(WidgetType tp);
 
  virtual bool IsHighlighted() const { return false; }
  virtual TextColour GetHighlightColour() const { return TC_INVALID; }
  virtual void SetHighlighted(TextColour highlight_colour) {}
 
  inline void SetPadding(uint8 top, uint8 right, uint8 bottom, uint8 left)
  {
    this->uz_padding.top = top;
    this->uz_padding.right = right;
    this->uz_padding.bottom = bottom;
    this->uz_padding.left = left;
    this->AdjustPaddingForZoom();
  }
 
  inline void SetPadding(const RectPadding &padding)
  {
    this->uz_padding = padding;
    this->AdjustPaddingForZoom();
  }
 
  inline uint GetHorizontalStepSize(SizingType sizing) const;
  inline uint GetVerticalStepSize(SizingType sizing) const;
 
  virtual void Draw(const Window *w) = 0;
  virtual void SetDirty(const Window *w) const;
 
  Rect GetCurrentRect() const
  {
    Rect r;
    r.left = this->pos_x;
    r.top = this->pos_y;
    r.right = this->pos_x + this->current_x - 1;
    r.bottom = this->pos_y + this->current_y - 1;
    return r;
  }
 
  WidgetType type;      
  uint fill_x;          
  uint fill_y;          
  uint resize_x;        
  uint resize_y;        
  /* Size of the widget in the smallest window possible.
   * Computed by #SetupSmallestSize() followed by #AssignSizePosition().
   */
  uint smallest_x;      
  uint smallest_y;      
  /* Current widget size (that is, after resizing). */
  uint current_x;       
  uint current_y;       
 
  int pos_x;            
  int pos_y;            
 
  NWidgetBase *next;    
  NWidgetBase *prev;    
 
  RectPadding padding;    
  RectPadding uz_padding; 
 
protected:
  inline void StoreSizePosition(SizingType sizing, uint x, uint y, uint given_width, uint given_height);
};
 
inline uint NWidgetBase::GetHorizontalStepSize(SizingType sizing) const
{
  return (sizing == ST_RESIZE) ? this->resize_x : this->fill_x;
}
 
inline uint NWidgetBase::GetVerticalStepSize(SizingType sizing) const
{
  return (sizing == ST_RESIZE) ? this->resize_y : this->fill_y;
}
 
inline void NWidgetBase::StoreSizePosition(SizingType sizing, uint x, uint y, uint given_width, uint given_height)
{
  this->pos_x = x;
  this->pos_y = y;
  if (sizing == ST_SMALLEST) {
    this->smallest_x = given_width;
    this->smallest_y = given_height;
  }
  this->current_x = given_width;
  this->current_y = given_height;
}
 
 
class NWidgetResizeBase : public NWidgetBase {
public:
  NWidgetResizeBase(WidgetType tp, uint fill_x, uint fill_y);
 
  void AdjustPaddingForZoom() override;
  void SetMinimalSize(uint min_x, uint min_y);
  void SetMinimalSizeAbsolute(uint min_x, uint min_y);
  void SetMinimalTextLines(uint8 min_lines, uint8 spacing, FontSize size);
  void SetFill(uint fill_x, uint fill_y);
  void SetResize(uint resize_x, uint resize_y);
 
  void AssignSizePosition(SizingType sizing, uint x, uint y, uint given_width, uint given_height, bool rtl) override;
 
  uint min_x; 
  uint min_y; 
 
  bool absolute; 
  uint uz_min_x; 
  uint uz_min_y; 
 
  uint8 uz_text_lines;   
  uint8 uz_text_spacing; 
  FontSize uz_text_size; 
};
 
enum NWidgetDisplay {
  /* Generic. */
  NDB_LOWERED         = 0, 
  NDB_DISABLED        = 1, 
  /* Viewport widget. */
  NDB_NO_TRANSPARENCY = 2, 
  NDB_SHADE_GREY      = 3, 
  NDB_SHADE_DIMMED    = 4, 
  /* Button dropdown widget. */
  NDB_DROPDOWN_ACTIVE = 5, 
  /* Scrollbar widget. */
  NDB_SCROLLBAR_UP    = 6, 
  NDB_SCROLLBAR_DOWN  = 7, 
  /* Generic. */
  NDB_HIGHLIGHT       = 8, 
 
  ND_LOWERED  = 1 << NDB_LOWERED,                
  ND_DISABLED = 1 << NDB_DISABLED,               
  ND_HIGHLIGHT = 1 << NDB_HIGHLIGHT,             
  ND_NO_TRANSPARENCY = 1 << NDB_NO_TRANSPARENCY, 
  ND_SHADE_GREY      = 1 << NDB_SHADE_GREY,      
  ND_SHADE_DIMMED    = 1 << NDB_SHADE_DIMMED,    
  ND_DROPDOWN_ACTIVE = 1 << NDB_DROPDOWN_ACTIVE, 
  ND_SCROLLBAR_UP    = 1 << NDB_SCROLLBAR_UP,    
  ND_SCROLLBAR_DOWN  = 1 << NDB_SCROLLBAR_DOWN,  
  ND_SCROLLBAR_BTN   = ND_SCROLLBAR_UP | ND_SCROLLBAR_DOWN, 
};
DECLARE_ENUM_AS_BIT_SET(NWidgetDisplay)
 
 
class NWidgetCore : public NWidgetResizeBase {
public:
  NWidgetCore(WidgetType tp, Colours colour, uint fill_x, uint fill_y, uint32 widget_data, StringID tool_tip);
 
  void SetIndex(int index);
  void SetDataTip(uint32 widget_data, StringID tool_tip);
  void SetToolTip(StringID tool_tip);
  void SetTextColour(TextColour colour);
  void SetAlignment(StringAlignment align);
 
  inline void SetLowered(bool lowered);
  inline bool IsLowered() const;
  inline void SetDisabled(bool disabled);
  inline bool IsDisabled() const;
 
  void FillNestedArray(NWidgetBase **array, uint length) override;
  NWidgetCore *GetWidgetFromPos(int x, int y) override;
  bool IsHighlighted() const override;
  TextColour GetHighlightColour() const override;
  void SetHighlighted(TextColour highlight_colour) override;
 
  NWidgetDisplay disp_flags; 
  Colours colour;            
  int index;                 
  uint32 widget_data;        
  StringID tool_tip;         
  int scrollbar_index;       
  TextColour highlight_colour; 
  TextColour text_colour;    
  StringAlignment align;     
};
 
inline void NWidgetCore::SetHighlighted(TextColour highlight_colour)
{
  this->disp_flags = highlight_colour != TC_INVALID ? SETBITS(this->disp_flags, ND_HIGHLIGHT) : CLRBITS(this->disp_flags, ND_HIGHLIGHT);
  this->highlight_colour = highlight_colour;
}
 
inline bool NWidgetCore::IsHighlighted() const
{
  return HasBit(this->disp_flags, NDB_HIGHLIGHT);
}
 
inline TextColour NWidgetCore::GetHighlightColour() const
{
  return this->highlight_colour;
}
 
inline void NWidgetCore::SetLowered(bool lowered)
{
  this->disp_flags = lowered ? SETBITS(this->disp_flags, ND_LOWERED) : CLRBITS(this->disp_flags, ND_LOWERED);
}
 
inline bool NWidgetCore::IsLowered() const
{
  return HasBit(this->disp_flags, NDB_LOWERED);
}
 
inline void NWidgetCore::SetDisabled(bool disabled)
{
  this->disp_flags = disabled ? SETBITS(this->disp_flags, ND_DISABLED) : CLRBITS(this->disp_flags, ND_DISABLED);
}
 
inline bool NWidgetCore::IsDisabled() const
{
  return HasBit(this->disp_flags, NDB_DISABLED);
}
 
 
class NWidgetContainer : public NWidgetBase {
public:
  NWidgetContainer(WidgetType tp);
  ~NWidgetContainer();
 
  void AdjustPaddingForZoom() override;
  void Add(NWidgetBase *wid);
  void FillNestedArray(NWidgetBase **array, uint length) override;
 
  inline bool IsEmpty() { return head == nullptr; }
 
  NWidgetBase *GetWidgetOfType(WidgetType tp) override;
 
protected:
  NWidgetBase *head; 
  NWidgetBase *tail; 
};
 
enum StackedZeroSizePlanes {
  SZSP_VERTICAL = INT_MAX / 2, 
  SZSP_HORIZONTAL,             
  SZSP_NONE,                   
 
  SZSP_BEGIN = SZSP_VERTICAL,  
};
 
class NWidgetStacked : public NWidgetContainer {
public:
  NWidgetStacked();
 
  void SetIndex(int index);
 
  void AdjustPaddingForZoom() override;
  void SetupSmallestSize(Window *w, bool init_array) override;
  void AssignSizePosition(SizingType sizing, uint x, uint y, uint given_width, uint given_height, bool rtl) override;
  void FillNestedArray(NWidgetBase **array, uint length) override;
 
  void Draw(const Window *w) override;
  NWidgetCore *GetWidgetFromPos(int x, int y) override;
 
  void SetDisplayedPlane(int plane);
 
  int shown_plane; 
  int index;       
};
 
enum NWidContainerFlags {
  NCB_EQUALSIZE = 0, 
  NCB_BIGFIRST  = 1, 
 
  NC_NONE = 0,                       
  NC_EQUALSIZE = 1 << NCB_EQUALSIZE, 
  NC_BIGFIRST  = 1 << NCB_BIGFIRST,  
};
DECLARE_ENUM_AS_BIT_SET(NWidContainerFlags)
 
 
class NWidgetPIPContainer : public NWidgetContainer {
public:
  NWidgetPIPContainer(WidgetType tp, NWidContainerFlags flags = NC_NONE);
 
  void AdjustPaddingForZoom() override;
  void SetPIP(uint8 pip_pre, uint8 pip_inter, uint8 pip_post);
 
  void Draw(const Window *w) override;
  NWidgetCore *GetWidgetFromPos(int x, int y) override;
 
protected:
  NWidContainerFlags flags; 
  uint8 pip_pre;            
  uint8 pip_inter;          
  uint8 pip_post;           
 
  uint8 uz_pip_pre;         
  uint8 uz_pip_inter;       
  uint8 uz_pip_post;        
};
 
class NWidgetHorizontal : public NWidgetPIPContainer {
public:
  NWidgetHorizontal(NWidContainerFlags flags = NC_NONE);
 
  void SetupSmallestSize(Window *w, bool init_array) override;
  void AssignSizePosition(SizingType sizing, uint x, uint y, uint given_width, uint given_height, bool rtl) override;
};
 
class NWidgetHorizontalLTR : public NWidgetHorizontal {
public:
  NWidgetHorizontalLTR(NWidContainerFlags flags = NC_NONE);
 
  void AssignSizePosition(SizingType sizing, uint x, uint y, uint given_width, uint given_height, bool rtl) override;
};
 
class NWidgetVertical : public NWidgetPIPContainer {
public:
  NWidgetVertical(NWidContainerFlags flags = NC_NONE);
 
  void SetupSmallestSize(Window *w, bool init_array) override;
  void AssignSizePosition(SizingType sizing, uint x, uint y, uint given_width, uint given_height, bool rtl) override;
};
 
class NWidgetMatrix : public NWidgetPIPContainer {
public:
  NWidgetMatrix();
 
  void SetIndex(int index);
  void SetColour(Colours colour);
  void SetClicked(int clicked);
  void SetCount(int count);
  void SetScrollbar(Scrollbar *sb);
 
  void SetupSmallestSize(Window *w, bool init_array) override;
  void AssignSizePosition(SizingType sizing, uint x, uint y, uint given_width, uint given_height, bool rtl) override;
  void FillNestedArray(NWidgetBase **array, uint length) override;
 
  NWidgetCore *GetWidgetFromPos(int x, int y) override;
  void Draw(const Window *w) override;
protected:
  int index;      
  Colours colour; 
  int clicked;    
  int count;      
  Scrollbar *sb;  
private:
  int widget_w;   
  int widget_h;   
  int widgets_x;  
  int widgets_y;  
 
  void GetScrollOffsets(int &start_x, int &start_y, int &base_offs_x, int &base_offs_y);
};
 
 
class NWidgetSpacer : public NWidgetResizeBase {
public:
  NWidgetSpacer(int width, int height);
 
  void SetupSmallestSize(Window *w, bool init_array) override;
  void FillNestedArray(NWidgetBase **array, uint length) override;
 
  void Draw(const Window *w) override;
  void SetDirty(const Window *w) const override;
  NWidgetCore *GetWidgetFromPos(int x, int y) override;
};
 
class NWidgetBackground : public NWidgetCore {
public:
  NWidgetBackground(WidgetType tp, Colours colour, int index, NWidgetPIPContainer *child = nullptr);
  ~NWidgetBackground();
 
  void Add(NWidgetBase *nwid);
  void SetPIP(uint8 pip_pre, uint8 pip_inter, uint8 pip_post);
 
  void AdjustPaddingForZoom() override;
  void SetupSmallestSize(Window *w, bool init_array) override;
  void AssignSizePosition(SizingType sizing, uint x, uint y, uint given_width, uint given_height, bool rtl) override;
 
  void FillNestedArray(NWidgetBase **array, uint length) override;
 
  void Draw(const Window *w) override;
  NWidgetCore *GetWidgetFromPos(int x, int y) override;
  NWidgetBase *GetWidgetOfType(WidgetType tp) override;
 
private:
  NWidgetPIPContainer *child; 
};
 
class NWidgetViewport : public NWidgetCore {
public:
  NWidgetViewport(int index);
 
  void SetupSmallestSize(Window *w, bool init_array) override;
  void Draw(const Window *w) override;
 
  void InitializeViewport(Window *w, uint32 follow_flags, ZoomLevel zoom);
  void UpdateViewportCoordinates(Window *w);
};
 
class Scrollbar {
private:
  const bool is_vertical; 
  uint16 count;           
  uint16 cap;             
  uint16 pos;             
  uint16 stepsize;        
 
public:
  enum ScrollbarStepping {
    SS_RAW,             
    SS_SMALL,           
    SS_BIG,             
  };
 
  Scrollbar(bool is_vertical) : is_vertical(is_vertical), stepsize(1)
  {
  }
 
  inline uint16 GetCount() const
  {
    return this->count;
  }
 
  inline uint16 GetCapacity() const
  {
    return this->cap;
  }
 
  inline uint16 GetPosition() const
  {
    return this->pos;
  }
 
  inline bool IsVisible(uint16 item) const
  {
    return IsInsideBS(item, this->GetPosition(), this->GetCapacity());
  }
 
  inline bool IsVertical() const
  {
    return this->is_vertical;
  }
 
  void SetStepSize(uint16 stepsize)
  {
    assert(stepsize > 0);
    this->stepsize = stepsize;
  }
 
  void SetCount(int num)
  {
    assert(num >= 0);
    assert(num <= MAX_UVALUE(uint16));
 
    this->count = num;
    num -= this->cap;
    if (num < 0) num = 0;
    if (num < this->pos) this->pos = num;
  }
 
  void SetCapacity(int capacity)
  {
    assert(capacity > 0);
    assert(capacity <= MAX_UVALUE(uint16));
 
    this->cap = capacity;
    if (this->cap + this->pos > this->count) this->pos = std::max(0, this->count - this->cap);
  }
 
  void SetCapacityFromWidget(Window *w, int widget, int padding = 0);
 
  bool SetPosition(int position)
  {
    uint16 old_pos = this->pos;
    this->pos = Clamp(position, 0, std::max(this->count - this->cap, 0));
    return this->pos != old_pos;
  }
 
  bool UpdatePosition(int difference, ScrollbarStepping unit = SS_SMALL)
  {
    if (difference == 0) return false;
    switch (unit) {
      case SS_SMALL: difference *= this->stepsize; break;
      case SS_BIG:   difference *= this->cap; break;
      default: break;
    }
    return this->SetPosition(this->pos + difference);
  }
 
  void ScrollTowards(int position)
  {
    if (position < this->GetPosition()) {
      /* scroll up to the item */
      this->SetPosition(position);
    } else if (position >= this->GetPosition() + this->GetCapacity()) {
      /* scroll down so that the item is at the bottom */
      this->SetPosition(position - this->GetCapacity() + 1);
    }
  }
 
  int GetScrolledRowFromWidget(int clickpos, const Window * const w, int widget, int padding = 0) const;
  EventState UpdateListPositionOnKeyPress(int &list_position, uint16 keycode) const;
};
 
class NWidgetScrollbar : public NWidgetCore, public Scrollbar {
public:
  NWidgetScrollbar(WidgetType tp, Colours colour, int index);
 
  void SetupSmallestSize(Window *w, bool init_array) override;
  void Draw(const Window *w) override;
 
  static void InvalidateDimensionCache();
  static Dimension GetVerticalDimension();
  static Dimension GetHorizontalDimension();
 
private:
  static Dimension vertical_dimension;   
  static Dimension horizontal_dimension; 
};
 
class NWidgetLeaf : public NWidgetCore {
public:
  NWidgetLeaf(WidgetType tp, Colours colour, int index, uint32 data, StringID tip);
 
  void SetupSmallestSize(Window *w, bool init_array) override;
  void Draw(const Window *w) override;
 
  bool ButtonHit(const Point &pt);
 
  static void InvalidateDimensionCache();
 
  static Dimension dropdown_dimension;  
  static Dimension resizebox_dimension; 
  static Dimension closebox_dimension;  
private:
  static Dimension shadebox_dimension;  
  static Dimension debugbox_dimension;  
  static Dimension defsizebox_dimension; 
  static Dimension stickybox_dimension; 
};
 
static inline uint ComputeMaxSize(uint base, uint max_space, uint step)
{
  if (base >= max_space || step == 0) return base;
  if (step == 1) return max_space;
  uint increment = max_space - base;
  increment -= increment % step;
  return base + increment;
}
 
struct NWidgetPartDataTip {
  uint32 data;      
  StringID tooltip; 
};
 
struct NWidgetPartWidget {
  Colours colour; 
  int16 index;    
};
 
struct NWidgetPartPaddings : RectPadding {
};
 
struct NWidgetPartPIP {
  uint8 pre, inter, post; 
};
 
struct NWidgetPartTextLines {
  uint8 lines;   
  uint8 spacing; 
  FontSize size; 
};
 
struct NWidgetPartTextColour {
  TextColour colour; 
};
 
struct NWidgetPartAlignment {
  StringAlignment align; 
};
 
typedef NWidgetBase *NWidgetFunctionType(int *biggest_index);
 
struct NWidgetPart {
  WidgetType type;                         
  union {
    Point xy;                        
    NWidgetPartDataTip data_tip;     
    NWidgetPartWidget widget;        
    NWidgetPartPaddings padding;     
    NWidgetPartPIP pip;              
    NWidgetPartTextLines text_lines; 
    NWidgetPartTextColour colour;    
    NWidgetPartAlignment align;      
    NWidgetFunctionType *func_ptr;   
    NWidContainerFlags cont_flags;   
  } u;
};
 
static inline NWidgetPart SetResize(int16 dx, int16 dy)
{
  NWidgetPart part;
 
  part.type = WPT_RESIZE;
  part.u.xy.x = dx;
  part.u.xy.y = dy;
 
  return part;
}
 
static inline NWidgetPart SetMinimalSize(int16 x, int16 y)
{
  NWidgetPart part;
 
  part.type = WPT_MINSIZE;
  part.u.xy.x = x;
  part.u.xy.y = y;
 
  return part;
}
 
static inline NWidgetPart SetMinimalTextLines(uint8 lines, uint8 spacing, FontSize size = FS_NORMAL)
{
  NWidgetPart part;
 
  part.type = WPT_MINTEXTLINES;
  part.u.text_lines.lines = lines;
  part.u.text_lines.spacing = spacing;
  part.u.text_lines.size = size;
 
  return part;
}
 
static inline NWidgetPart SetTextColour(TextColour colour)
{
  NWidgetPart part;
 
  part.type = WPT_TEXTCOLOUR;
  part.u.colour.colour = colour;
 
  return part;
}
 
static inline NWidgetPart SetAlignment(StringAlignment align)
{
  NWidgetPart part;
 
  part.type = WPT_ALIGNMENT;
  part.u.align.align = align;
 
  return part;
}
 
static inline NWidgetPart SetFill(uint fill_x, uint fill_y)
{
  NWidgetPart part;
 
  part.type = WPT_FILL;
  part.u.xy.x = fill_x;
  part.u.xy.y = fill_y;
 
  return part;
}
 
static inline NWidgetPart EndContainer()
{
  NWidgetPart part;
 
  part.type = WPT_ENDCONTAINER;
 
  return part;
}
 
static inline NWidgetPart SetDataTip(uint32 data, StringID tip)
{
  NWidgetPart part;
 
  part.type = WPT_DATATIP;
  part.u.data_tip.data = data;
  part.u.data_tip.tooltip = tip;
 
  return part;
}
 
static inline NWidgetPart SetMatrixDataTip(uint8 cols, uint8 rows, StringID tip)
{
  return SetDataTip((rows << MAT_ROW_START) | (cols << MAT_COL_START), tip);
}
 
static inline NWidgetPart SetPadding(uint8 top, uint8 right, uint8 bottom, uint8 left)
{
  NWidgetPart part;
 
  part.type = WPT_PADDING;
  part.u.padding.top = top;
  part.u.padding.right = right;
  part.u.padding.bottom = bottom;
  part.u.padding.left = left;
 
  return part;
}
 
static inline NWidgetPart SetPadding(const RectPadding &padding)
{
  NWidgetPart part;
 
  part.type = WPT_PADDING;
  part.u.padding.left = padding.left;
  part.u.padding.top = padding.top;
  part.u.padding.right = padding.right;
  part.u.padding.bottom = padding.bottom;
 
  return part;
}
 
static inline NWidgetPart SetPadding(uint8 padding)
{
  return SetPadding(padding, padding, padding, padding);
}
 
static inline NWidgetPart SetPIP(uint8 pre, uint8 inter, uint8 post)
{
  NWidgetPart part;
 
  part.type = WPT_PIPSPACE;
  part.u.pip.pre = pre;
  part.u.pip.inter = inter;
  part.u.pip.post = post;
 
  return part;
}
 
static inline NWidgetPart SetScrollbar(int index)
{
  NWidgetPart part;
 
  part.type = WPT_SCROLLBAR;
  part.u.widget.index = index;
 
  return part;
}
 
static inline NWidgetPart NWidget(WidgetType tp, Colours col, int16 idx = -1)
{
  NWidgetPart part;
 
  part.type = tp;
  part.u.widget.colour = col;
  part.u.widget.index = idx;
 
  return part;
}
 
static inline NWidgetPart NWidget(WidgetType tp, NWidContainerFlags cont_flags = NC_NONE)
{
  NWidgetPart part;
 
  part.type = tp;
  part.u.cont_flags = cont_flags;
 
  return part;
}
 
static inline NWidgetPart NWidgetFunction(NWidgetFunctionType *func_ptr)
{
  NWidgetPart part;
 
  part.type = WPT_FUNCTION;
  part.u.func_ptr = func_ptr;
 
  return part;
}
 
NWidgetContainer *MakeNWidgets(const NWidgetPart *parts, int count, int *biggest_index, NWidgetContainer *container);
NWidgetContainer *MakeWindowNWidgetTree(const NWidgetPart *parts, int count, int *biggest_index, NWidgetStacked **shade_select);
 
NWidgetBase *MakeCompanyButtonRows(int *biggest_index, int widget_first, int widget_last, Colours button_colour, int max_length, StringID button_tooltip);
 
void SetupWidgetDimensions();
 
#endif /* WIDGET_TYPE_H */