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 <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */

 
#ifndef WIDGET_TYPE_H
#define WIDGET_TYPE_H
 
#include "core/math_func.hpp"
#include "strings_type.h"
#include "gfx_type.h"
#include "window_type.h"

enum class ArrowWidgetType : uint8_t {
  Decrease, 
  Increase, 
  Left, 
  Right, 
};

enum class ResizeWidgetType : uint8_t {
  ShowBevel, 
  HideBevel, 
};

enum WidgetType : uint8_t {
  /* Window widget types. */
  WWT_EMPTY,      
 
  WWT_PANEL,      
  WWT_INSET,      
  WWT_IMGBTN,     
  WWT_IMGBTN_2,   
  WWT_ARROWBTN,   
  WWT_TEXTBTN,    
  WWT_TEXTBTN_2,  
  WWT_BOOLBTN,    
  WWT_IMGTEXTBTN, 
  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_LAYER,           
  NWID_VIEWPORT,        
  NWID_BUTTON_DROPDOWN, 
  NWID_HSCROLLBAR,      
  NWID_VSCROLLBAR,      
  NWID_CUSTOM,          
 
  /* Nested widget part types. */
  WPT_ATTRIBUTE_BEGIN, 
  WPT_RESIZE,       
  WPT_MINSIZE,      
  WPT_MINTEXTLINES, 
  WPT_FILL,         
  WPT_DATATIP,      
  WPT_PADDING,      
  WPT_PIPSPACE,     
  WPT_PIPRATIO,     
  WPT_TEXTSTYLE,    
  WPT_ALIGNMENT,    
  WPT_SCROLLBAR,    
  WPT_ASPECT,       
  WPT_TOOLBARSIZE,  
  WPT_ATTRIBUTE_END, 
 
  WPT_FUNCTION, 
  WPT_ENDCONTAINER, 
 
  /* 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,    
  WWT_PUSHIMGTEXTBTN = WWT_IMGTEXTBTN | WWB_PUSHBUTTON, 
  NWID_PUSHBUTTON_DROPDOWN = NWID_BUTTON_DROPDOWN | WWB_PUSHBUTTON,
};

enum class SizingType : uint8_t {
  Smallest, 
  Resize, 
};

enum class AspectFlag : uint8_t {
  ResizeX, 
  ResizeY, 
};

using AspectFlags = EnumBitSet<AspectFlag, uint8_t>;
 
/* Forward declarations. */
class NWidgetCore;
class Scrollbar;

using WidgetLookup = std::map<WidgetID, class NWidgetBase *>;

class NWidgetBase {
public:
  NWidgetBase(WidgetType tp, WidgetID index = INVALID_WIDGET) : type(tp), index(index) {}
  virtual ~NWidgetBase() = default;
 
  void ApplyAspectRatio();

  virtual void AdjustPaddingForZoom();
  virtual void SetupSmallestSize(Window *w) = 0;
  virtual void AssignSizePosition(SizingType sizing, int x, int y, uint given_width, uint given_height, bool rtl) = 0;
 
  virtual void FillWidgetLookup(WidgetLookup &widget_lookup);
 
  virtual NWidgetCore *GetWidgetFromPos(int x, int y) = 0;
  virtual NWidgetBase *GetWidgetOfType(WidgetType tp);

  template <class NWID>
  NWID *GetParentWidget()
  {
    for (NWidgetBase *nwid_parent = this->parent; nwid_parent != nullptr; nwid_parent = nwid_parent->parent) {
      if (NWID *nwid = dynamic_cast<NWID *>(nwid_parent); nwid != nullptr) return nwid;
    }
    return nullptr;
  }

  template <class NWID>
  const NWID *GetParentWidget() const
  {
    for (const NWidgetBase *nwid_parent = this->parent; nwid_parent != nullptr; nwid_parent = nwid_parent->parent) {
      if (const NWID *nwid = dynamic_cast<const NWID *>(nwid_parent); nwid != nullptr) return nwid;
    }
    return nullptr;
  }
 
  inline WidgetID GetIndex() const { return this->index; }

  virtual bool IsHighlighted() const { return false; }

  virtual TextColour GetHighlightColour() const { return TextColour::Invalid; }

  virtual void SetHighlighted([[maybe_unused]] TextColour highlight_colour) {}

  inline void SetPadding(uint8_t top, uint8_t right, uint8_t bottom, uint8_t 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 = 0; 
  uint fill_y = 0; 
  uint resize_x = 0; 
  uint resize_y = 0; 
  /* Size of the widget in the smallest window possible.
   * Computed by #SetupSmallestSize() followed by #AssignSizePosition().
   */
  uint smallest_x = 0; 
  uint smallest_y = 0; 
  /* Current widget size (that is, after resizing). */
  uint current_x = 0; 
  uint current_y = 0; 
  float aspect_ratio = 0; 
  AspectFlags aspect_flags = AspectFlag::ResizeX; 
 
  int pos_x = 0; 
  int pos_y = 0; 
 
  RectPadding padding{}; 
  RectPadding uz_padding{}; 
 
  NWidgetBase *parent = nullptr; 
 
protected:
  const WidgetID index = INVALID_WIDGET; 
 
  inline void StoreSizePosition(SizingType sizing, int x, int y, uint given_width, uint given_height);
};

inline uint NWidgetBase::GetHorizontalStepSize(SizingType sizing) const
{
  return (sizing == SizingType::Resize) ? this->resize_x : this->fill_x;
}

inline uint NWidgetBase::GetVerticalStepSize(SizingType sizing) const
{
  return (sizing == SizingType::Resize) ? this->resize_y : this->fill_y;
}

inline void NWidgetBase::StoreSizePosition(SizingType sizing, int x, int y, uint given_width, uint given_height)
{
  this->pos_x = x;
  this->pos_y = y;
  if (sizing == SizingType::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, WidgetID index, 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_t min_lines, uint8_t spacing, FontSize size);
  void SetToolbarMinimalSize(uint8_t toolbar_size);
  void SetFill(uint fill_x, uint fill_y);
  void SetResize(uint resize_x, uint resize_y);
  void SetAspect(float ratio, AspectFlags flags = AspectFlag::ResizeX);
  void SetAspect(int x_ratio, int y_ratio, AspectFlags flags = AspectFlag::ResizeX);
 
  bool UpdateMultilineWidgetSize(const std::string &str, int max_lines);
  bool UpdateSize(uint min_x, uint min_y);
  bool UpdateVerticalSize(uint min_y);
 
  void AssignSizePosition(SizingType sizing, int x, int y, uint given_width, uint given_height, bool rtl) override;
 
  uint min_x = 0; 
  uint min_y = 0; 
 
  bool absolute = false; 
  uint uz_min_x = 0; 
  uint uz_min_y = 0; 
 
  uint8_t uz_text_lines = 0; 
  uint8_t uz_text_spacing = 0; 
  FontSize uz_text_size{}; 
  uint8_t toolbar_size = 0; 
};

enum class NWidgetDisplayFlag : uint8_t {
  /* Generic. */
  Lowered, 
  Disabled, 
 
  /* Viewport widget. */
  NoTransparency, 
  ShadeGrey, 
  ShadeDimmed, 
 
  /* Button dropdown widget. */
  DropdownActive, 
 
  /* Scrollbar widget. */
  ScrollbarUp, 
  ScrollbarDown, 
 
  /* Generic. */
  Highlight, 
  DropdownClosed, 
};

using NWidgetDisplayFlags = EnumBitSet<NWidgetDisplayFlag, uint16_t>;

struct WidgetData {
  StringID string{};
  SpriteID sprite{};
  ArrowWidgetType arrow_widget_type{};
  ResizeWidgetType resize_widget_type{};
  Colours alternate_colour = Colours::Invalid;
  Dimension matrix{};
};

class NWidgetCore : public NWidgetResizeBase {
public:
  NWidgetCore(WidgetType tp, Colours colour, WidgetID index, uint fill_x, uint fill_y, const WidgetData &widget_data, StringID tool_tip);
 
  void SetString(StringID string);
  void SetStringTip(StringID string, StringID tool_tip);
  void SetSprite(SpriteID sprite);
  void SetSpriteTip(SpriteID sprite, StringID tool_tip);
  void SetMatrixDimension(uint32_t columns, uint32_t rows);
  void SetResizeWidgetType(ResizeWidgetType type);
  void SetToolTip(StringID tool_tip);
  StringID GetToolTip() const;
  void SetTextStyle(TextColour colour, FontSize size);
  void SetAlignment(StringAlignment align);
 
  StringID GetString() const;
  WidgetID GetScrollbarIndex() const;
 
  inline void SetLowered(bool lowered);
  inline bool IsLowered() const;
  inline void SetDisabled(bool disabled);
  inline bool IsDisabled() const;
 
  inline TextColour GetTextColour() const { return this->text_colour; }
  inline FontSize GetFontSize() const { return this->text_size; }
 
  NWidgetCore *GetWidgetFromPos(int x, int y) override;
  bool IsHighlighted() const override;
  TextColour GetHighlightColour() const override;
  void SetHighlighted(TextColour highlight_colour) override;
 
  NWidgetDisplayFlags disp_flags; 
  Colours colour;            
protected:
  WidgetData widget_data{}; 
  StringID tool_tip{}; 
  WidgetID scrollbar_index = INVALID_WIDGET; 
  TextColour highlight_colour{}; 
  TextColour text_colour{}; 
  FontSize text_size = FontSize::Normal; 
  StringAlignment align = SA_CENTER; 
 
  /* This function constructs the widgets, so it should be able to write the variables. */
  friend void ApplyNWidgetPartAttribute(const struct NWidgetPart &nwid, NWidgetBase *dest);
};
 
inline void NWidgetCore::SetHighlighted(TextColour highlight_colour)
{
  highlight_colour != TextColour::Invalid ? this->disp_flags.Set(NWidgetDisplayFlag::Highlight) : this->disp_flags.Reset(NWidgetDisplayFlag::Highlight);
  this->highlight_colour = highlight_colour;
}
 
inline bool NWidgetCore::IsHighlighted() const
{
  return this->disp_flags.Test(NWidgetDisplayFlag::Highlight);
}
 
inline TextColour NWidgetCore::GetHighlightColour() const
{
  return this->highlight_colour;
}

inline void NWidgetCore::SetLowered(bool lowered)
{
  lowered ? this->disp_flags.Set(NWidgetDisplayFlag::Lowered) : this->disp_flags.Reset(NWidgetDisplayFlag::Lowered);
}

inline bool NWidgetCore::IsLowered() const
{
  return this->disp_flags.Test(NWidgetDisplayFlag::Lowered);
}

inline void NWidgetCore::SetDisabled(bool disabled)
{
  this->disp_flags = disabled ? this->disp_flags.Set(NWidgetDisplayFlag::Disabled) : this->disp_flags.Reset(NWidgetDisplayFlag::Disabled);
}

inline bool NWidgetCore::IsDisabled() const
{
  return this->disp_flags.Test(NWidgetDisplayFlag::Disabled);
}
 

class NWidgetContainer : public NWidgetBase {
public:
  NWidgetContainer(WidgetType tp, WidgetID index = INVALID_WIDGET) : NWidgetBase(tp, index) {}
 
  void AdjustPaddingForZoom() override;
  void Add(std::unique_ptr<NWidgetBase> &&wid);
  void FillWidgetLookup(WidgetLookup &widget_lookup) override;
 
  void Draw(const Window *w) override;
  NWidgetCore *GetWidgetFromPos(int x, int y) override;

  inline bool IsEmpty() { return this->children.empty(); }
 
  NWidgetBase *GetWidgetOfType(WidgetType tp) override;
  void UnfocusWidgets(Window *parent_window);

  inline void Clear(Window *parent_window)
  {
    this->UnfocusWidgets(parent_window);
    this->children.clear();
  }
 
protected:
  std::vector<std::unique_ptr<NWidgetBase>> children{}; 
};

enum StackedZeroSizePlanes : int {
  SZSP_VERTICAL = INT_MAX / 2, 
  SZSP_HORIZONTAL,             
  SZSP_NONE,                   
 
  SZSP_BEGIN = SZSP_VERTICAL,  
};

class NWidgetStacked : public NWidgetContainer {
public:
  NWidgetStacked(WidgetID index) : NWidgetContainer(NWID_SELECTION, index) {}
 
  void SetupSmallestSize(Window *w) override;
  void AssignSizePosition(SizingType sizing, int x, int y, uint given_width, uint given_height, bool rtl) override;
  void FillWidgetLookup(WidgetLookup &widget_lookup) override;
 
  void Draw(const Window *w) override;
  NWidgetCore *GetWidgetFromPos(int x, int y) override;
 
  bool SetDisplayedPlane(int plane);
 
  int shown_plane = 0; 
private:
  WidgetLookup *widget_lookup = nullptr; 
};

enum class NWidContainerFlag : uint8_t {
  EqualSize, 
  BigFirst, 
};

using NWidContainerFlags = EnumBitSet<NWidContainerFlag, uint8_t>;

class NWidgetPIPContainer : public NWidgetContainer {
public:
  NWidgetPIPContainer(WidgetType tp, NWidContainerFlags flags = {}, WidgetID index = INVALID_WIDGET) : NWidgetContainer(tp, index), flags(flags) {}
 
  void AdjustPaddingForZoom() override;
  void SetPIP(uint8_t pip_pre, uint8_t pip_inter, uint8_t pip_post);
  void SetPIPRatio(uint8_t pip_ratio_pre, uint8_t pip_ratio_inter, uint8_t pip_ratio_post);
 
protected:
  NWidContainerFlags flags{}; 
  uint8_t pip_pre = 0; 
  uint8_t pip_inter = 0; 
  uint8_t pip_post = 0; 
  uint8_t pip_ratio_pre = 0; 
  uint8_t pip_ratio_inter = 0; 
  uint8_t pip_ratio_post = 0; 
 
  uint8_t uz_pip_pre = 0; 
  uint8_t uz_pip_inter = 0; 
  uint8_t uz_pip_post = 0; 
 
  uint8_t gaps = 0; 
};

class NWidgetHorizontal : public NWidgetPIPContainer {
public:
  NWidgetHorizontal(NWidContainerFlags flags = {}, WidgetID index = INVALID_WIDGET, WidgetType type = NWID_HORIZONTAL) : NWidgetPIPContainer(type, flags, index) {}
 
  void SetupSmallestSize(Window *w) override;
  void AssignSizePosition(SizingType sizing, int x, int y, uint given_width, uint given_height, bool rtl) override;
};

class NWidgetHorizontalLTR : public NWidgetHorizontal {
public:
  NWidgetHorizontalLTR(NWidContainerFlags flags = {}, WidgetID index = INVALID_WIDGET) : NWidgetHorizontal(flags, index, NWID_HORIZONTAL_LTR) {}
 
  void AssignSizePosition(SizingType sizing, int x, int y, uint given_width, uint given_height, bool rtl) override;
};

class NWidgetVertical : public NWidgetPIPContainer {
public:
  NWidgetVertical(NWidContainerFlags flags = {}, WidgetID index = INVALID_WIDGET) : NWidgetPIPContainer(NWID_VERTICAL, flags, index) {}
 
  void SetupSmallestSize(Window *w) override;
  void AssignSizePosition(SizingType sizing, int x, int y, uint given_width, uint given_height, bool rtl) override;
 
  bool bottom_up = false; 
};

class NWidgetMatrix : public NWidgetPIPContainer {
public:
  NWidgetMatrix(Colours colour, WidgetID index) : NWidgetPIPContainer(NWID_MATRIX, NWidContainerFlag::EqualSize, index), colour(colour) {}
 
  void SetClicked(int clicked);
  void SetCount(int count);
  void SetScrollbar(Scrollbar *sb);
  int GetCurrentElement() const;
 
  void SetupSmallestSize(Window *w) override;
  void AssignSizePosition(SizingType sizing, int x, int y, uint given_width, uint given_height, bool rtl) override;
 
  NWidgetCore *GetWidgetFromPos(int x, int y) override;
  void Draw(const Window *w) override;
protected:
  Colours colour{}; 
  int clicked = -1; 
  int count = 0; 
  int current_element = 0; 
  Scrollbar *sb = nullptr;  
private:
  int widget_w = 0; 
  int widget_h = 0; 
  int widgets_x = 0; 
  int widgets_y = 0; 
 
  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) 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, WidgetID index, std::unique_ptr<NWidgetPIPContainer> &&child = nullptr);
 
  void Add(std::unique_ptr<NWidgetBase> &&nwid);
  void SetPIP(uint8_t pip_pre, uint8_t pip_inter, uint8_t pip_post);
  void SetPIPRatio(uint8_t pip_ratio_pre, uint8_t pip_ratio_inter, uint8_t pip_ratio_post);
 
  void AdjustPaddingForZoom() override;
  void SetupSmallestSize(Window *w) override;
  void AssignSizePosition(SizingType sizing, int x, int y, uint given_width, uint given_height, bool rtl) override;
 
  void FillWidgetLookup(WidgetLookup &widget_lookup) override;
 
  void Draw(const Window *w) override;
  NWidgetCore *GetWidgetFromPos(int x, int y) override;
  NWidgetBase *GetWidgetOfType(WidgetType tp) override;
 
private:
  std::unique_ptr<NWidgetPIPContainer> child{}; 
};

class NWidgetViewport : public NWidgetCore {
public:
  NWidgetViewport(WidgetID index);
 
  void SetupSmallestSize(Window *w) override;
  void Draw(const Window *w) override;
 
  void InitializeViewport(Window *w, std::variant<TileIndex, VehicleID> focus, ZoomLevel zoom);
  void UpdateViewportCoordinates(Window *w);
};

class Scrollbar {
public:
  using size_type = int32_t;
  static constexpr size_type max_size_type = std::numeric_limits<size_type>::max();
  static constexpr size_type npos = max_size_type;
private:
  const bool is_vertical = false; 
  size_type count = 0; 
  size_type cap = 0; 
  size_type pos = 0; 
  size_type stepsize = 1; 
 
public:
  enum class Stepping : uint8_t {
    Single, 
    Small, 
    Big, 
  };
 
  Scrollbar(bool is_vertical) : is_vertical(is_vertical) {}

  inline size_type GetCount() const
  {
    return this->count;
  }

  inline size_type GetCapacity() const
  {
    return this->cap;
  }

  inline size_type GetPosition() const
  {
    return this->pos;
  }

  inline bool IsVisible(size_type item) const
  {
    return IsInsideBS(item, this->GetPosition(), this->GetCapacity());
  }

  inline bool IsVertical() const
  {
    return this->is_vertical;
  }

  void SetStepSize(size_t stepsize)
  {
    assert(stepsize > 0);
 
    this->stepsize = ClampTo<size_type>(stepsize);
  }

  void SetCount(size_t num)
  {
    assert(num < Scrollbar::max_size_type);
 
    this->count = ClampTo<size_type>(num);
    /* Ensure position is within bounds */
    this->SetPosition(this->pos);
  }

  void SetCapacity(size_t capacity)
  {
    assert(capacity < Scrollbar::max_size_type);
 
    this->cap = ClampTo<size_type>(capacity);
    /* Ensure position is within bounds */
    this->SetPosition(this->pos);
  }
 
  void SetCapacityFromWidget(Window *w, WidgetID widget, int padding = 0);

  bool SetPosition(size_type position)
  {
    size_type 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, Scrollbar::Stepping unit = Stepping::Small)
  {
    if (difference == 0) return false;
    switch (unit) {
      case Stepping::Small: difference *= this->stepsize; break;
      case Stepping::Big: difference *= this->cap; break;
      default: break;
    }
    return this->SetPosition(this->pos + difference);
  }

  void ScrollTowards(size_type 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);
    }
  }
 
  size_type GetScrolledRowFromWidget(int clickpos, const Window * const w, WidgetID widget, int padding = 0, int line_height = -1) const;

  template <typename Tcontainer>
  auto GetVisibleRangeIterators(Tcontainer &container) const
  {
    assert(static_cast<size_t>(this->GetCount()) == container.size()); // Scrollbar and container size must match.
    auto first = std::next(std::begin(container), this->GetPosition());
    auto last = std::next(first, std::min<size_t>(this->GetCapacity(), this->GetCount() - this->GetPosition()));
    return std::make_pair(first, last);
  }

  template <typename Tcontainer>
  auto GetScrolledItemFromWidget(Tcontainer &container, int clickpos, const Window * const w, WidgetID widget, int padding = 0, int line_height = -1) const
  {
    assert(static_cast<size_t>(this->GetCount()) == container.size()); // Scrollbar and container size must match.
    size_type row = this->GetScrolledRowFromWidget(clickpos, w, widget, padding, line_height);
    if (row == Scrollbar::npos) return std::end(container);
 
    return std::next(std::begin(container), row);
  }
 
  EventState UpdateListPositionOnKeyPress(int &list_position, uint16_t keycode) const;
};

class NWidgetScrollbar : public NWidgetCore, public Scrollbar {
public:
  NWidgetScrollbar(WidgetType tp, Colours colour, WidgetID index);
 
  void SetupSmallestSize(Window *w) 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, WidgetID index, const WidgetData &data, StringID tip);
 
  void SetupSmallestSize(Window *w) 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; 
};

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 {
  WidgetData data; 
  StringID tooltip; 
};

struct NWidgetPartWidget {
  Colours colour; 
  WidgetID index; 
};
 
struct NWidgetPartContainer {
  NWidContainerFlags flags;
  WidgetID index;
};

struct NWidgetPartPaddings : RectPadding {
};

struct NWidgetPartPIP {
  uint8_t pre, inter, post; 
};

struct NWidgetPartTextLines {
  uint8_t lines;   
  uint8_t spacing; 
  FontSize size; 
};

struct NWidgetPartTextStyle {
  TextColour colour; 
  FontSize size; 
};

struct NWidgetPartAlignment {
  StringAlignment align; 
};
 
struct NWidgetPartAspect {
  float ratio;
  AspectFlags flags;
};

using NWidgetFunctionType = std::unique_ptr<NWidgetBase>();

struct NWidgetPart {
  WidgetType type;                         
  union NWidgetPartUnion {
    Point xy;                        
    NWidgetPartDataTip data_tip;     
    NWidgetPartWidget widget;        
    NWidgetPartPaddings padding;     
    NWidgetPartPIP pip;              
    NWidgetPartTextLines text_lines; 
    NWidgetPartTextStyle text_style; 
    NWidgetPartAlignment align;      
    NWidgetFunctionType *func_ptr;   
    NWidgetPartContainer container;   
    NWidgetPartAspect aspect; 
 
    /* Constructors for each NWidgetPartUnion data type. */
    constexpr NWidgetPartUnion() : xy() {}
    constexpr NWidgetPartUnion(Point xy) : xy(xy) {}
    constexpr NWidgetPartUnion(NWidgetPartDataTip data_tip) : data_tip(data_tip) {}
    constexpr NWidgetPartUnion(NWidgetPartWidget widget) : widget(widget) {}
    constexpr NWidgetPartUnion(NWidgetPartPaddings padding) : padding(padding) {}
    constexpr NWidgetPartUnion(NWidgetPartPIP pip) : pip(pip) {}
    constexpr NWidgetPartUnion(NWidgetPartTextLines text_lines) : text_lines(text_lines) {}
    constexpr NWidgetPartUnion(NWidgetPartTextStyle text_style) : text_style(text_style) {}
    constexpr NWidgetPartUnion(NWidgetPartAlignment align) : align(align) {}
    constexpr NWidgetPartUnion(NWidgetFunctionType *func_ptr) : func_ptr(func_ptr) {}
    constexpr NWidgetPartUnion(NWidgetPartContainer container) : container(container) {}
    constexpr NWidgetPartUnion(NWidgetPartAspect aspect) : aspect(aspect) {}
  } u;
 
  /* Constructors for each NWidgetPart data type. */
  explicit constexpr NWidgetPart(WidgetType type) : type(type), u() {}
  constexpr NWidgetPart(WidgetType type, Point xy) : type(type), u(xy) {}
  constexpr NWidgetPart(WidgetType type, NWidgetPartDataTip data_tip) : type(type), u(data_tip) {}
  constexpr NWidgetPart(WidgetType type, NWidgetPartWidget widget) : type(type), u(widget) {}
  constexpr NWidgetPart(WidgetType type, NWidgetPartPaddings padding) : type(type), u(padding) {}
  constexpr NWidgetPart(WidgetType type, NWidgetPartPIP pip) : type(type), u(pip) {}
  constexpr NWidgetPart(WidgetType type, NWidgetPartTextLines text_lines) : type(type), u(text_lines) {}
  constexpr NWidgetPart(WidgetType type, NWidgetPartTextStyle text_style) : type(type), u(text_style) {}
  constexpr NWidgetPart(WidgetType type, NWidgetPartAlignment align) : type(type), u(align) {}
  constexpr NWidgetPart(WidgetType type, NWidgetFunctionType *func_ptr) : type(type), u(func_ptr) {}
  constexpr NWidgetPart(WidgetType type, NWidgetPartContainer container) : type(type), u(container) {}
  constexpr NWidgetPart(WidgetType type, NWidgetPartAspect aspect) : type(type), u(aspect) {}
};

constexpr NWidgetPart SetResize(int16_t dx, int16_t dy)
{
  return NWidgetPart{WPT_RESIZE, Point{dx, dy}};
}

constexpr NWidgetPart SetMinimalSize(int16_t x, int16_t y)
{
  return NWidgetPart{WPT_MINSIZE, Point{x, y}};
}

constexpr NWidgetPart SetToolbarSpacerMinimalSize()
{
  return NWidgetPart{WPT_MINSIZE, Point{4, 0}};
}

constexpr NWidgetPart SetToolbarMinimalSize(int width)
{
  return NWidgetPart{WPT_TOOLBARSIZE, Point{width, 1}};
}

constexpr NWidgetPart SetMinimalTextLines(uint8_t lines, uint8_t spacing, FontSize size = FontSize::Normal)
{
  return NWidgetPart{WPT_MINTEXTLINES, NWidgetPartTextLines{lines, spacing, size}};
}

constexpr NWidgetPart SetTextStyle(TextColour colour, FontSize size = FontSize::Normal)
{
  return NWidgetPart{WPT_TEXTSTYLE, NWidgetPartTextStyle{colour, size}};
}

constexpr NWidgetPart SetAlignment(StringAlignment align)
{
  return NWidgetPart{WPT_ALIGNMENT, NWidgetPartAlignment{align}};
}

constexpr NWidgetPart SetFill(uint16_t fill_x, uint16_t fill_y)
{
  return NWidgetPart{WPT_FILL, Point{fill_x, fill_y}};
}

constexpr NWidgetPart EndContainer()
{
  return NWidgetPart{WPT_ENDCONTAINER};
}

constexpr NWidgetPart SetStringTip(StringID string, StringID tip = {})
{
  return NWidgetPart{WPT_DATATIP, NWidgetPartDataTip{{.string = string}, tip}};
}

constexpr NWidgetPart SetSpriteTip(SpriteID sprite, StringID tip = {})
{
  return NWidgetPart{WPT_DATATIP, NWidgetPartDataTip{{.sprite = sprite}, tip}};
}

constexpr NWidgetPart SetSpriteStringTip(SpriteID sprite, StringID string, StringID tip = {})
{
  return NWidgetPart{WPT_DATATIP, NWidgetPartDataTip{{.string = string, .sprite = sprite}, tip}};
}

constexpr NWidgetPart SetArrowWidgetTypeTip(ArrowWidgetType widget_type, StringID tip = {})
{
  return NWidgetPart{WPT_DATATIP, NWidgetPartDataTip{{.arrow_widget_type = widget_type}, tip}};
}

constexpr NWidgetPart SetResizeWidgetTypeTip(ResizeWidgetType widget_type, StringID tip)
{
  return NWidgetPart{WPT_DATATIP, NWidgetPartDataTip{{.resize_widget_type = widget_type}, tip}};
}

constexpr NWidgetPart SetAlternateColourTip(Colours colour, StringID tip)
{
  return NWidgetPart{WPT_DATATIP, NWidgetPartDataTip{{.alternate_colour = colour}, tip}};
}

constexpr NWidgetPart SetMatrixDataTip(uint32_t cols, uint32_t rows, StringID tip = {})
{
  return NWidgetPart{WPT_DATATIP, NWidgetPartDataTip{{.matrix{ cols, rows }}, tip}};
}

constexpr NWidgetPart SetToolTip(StringID tip)
{
  return NWidgetPart{WPT_DATATIP, NWidgetPartDataTip{{}, tip}};
}

constexpr NWidgetPart SetPadding(uint8_t top, uint8_t right, uint8_t bottom, uint8_t left)
{
  return NWidgetPart{WPT_PADDING, NWidgetPartPaddings{left, top, right, bottom}};
}

constexpr NWidgetPart SetPadding(uint8_t horizontal, uint8_t vertical)
{
  return NWidgetPart{WPT_PADDING, NWidgetPartPaddings{horizontal, vertical, horizontal, vertical}};
}

constexpr NWidgetPart SetPadding(const RectPadding &padding)
{
  return NWidgetPart{WPT_PADDING, NWidgetPartPaddings{padding}};
}

constexpr NWidgetPart SetPadding(uint8_t padding)
{
  return SetPadding(padding, padding, padding, padding);
}

constexpr NWidgetPart SetPIP(uint8_t pre, uint8_t inter, uint8_t post)
{
  return NWidgetPart{WPT_PIPSPACE, NWidgetPartPIP{pre, inter, post}};
}

constexpr NWidgetPart SetPIPRatio(uint8_t ratio_pre, uint8_t ratio_inter, uint8_t ratio_post)
{
  return NWidgetPart{WPT_PIPRATIO, NWidgetPartPIP{ratio_pre, ratio_inter, ratio_post}};
}

constexpr NWidgetPart SetScrollbar(WidgetID index)
{
  return NWidgetPart{WPT_SCROLLBAR, NWidgetPartWidget{Colours::Invalid, index}};
}

constexpr NWidgetPart SetAspect(float ratio, AspectFlags flags = AspectFlag::ResizeX)
{
  return NWidgetPart{WPT_ASPECT, NWidgetPartAspect{ratio, flags}};
}

constexpr NWidgetPart NWidget(WidgetType tp, Colours col, WidgetID idx = INVALID_WIDGET)
{
  return NWidgetPart{tp, NWidgetPartWidget{col, idx}};
}

constexpr NWidgetPart NWidget(WidgetType tp, NWidContainerFlags cont_flags = {}, WidgetID idx = INVALID_WIDGET)
{
  return NWidgetPart{tp, NWidgetPartContainer{cont_flags, idx}};
}

constexpr NWidgetPart NWidgetFunction(NWidgetFunctionType *func_ptr)
{
  return NWidgetPart{WPT_FUNCTION, func_ptr};
}
 
bool IsContainerWidgetType(WidgetType tp);
std::unique_ptr<NWidgetBase> MakeNWidgets(std::span<const NWidgetPart> nwid_parts, std::unique_ptr<NWidgetBase> &&container);
std::unique_ptr<NWidgetBase> MakeWindowNWidgetTree(std::span<const NWidgetPart> nwid_parts, NWidgetStacked **shade_select);
 
std::unique_ptr<NWidgetBase> MakeCompanyButtonRows(WidgetID widget_first, WidgetID widget_last, Colours button_colour, int max_length, StringID button_tooltip, bool resizable = true);
 
void SetupWidgetDimensions();
 
#endif /* WIDGET_TYPE_H */