window_gui.h

Go to the documentation of this file.

/* $Id: window_gui.h 14466 2008-10-14 19:27:08Z rubidium $ */

#ifndef WINDOW_GUI_H
#define WINDOW_GUI_H

#include "core/bitmath_func.hpp"
#include "core/geometry_type.hpp"
#include "vehicle_type.h"
#include "viewport_type.h"
#include "company_type.h"
#include "strings_type.h"
#include "core/alloc_type.hpp"
#include "window_type.h"
#include "tile_type.h"

static const int MAX_NUMBER_OF_WINDOWS = 25;

/* How the resize system works:
    First, you need to add a WWT_RESIZEBOX to the widgets, and you need
     to add the flag WDF_RESIZABLE to the window. Now the window is ready
     to resize itself.
    As you may have noticed, all widgets have a RESIZE_XXX in their line.
     This lines controls how the widgets behave on resize. RESIZE_NONE means
     it doesn't do anything. Any other option let's one of the borders
     move with the changed width/height. So if a widget has
     RESIZE_RIGHT, and the window is made 5 pixels wider by the user,
     the right of the window will also be made 5 pixels wider.
    Now, what if you want to clamp a widget to the bottom? Give it the flag
     RESIZE_TB. This is RESIZE_TOP + RESIZE_BOTTOM. Now if the window gets
     5 pixels bigger, both the top and bottom gets 5 bigger, so the whole
     widgets moves downwards without resizing, and appears to be clamped
     to the bottom. Nice aint it?
   You should know one more thing about this system. Most windows can't
    handle an increase of 1 pixel. So there is a step function, which
    let the windowsize only be changed by X pixels. You configure this
    after making the window, like this:
      w->resize.step_height = 10;
    Now the window will only change in height in steps of 10.
   You can also give a minimum width and height. The default value is
    the default height/width of the window itself. You can change this
    AFTER window - creation, with:
     w->resize.width or w->resize.height.
   That was all.. good luck, and enjoy :) -- TrueLight */

enum ResizeFlag {
  RESIZE_NONE   = 0,  

  RESIZE_LEFT   = 1,  
  RESIZE_RIGHT  = 2,  
  RESIZE_TOP    = 4,  
  RESIZE_BOTTOM = 8,  

  RESIZE_LR     = RESIZE_LEFT  | RESIZE_RIGHT,   
  RESIZE_RB     = RESIZE_RIGHT | RESIZE_BOTTOM,  
  RESIZE_TB     = RESIZE_TOP   | RESIZE_BOTTOM,  
  RESIZE_LRB    = RESIZE_LEFT  | RESIZE_RIGHT  | RESIZE_BOTTOM, 
  RESIZE_LRTB   = RESIZE_LEFT  | RESIZE_RIGHT  | RESIZE_TOP | RESIZE_BOTTOM,  
  RESIZE_RTB    = RESIZE_RIGHT | RESIZE_TOP    | RESIZE_BOTTOM, 

  /* The following flags are used by the system to specify what is disabled, hidden, or clicked
   * They are used in the same place as the above RESIZE_x flags, Widget visual_flags.
   * These states are used in exceptions. If nothing is specified, they will indicate
   * Enabled, visible or unclicked widgets*/
  WIDG_DISABLED = 4,  
  WIDG_HIDDEN   = 5,  
  WIDG_LOWERED  = 6,  
};

enum {
  WIDGET_LIST_END = -1, 
};

struct Widget {
  byte type;                        
  byte display_flags;               
  byte color;                       
  int16 left;                       
  int16 right;                      
  int16 top;                        
  int16 bottom;                     
  uint16 data;                      
  StringID tooltips;                
};

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);

/* wiget.cpp */
void DrawFrameRect(int left, int top, int right, int bottom, int color, FrameFlags flags);

struct WindowDesc {
  int16 left;             
  int16 top;              
  int16 minimum_width;    
  int16 minimum_height;   
  int16 default_width;    
  int16 default_height;   
  WindowClass cls;        
  WindowClass parent_cls; 
  uint32 flags;           
  const Widget *widgets;  
};

enum WindowDefaultFlag {
  WDF_STD_TOOLTIPS    =   1 << 0, 
  WDF_DEF_WIDGET      =   1 << 1, 
  WDF_STD_BTN         =   1 << 2, 

  WDF_UNCLICK_BUTTONS =   1 << 4, 
  WDF_STICKY_BUTTON   =   1 << 5, 
  WDF_RESIZABLE       =   1 << 6, 
  WDF_MODAL           =   1 << 7, 
};

enum WindowDefaultPosition {
  WDP_AUTO      = -1, 
  WDP_CENTER    = -2, 
  WDP_ALIGN_TBR = -3, 
  WDP_ALIGN_TBL = -4, 
};

struct Scrollbar {
  uint16 count;  
  uint16 cap;    
  uint16 pos;    
};

struct ResizeInfo {
  uint width;       
  uint height;      
  uint step_width;  
  uint step_height; 
};

enum SortButtonState {
  SBS_OFF,
  SBS_DOWN,
  SBS_UP,
};

struct ViewportData : ViewPort {
  VehicleID follow_vehicle;
  int32 scrollpos_x;
  int32 scrollpos_y;
  int32 dest_scrollpos_x;
  int32 dest_scrollpos_y;
};

struct Window : ZeroedMemoryAllocator {
  enum EventState {
    ES_HANDLED,     
    ES_NOT_HANDLED, 
  };

protected:
  void Initialize(int x, int y, int min_width, int min_height,
      WindowClass cls, const Widget *widget, int window_number);
  void FindWindowPlacementAndResize(int def_width, int def_height);
  void FindWindowPlacementAndResize(const WindowDesc *desc);

public:
  Window(int x, int y, int width, int height, WindowClass cls, const Widget *widget);
  Window(const WindowDesc *desc, WindowNumber number = 0);

  virtual ~Window();

  uint16 flags4;              
  WindowClass window_class;   
  WindowNumber window_number; 

  int left;   
  int top;    
  int width;  
  int height; 

  Scrollbar hscroll;  
  Scrollbar vscroll;  
  Scrollbar vscroll2; 
  ResizeInfo resize;  

  byte caption_color; 

  ViewportData *viewport;      
  Widget *widget;        
  uint widget_count;     
  uint32 desc_flags;     

  Window *parent;        

  void HandleButtonClick(byte widget);

  void SetWidgetDisabledState(byte widget_index, bool disab_stat);
  void DisableWidget(byte widget_index);
  void EnableWidget(byte widget_index);
  bool IsWidgetDisabled(byte widget_index) const;
  void SetWidgetHiddenState(byte widget_index, bool hidden_stat);
  void HideWidget(byte widget_index);
  void ShowWidget(byte widget_index);
  bool IsWidgetHidden(byte widget_index) const;
  void SetWidgetLoweredState(byte widget_index, bool lowered_stat);
  void ToggleWidgetLoweredState(byte widget_index);
  void LowerWidget(byte widget_index);
  void RaiseWidget(byte widget_index);
  bool IsWidgetLowered(byte widget_index) const;
  void AlignWidgetRight(byte widget_index_a, byte widget_index_b);
  int  GetWidgetWidth(byte widget_index) const;

  void RaiseButtons();
  void CDECL SetWidgetsDisabledState(bool disab_stat, int widgets, ...);
  void CDECL SetWidgetsHiddenState(bool hidden_stat, int widgets, ...);
  void CDECL SetWidgetsLoweredState(bool lowered_stat, int widgets, ...);
  void InvalidateWidget(byte widget_index) const;

  void DrawWidgets() const;
  void DrawViewport() const;
  void DrawSortButtonState(int widget, SortButtonState state) const;

  void DeleteChildWindows() const;

  void SetDirty() const;

  /*** Event handling ***/

  virtual void OnPaint() {}


  virtual EventState OnKeyPress(uint16 key, uint16 keycode) { return ES_NOT_HANDLED; }

  virtual EventState OnCTRLStateChange() { return ES_NOT_HANDLED; }


  virtual void OnClick(Point pt, int widget) {}

  virtual void OnDoubleClick(Point pt, int widget) {}

  virtual void OnRightClick(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 OnTick() {}

  virtual void OnHundredthTick() {}

  virtual void OnTimeout() {}


  virtual void OnResize(Point new_size, Point delta) {}

  virtual void OnDropdownSelect(int widget, int index) {}

  virtual void OnQueryTextFinished(char *str) {}

  virtual void OnInvalidateData(int data = 0) {}


  virtual void OnPlaceObject(Point pt, TileIndex tile) {}

  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 ***/
};

class PickerWindowBase : public Window {

public:
  PickerWindowBase(const WindowDesc *desc, Window *parent) : Window(desc)
  {
    this->parent = parent;
  };

  virtual ~PickerWindowBase();
};

/****************** THESE ARE NOT WIDGET TYPES!!!!! *******************/
enum WindowWidgetBehaviours {
  WWB_PUSHBUTTON  = 1 << 5,

  WWB_MASK        = 0xE0,
};


enum WindowWidgetTypes {
  WWT_EMPTY,      

  WWT_PANEL,      
  WWT_INSET,      
  WWT_IMGBTN,     
  WWT_IMGBTN_2,   

  WWT_TEXTBTN,    
  WWT_TEXTBTN_2,  
  WWT_LABEL,      
  WWT_TEXT,       
  WWT_MATRIX,     
  WWT_SCROLLBAR,  
  WWT_FRAME,      
  WWT_CAPTION,    

  WWT_HSCROLLBAR, 
  WWT_STICKYBOX,  
  WWT_SCROLL2BAR, 
  WWT_RESIZEBOX,  
  WWT_CLOSEBOX,   
  WWT_DROPDOWN,   
  WWT_DROPDOWNIN, 
  WWT_EDITBOX,    
  WWT_LAST,       

  WWT_MASK = 0x1F,

  WWT_PUSHBTN     = WWT_PANEL   | WWB_PUSHBUTTON,
  WWT_PUSHTXTBTN  = WWT_TEXTBTN | WWB_PUSHBUTTON,
  WWT_PUSHIMGBTN  = WWT_IMGBTN  | WWB_PUSHBUTTON,
};

#define WIDGETS_END WWT_LAST,   RESIZE_NONE,     0,     0,     0,     0,     0, 0, STR_NULL

enum WindowFlags {
  WF_TIMEOUT_TRIGGER   = 1,       
  WF_TIMEOUT_BEGIN     = 7,       
  WF_TIMEOUT_MASK      = 7,       
  WF_DRAGGING          = 1 <<  3, 
  WF_SCROLL_UP         = 1 <<  4, 
  WF_SCROLL_DOWN       = 1 <<  5, 
  WF_SCROLL_MIDDLE     = 1 <<  6, 
  WF_HSCROLL           = 1 <<  7,
  WF_SIZING            = 1 <<  8,
  WF_STICKY            = 1 <<  9, 

  WF_DISABLE_VP_SCROLL = 1 << 10, 

  WF_WHITE_BORDER_ONE  = 1 << 11,
  WF_WHITE_BORDER_MASK = 1 << 12 | WF_WHITE_BORDER_ONE,
  WF_SCROLL2           = 1 << 13,
};

Window *BringWindowToFrontById(WindowClass cls, WindowNumber number);
Window *FindWindowFromPt(int x, int y);

template <typename Wcls>
Wcls *AllocateWindowDescFront(const WindowDesc *desc, int window_number)
{
  if (BringWindowToFrontById(desc->cls, window_number)) return NULL;
  return new Wcls(desc, window_number);
}

void RelocateAllWindows(int neww, int newh);

/* misc_gui.cpp */
void GuiShowTooltips(StringID str, uint paramcount = 0, const uint64 params[] = NULL, bool use_left_mouse_button = false);

/* widget.cpp */
int GetWidgetFromPos(const Window *w, int x, int y);

/* window.cpp */
extern Window *_z_windows[];
extern Window **_last_z_window;

#define FOR_ALL_WINDOWS(wz) for (wz = _z_windows; wz != _last_z_window; wz++)

enum {
  SCROLL_CON  = 0,
  SCROLL_EDIT = 1,
  SCROLL_SAVE = 2,
  SCROLL_CHAT = 4,
};

extern byte _no_scroll;

extern Point _cursorpos_drag_start;

extern int _scrollbar_start_pos;
extern int _scrollbar_size;
extern byte _scroller_click_timeout;

extern bool _scrolling_scrollbar;
extern bool _scrolling_viewport;

extern byte _special_mouse_mode;
enum SpecialMouseMode {
  WSM_NONE     = 0,
  WSM_DRAGDROP = 1,
  WSM_SIZING   = 2,
  WSM_PRESIZE  = 3,
};

Window *GetCallbackWnd();
Window **FindWindowZPosition(const Window *w);

void ScrollbarClickHandler(Window *w, const Widget *wi, int x, int y);

void ResizeButtons(Window *w, byte left, byte right);

void ResizeWindowForWidget(Window *w, uint widget, int delta_x, int delta_y);

void SetVScrollCount(Window *w, int num);
void SetVScroll2Count(Window *w, int num);
void SetHScrollCount(Window *w, int num);


inline void Window::SetWidgetDisabledState(byte widget_index, bool disab_stat)
{
  assert(widget_index < this->widget_count);
  SB(this->widget[widget_index].display_flags, WIDG_DISABLED, 1, !!disab_stat);
}

inline void Window::DisableWidget(byte widget_index)
{
  SetWidgetDisabledState(widget_index, true);
}

inline void Window::EnableWidget(byte widget_index)
{
  SetWidgetDisabledState(widget_index, false);
}

inline bool Window::IsWidgetDisabled(byte widget_index) const
{
  assert(widget_index < this->widget_count);
  return HasBit(this->widget[widget_index].display_flags, WIDG_DISABLED);
}

inline void Window::SetWidgetHiddenState(byte widget_index, bool hidden_stat)
{
  assert(widget_index < this->widget_count);
  SB(this->widget[widget_index].display_flags, WIDG_HIDDEN, 1, !!hidden_stat);
}

inline void Window::HideWidget(byte widget_index)
{
  SetWidgetHiddenState(widget_index, true);
}

inline void Window::ShowWidget(byte widget_index)
{
  SetWidgetHiddenState(widget_index, false);
}

inline bool Window::IsWidgetHidden(byte widget_index) const
{
  assert(widget_index < this->widget_count);
  return HasBit(this->widget[widget_index].display_flags, WIDG_HIDDEN);
}

inline void Window::SetWidgetLoweredState(byte widget_index, bool lowered_stat)
{
  assert(widget_index < this->widget_count);
  SB(this->widget[widget_index].display_flags, WIDG_LOWERED, 1, !!lowered_stat);
}

inline void Window::ToggleWidgetLoweredState(byte widget_index)
{
  assert(widget_index < this->widget_count);
  ToggleBit(this->widget[widget_index].display_flags, WIDG_LOWERED);
}

inline void Window::LowerWidget(byte widget_index)
{
  SetWidgetLoweredState(widget_index, true);
}

inline void Window::RaiseWidget(byte widget_index)
{
  SetWidgetLoweredState(widget_index, false);
}

inline bool Window::IsWidgetLowered(byte widget_index) const
{
  assert(widget_index < this->widget_count);
  return HasBit(this->widget[widget_index].display_flags, WIDG_LOWERED);
}

inline void Window::AlignWidgetRight(byte widget_index_a, byte widget_index_b)
{
  assert(widget_index_a < this->widget_count);
  assert(widget_index_b < this->widget_count);
  int w = this->widget[widget_index_a].right - this->widget[widget_index_a].left;
  this->widget[widget_index_a].right = this->widget[widget_index_b].left - 1;
  this->widget[widget_index_a].left  = this->widget[widget_index_a].right - w;
}

inline int Window::GetWidgetWidth(byte widget_index) const
{
  assert(widget_index < this->widget_count);
  return this->widget[widget_index].right - this->widget[widget_index].left + 1;
}

#endif /* WINDOW_GUI_H */