fabui.h

Go to the documentation of this file.

/*
  Created by Fabrizio Di Vittorio (fdivitto2013@gmail.com) - <http://www.fabgl.com>
  Copyright (c) 2019-2022 Fabrizio Di Vittorio.
  All rights reserved.
 
 
* Please contact fdivitto2013@gmail.com if you need a commercial license.
 
 
* This library and related software is available under GPL v3.
 
  FabGL 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, either version 3 of the License, or
  (at your option) any later version.
 
  FabGL 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 FabGL.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 
#pragma once
 
 
#include <stdint.h>
#include <stddef.h>
 
#include <list>
 
#include "freertos/FreeRTOS.h"
#include "freertos/queue.h"
#include "freertos/timers.h"
 
#include "fabglconf.h"
#include "fabutils.h"
#include "displaycontroller.h"
#include "canvas.h"
#include "fabfonts.h"
#include "codepages.h"
 
 
 
/*
 
  *uiObject
    *uiEvtHandler
      *uiApp
      *uiWindow
        *uiFrame
        *uiControl
          *uiButton
          *uiLabel
          *uiStaticLabel
          *uiImage
          *uiPanel
          *uiTextEdit
          *uiScrollableControl
            *uiPaintBox
              *uiCustomListBox
                *uiListBox
                *uiColorListBox
                *uiFileBrowser
                *uiSimpleMenu
            uiMemoEdit
          *uiCheckBox
          *uiCustomComboBox
            *uiComboBox
            *uiColorComboBox
            *uiSplitButton
          uiMenu
          uiGauge
          *uiSlider
          uiSpinButton
          *uiColorBox
          *uiProgressBar
 
*/
 
 
namespace fabgl {
 
 
 
// increase in case of garbage between windows!
#define FABGLIB_UI_EVENTS_QUEUE_SIZE 300
 
 
using std::list;
using std::pair;
 
 
// uiEvent
 
enum uiEventID {
  UIEVT_NULL,
  UIEVT_DEBUGMSG,
  UIEVT_APPINIT,
  UIEVT_GENPAINTEVENTS,
  UIEVT_PAINT,
  UIEVT_ACTIVATE,
  UIEVT_DEACTIVATE,
  UIEVT_MOUSEMOVE,
  UIEVT_MOUSEWHEEL,
  UIEVT_MOUSEBUTTONDOWN,
  UIEVT_MOUSEBUTTONUP,
  UIEVT_SETPOS,
  UIEVT_SETSIZE,
  UIEVT_RESHAPEWINDOW,
  UIEVT_MOUSEENTER,
  UIEVT_MOUSELEAVE,
  UIEVT_MAXIMIZE,   // Request for maximize
  UIEVT_MINIMIZE,   // Request for minimize
  UIEVT_RESTORE,    // Restore from UIEVT_MAXIMIZE or UIEVT_MINIMIZE
  UIEVT_SHOW,
  UIEVT_HIDE,
  UIEVT_SETFOCUS,
  UIEVT_KILLFOCUS,
  UIEVT_KEYDOWN,
  UIEVT_KEYUP,
  UIEVT_KEYTYPE,
  UIEVT_TIMER,
  UIEVT_CLICK,
  UIEVT_DBLCLICK,
  UIEVT_EXITMODAL,
  UIEVT_DESTROY,
  UIEVT_CLOSE,      // Request to close (frame Close button)
  UIEVT_QUIT,       // Quit the application
  UIEVT_CREATE,
  UIEVT_CHILDSETFOCUS,  // a UIEVT_SETFOCUS has been sent to a child
  UIEVT_CHILDKILLFOCUS, // a UIEVT_KILLFOCUS has been sent to a child
};
 
 
class uiEvtHandler;
class uiApp;
class uiWindow;
 
 
typedef void * uiTimerHandle;
 
 
struct uiKeyEventInfo {
  VirtualKey VK;         
  uint8_t    ASCII;      
  uint8_t    LALT  : 1;  
  uint8_t    RALT  : 1;  
  uint8_t    CTRL  : 1;  
  uint8_t    SHIFT : 1;  
  uint8_t    GUI   : 1;  
};
 
 
struct uiMouseEventInfo {
  MouseStatus status;         
  uint8_t     changedButton;  
};
 
 
struct uiFocusInfo {
  uiWindow * oldFocused;
  uiWindow * newFocused;
};
 
 
struct uiEvent {
  uiEvtHandler * dest;
  uiEventID      id;
 
  union uiEventParams {
    // event: UIEVT_MOUSEMOVE, UIEVT_MOUSEWHEEL, UIEVT_MOUSEBUTTONDOWN, UIEVT_MOUSEBUTTONUP, UIEVT_CLICK, UIEVT_DBLCLICK
    uiMouseEventInfo mouse;
    // event: UIEVT_PAINT, UIEVT_GENPAINTEVENTS, UIEVT_RESHAPEWINDOW
    Rect rect;
    // event: UIEVT_SETPOS
    Point pos;
    // event: UIEVT_SETSIZE
    Size size;
    // event: UIEVT_DEBUGMSG
    char const * debugMsg;
    // event: UIEVT_KEYDOWN, UIEVT_KEYUP
    uiKeyEventInfo key;
    // event: UIEVT_TIMER
    uiTimerHandle timerHandle;
    // event: UIEVT_EXITMODAL
    int modalResult;
    // event: UIEVT_QUIT
    int exitCode;
    // event: UIEVT_SETFOCUS, UIEVT_KILLFOCUS, UIEVT_CHILDKILLFOCUS, UIEVT_CHILDSETFOCUS
    uiFocusInfo focusInfo;
 
    uiEventParams() { }
  } params;
 
  uiEvent() : dest(nullptr), id(UIEVT_NULL) { }
  uiEvent(uiEvent const & e) { dest = e.dest; id = e.id; params = e.params; }
  uiEvent(uiEvtHandler * dest_, uiEventID id_) : dest(dest_), id(id_) { }
};
 
 
 
enum class uiOrientation {
  Vertical,          
  Horizontal,        
};
 
 
enum class uiHAlign {
  Left,             
  Right,            
  Center,           
};
 
 
 
// uiObject
 
 
struct uiObjectType {
  uint32_t uiApp               : 1;
  uint32_t uiEvtHandler        : 1;
  uint32_t uiWindow            : 1;
  uint32_t uiFrame             : 1;
  uint32_t uiControl           : 1;
  uint32_t uiScrollableControl : 1;
  uint32_t uiButton            : 1;
  uint32_t uiTextEdit          : 1;
  uint32_t uiLabel             : 1;
  uint32_t uiStaticLabel       : 1;
  uint32_t uiImage             : 1;
  uint32_t uiPanel             : 1;
  uint32_t uiPaintBox          : 1;
  uint32_t uiCustomListBox     : 1;
  uint32_t uiListBox           : 1;
  uint32_t uiFileBrowser       : 1;
  uint32_t uiComboBox          : 1;
  uint32_t uiCheckBox          : 1;
  uint32_t uiSlider            : 1;
  uint32_t uiColorListBox      : 1;
  uint32_t uiCustomComboBox    : 1;
  uint32_t uiColorBox          : 1;
  uint32_t uiColorComboBox     : 1;
  uint32_t uiProgressBar       : 1;
  uint32_t uiSplitButton       : 1;
  uint32_t uiSimpleMenu        : 1;
 
  uiObjectType() : uiApp(0), uiEvtHandler(0), uiWindow(0), uiFrame(0), uiControl(0), uiScrollableControl(0), uiButton(0), uiTextEdit(0),
                   uiLabel(0), uiStaticLabel(0), uiImage(0), uiPanel(0), uiPaintBox(0), uiCustomListBox(0), uiListBox(0), uiFileBrowser(0), uiComboBox(0),
                   uiCheckBox(0), uiSlider(0), uiColorListBox(0), uiCustomComboBox(0), uiColorBox(0), uiColorComboBox(0), uiProgressBar(0),
                   uiSplitButton(0), uiSimpleMenu(0)
    { }
};
 
 
class uiObject {
 
public:
 
  uiObject();
 
  virtual ~uiObject();
 
  uiObjectType & objectType() { return m_objectType; }
 
private:
  uiObjectType m_objectType;
};
 
 
 
// uiEvtHandler
 
 
class uiEvtHandler : public uiObject {
 
public:
 
  uiEvtHandler(uiApp * app);
 
  virtual ~uiEvtHandler();
 
  virtual void processEvent(uiEvent * event);
 
  uiApp * app() { return m_app; }
 
 
protected:
 
  void setApp(uiApp * value) { m_app = value; }
 
 
private:
 
  uiApp * m_app;
};
 
 
 
// uiWindow
 
enum class uiOrigin {
  Screen,   
  Parent,   
  Window,   
};
 
 
struct uiWindowState {
  uint8_t visible   : 1;  
  uint8_t active    : 1;  
};
 
 
struct uiWindowProps {
  uint8_t activable  : 1;  
  uint8_t focusable  : 1;  
  uint8_t activeLook : 1;  
  uiWindowProps() :
    activable(true),
    focusable(false),
    activeLook(false)
  { }
};
 
 
struct uiWindowStyle {
  CursorName    defaultCursor      = CursorName::CursorPointerSimpleReduced;  
  RGB888        borderColor        = RGB888(128, 128, 128);                   
  RGB888        activeBorderColor  = RGB888(128, 128, 255);                   
  RGB888        focusedBorderColor = RGB888(0, 0, 255);                       
  uint8_t       borderSize         = 3;                                       
  uint8_t       focusedBorderSize  = 1;                                       
  void adaptToDisplayColors(int displayColors) {
    if (displayColors < 4) {
      borderColor        = RGB888(0, 0, 0);
      activeBorderColor  = RGB888(0, 0, 0);
      focusedBorderColor = RGB888(0, 0, 0);
    } else if (displayColors < 16) {
      borderColor = RGB888(0, 0, 0);
    }
  }
};
 
 
struct uiAnchors {
  uint8_t left   : 1;     
  uint8_t top    : 1;     
  uint8_t right  : 1;     
  uint8_t bottom : 1;     
  uiAnchors() : left(true), top(true), right(false), bottom(false) { }
};
 
 
#define UIWINDOW_PARENTCENTER Point(-1000, -1000)
 
 
class uiWindow : public uiEvtHandler {
 
friend class uiApp;
 
public:
 
  uiWindow(uiWindow * parent, const Point & pos, const Size & size, bool visible, uint32_t styleClassID = 0);
 
  virtual ~uiWindow();
 
  virtual void processEvent(uiEvent * event);
 
  uiWindow * next()  { return m_next; }
 
  uiWindow * prev()  { return m_prev; }
 
  uiWindow * firstChild() { return m_firstChild; }
 
  uiWindow * lastChild() { return m_lastChild; }
 
  bool hasChildren() { return m_firstChild != nullptr; }
 
  void bringOnTop();
 
  void bringAfter(uiWindow * insertionPoint);
 
  Point pos() { return m_pos; }
 
  Point clientPos();
 
  Size size() { return m_size; }
 
  Size clientSize();
 
  Rect rect(uiOrigin origin);
 
  virtual Rect clientRect(uiOrigin origin);
 
  uiWindowState state() { return m_state; }
 
  uiWindowProps & windowProps() { return m_windowProps; }
 
  uiWindowStyle & windowStyle() { return m_windowStyle; }
 
  uiWindow * parent() { return m_parent; }
 
  uiWindow * parentFrame();
 
  Rect transformRect(Rect const & rect, uiWindow * baseWindow);
 
  void repaint(Rect const & rect);
 
  void repaint();
 
  bool isMouseOver() { return m_isMouseOver; }
 
  void exitModal(int modalResult);
 
  bool hasFocus();
 
  bool isActiveWindow();
 
  uiAnchors & anchors() { return m_anchors; }
 
  void setFocusIndex(int value) { m_focusIndex = value; }
 
  int focusIndex()                       { return m_focusIndex; }
 
  Canvas * canvas();
 
  void setStyleClassID(uint16_t value)   { m_styleClassID = value; }
 
  uint16_t styleClassID()                { return m_styleClassID; }
 
  void setParentProcessKbdEvents(bool value) { m_parentProcessKbdEvents = value; }
 
 
protected:
 
  void addChild(uiWindow * child);
  void insertAfter(uiWindow * child, uiWindow * underlyingChild);
  void freeChildren();
  void removeChild(uiWindow * child, bool freeChild = true);
  void moveChildOnTop(uiWindow * child);
  void moveAfter(uiWindow * child, uiWindow * underlyingChild);
  bool isChild(uiWindow * window);
 
  virtual Size minWindowSize()        { return Size(0, 0); }
 
  void beginPaint(uiEvent * paintEvent, Rect const & clippingRect);
 
  void generatePaintEvents(Rect const & paintRect);
  void reshape(Rect const & r);
 
  bool isFocusable();
 
private:
 
  void paintWindow();
 
  uiWindow * findChildWithFocusIndex(int focusIndex, int * maxIndex);
 
 
  uiWindow *    m_parent;
 
  Point         m_pos;
  Size          m_size;
 
  // double linked list, order is: bottom (first items) -> up (last items)
  uiWindow *    m_next;
  uiWindow *    m_prev;
  uiWindow *    m_firstChild;
  uiWindow *    m_lastChild;
 
  uiWindowStyle m_windowStyle;
 
  uiWindowProps m_windowProps;
 
  uiWindowState m_state;
 
  uiAnchors     m_anchors;
 
  int8_t        m_focusIndex;      // -1 = doesn't partecipate to focus trip
 
  uint8_t       m_styleClassID;
 
  uint8_t       m_isMouseOver;     // 1 after mouse entered, 0 after mouse left
  
  uint8_t       m_parentProcessKbdEvents; // if 1 parent processes keyboard events
};
 
 
 
// uiFrame
 
 
struct uiFrameStyle {
  RGB888              backgroundColor                = RGB888(255, 255, 255);  
  RGB888              titleBackgroundColor           = RGB888(128, 128, 128);  
  RGB888              activeTitleBackgroundColor     = RGB888(128, 128, 255);  
  RGB888              titleColor                     = RGB888(0, 0, 0);        
  RGB888              activeTitleColor               = RGB888(255, 255, 255);  
  FontInfo const *    titleFont                      = &FONT_std_12;           
  RGB888              buttonColor                    = RGB888(64, 64, 64);     
  RGB888              activeButtonColor              = RGB888(255, 255, 255);  
  RGB888              mouseOverBackgroundButtonColor = RGB888(0, 0, 255);      
  RGB888              mouseOverButtonColor           = RGB888(255, 255, 255);  
  void adaptToDisplayColors(int displayColors) {
    if (displayColors < 4) {
      titleBackgroundColor           = RGB888(255, 255, 255);
      titleColor                     = RGB888(0, 0, 0);
      buttonColor                    = RGB888(0, 0, 0);
      activeTitleBackgroundColor     = RGB888(0, 0, 0);
      activeTitleColor               = RGB888(255, 255, 255);
      activeButtonColor              = RGB888(255, 255, 255);
      mouseOverButtonColor           = RGB888(0, 0, 0);
      mouseOverBackgroundButtonColor = RGB888(255, 255, 255);
    } else if (displayColors < 16) {
      titleBackgroundColor = RGB888(0, 0, 0);
      titleColor           = RGB888(255, 255, 255);
      buttonColor          = RGB888(255, 255, 255);
      activeButtonColor    = RGB888(0, 0, 0);
    }
  }
};
 
 
struct uiFrameProps {
  uint8_t resizeable        : 1; 
  uint8_t moveable          : 1; 
  uint8_t hasCloseButton    : 1; 
  uint8_t hasMaximizeButton : 1; 
  uint8_t hasMinimizeButton : 1; 
  uint8_t fillBackground    : 1; 
  uiFrameProps() :
    resizeable(true),
    moveable(true),
    hasCloseButton(true),
    hasMaximizeButton(true),
    hasMinimizeButton(true),
    fillBackground(true)
  { }
};
 
 
struct uiFrameState {
  uint8_t maximized : 1;  
  uint8_t minimized : 1;  
};
 
 
enum class uiFrameItem : uint8_t {
  None,                 
  MoveArea,             
  TopLeftResize,        
  TopCenterResize,      
  TopRightResize,       
  CenterLeftResize,     
  CenterRightResize,    
  BottomLeftResize,     
  BottomCenterResize,   
  BottomRightResize,    
  CloseButton,          
  MaximizeButton,       
  MinimizeButton,       
};
 
 
class uiFrame : public uiWindow {
 
public:
 
  uiFrame(uiWindow * parent, char const * title, const Point & pos, const Size & size, bool visible = true, uint32_t styleClassID = 0);
 
  virtual ~uiFrame();
 
  virtual void processEvent(uiEvent * event);
 
  char const * title() { return m_title; }
 
  void setTitle(char const * value);
 
  void setTitleFmt(const char *format, ...);
 
  uiFrameStyle & frameStyle() { return m_frameStyle; }
 
  uiFrameProps & frameProps() { return m_frameProps; }
 
  Rect clientRect(uiOrigin origin);
 
  int getNextFreeFocusIndex() { return m_nextFreeFocusIndex++; }
 
  uiFrameState frameState() { return m_frameState; }
 
 
 
  // Delegates
 
  Delegate<> onShow;
 
  Delegate<> onHide;
 
  Delegate<> onResize;
 
  Delegate<uiTimerHandle> onTimer;
 
  Delegate<uiKeyEventInfo const &> onKeyDown;
 
  Delegate<uiKeyEventInfo const &> onKeyUp;
 
  Delegate<> onPaint;
 
 
protected:
 
  Size minWindowSize();
  int titleBarHeight();
  Rect titleBarRect();
 
private:
 
  void paintFrame();
  int paintButtons(Rect const & bkgRect);
  void movingCapturedMouse(int mouseX, int mouseY, bool mouseIsDown);
  void movingFreeMouse(int mouseX, int mouseY);
  uiFrameItem getFrameItemAt(int x, int y);
  Rect getBtnRect(int buttonIndex);
  void handleButtonsClick(int x, int y, bool doubleClick);
  void drawTextWithEllipsis(FontInfo const * fontInfo, int X, int Y, char const * text, int maxX);
  void drawReshapingBox(Rect boxRect);
 
 
  static constexpr int CORNERSENSE = 10;
 
 
  uiFrameStyle       m_frameStyle;
 
  uiFrameProps       m_frameProps;
 
  char *             m_title;
  int                m_titleLength;
 
  uiFrameItem        m_mouseDownFrameItem;  // frame item on mouse down
  uiFrameItem        m_mouseMoveFrameItem;  // frame item on mouse move
 
  Rect               m_lastReshapingBox;    // last reshaping box painted by drawReshapingBox(), (0,0,0,0) if there isn't any
 
  int                m_nextFreeFocusIndex;
 
  Point              m_mouseDownPos;        // mouse position when mouse down event has been received
 
  Rect               m_savedScreenRect;     // saved screen rect before Maximize or Minimize
 
  Size               m_sizeAtMouseDown;     // used to resize
 
  uiFrameState       m_frameState;
};
 
 
 
// uiControl
 
 
class uiControl : public uiWindow {
 
public:
 
  uiControl(uiWindow * parent, const Point & pos, const Size & size, bool visible, uint32_t styleClassID = 0);
 
  virtual ~uiControl();
 
  virtual void processEvent(uiEvent * event);
};
 
 
 
// uiScrollableControl
 
 
struct uiScrollableControlStyle {
  RGB888  scrollBarBackgroundColor          = RGB888(64, 64, 64);     
  RGB888  scrollBarForegroundColor          = RGB888(128, 128, 128);  
  RGB888  mouseOverScrollBarForegroundColor = RGB888(255, 255, 255);  
  uint8_t scrollBarSize                     = 11;                     
  void adaptToDisplayColors(int displayColors) {
    if (displayColors < 16) {
      mouseOverScrollBarForegroundColor = RGB888(0, 0, 255);
    }
  }
};
 
 
enum class uiScrollBarItem {
  None,           
  LeftButton,     
  RightButton,    
  TopButton,      
  BottomButton,   
  HBar,           
  VBar,           
  PageUp,         
  PageDown,       
  PageLeft,       
  PageRight,      
};
 
 
class uiScrollableControl : public uiControl {
 
public:
 
  uiScrollableControl(uiWindow * parent, const Point & pos, const Size & size, bool visible = true, uint32_t styleClassID = 0);
 
  virtual ~uiScrollableControl();
 
  virtual void processEvent(uiEvent * event);
 
  Rect clientRect(uiOrigin origin);
 
  uiScrollableControlStyle & scrollableControlStyle() { return m_scrollableControlStyle; }
 
  int HScrollBarPos()     { return m_HScrollBarPosition; }
 
  int HScrollBarVisible() { return m_HScrollBarVisible; }
 
  int HScrollBarRange()   { return m_HScrollBarRange; }
 
  int VScrollBarPos()     { return m_VScrollBarPosition; }
 
  int VScrollBarVisible() { return m_VScrollBarVisible; }
 
  int VScrollBarRange()  { return m_VScrollBarRange; }
 
 
  // Delegates
 
  Delegate<> onChangeHScrollBar;
 
  Delegate<> onChangeVScrollBar;
 
 
protected:
 
  virtual void setScrollBar(uiOrientation orientation, int position, int visible, int range, bool repaintScrollbar = true);
 
 
private:
 
  void paintScrollableControl();
  void paintScrollBars();
  Rect getVScrollBarRects(Rect * topButton = nullptr, Rect * bottonButton = nullptr, Rect * bar = nullptr);
  Rect getHScrollBarRects(Rect * leftButton = nullptr, Rect * rightButton = nullptr, Rect * bar = nullptr);
  uiScrollBarItem getItemAt(int x, int y);
  void repaintScrollBar(uiOrientation orientation);
  void handleFreeMouseMove(int mouseX, int mouseY);
  void handleCapturedMouseMove(int mouseX, int mouseY);
  void handleButtonsScroll();
  void handlePageScroll();
 
  uiScrollableControlStyle m_scrollableControlStyle;
 
  int16_t         m_HScrollBarPosition;
  int16_t         m_HScrollBarVisible;    // it means the "visible" area (how big is the bar)
  int16_t         m_HScrollBarRange;
  int16_t         m_VScrollBarPosition;
  int16_t         m_VScrollBarVisible;    // it means the "visible" area (how big is the bar)
  int16_t         m_VScrollBarRange;
 
  // values updated by getVScrollBarRects() and getHScrollBarRects()
  int16_t         m_HBarArea;
  int16_t         m_VBarArea;
 
  int16_t         m_mouseDownHScrollBarPosition;
  int16_t         m_mouseDownVScrollBarPosition;
 
  uiScrollBarItem m_mouseOverItem;
 
  // a timer is active while mouse is down and the mouse is over a button
  uiTimerHandle   m_scrollTimer;
 
  Point           m_mouseDownPos;    // mouse position when mouse down event has been received
};
 
 
 
// uiButton
 
 
struct uiButtonStyle {
  RGB888           backgroundColor          = RGB888(128, 128, 128); 
  RGB888           downBackgroundColor      = RGB888(0, 255, 0);     
  RGB888           mouseOverBackgroundColor = RGB888(255, 255, 255); 
  RGB888           mouseDownBackgroundColor = RGB888(128, 128, 255); 
  RGB888           mouseOverTextColor       = RGB888(0, 0, 0);       
  RGB888           textColor                = RGB888(0, 0, 0);       
  RGB888           downTextColor            = RGB888(0, 0, 0);       
  FontInfo const * textFont                 = &FONT_std_14;          
  uint8_t          bitmapTextSpace          = 4;                     
  Bitmap const *   bitmap                   = nullptr;               
  Bitmap const *   downBitmap               = nullptr;               
  void adaptToDisplayColors(int displayColors) {
    if (displayColors < 4) {
      mouseOverBackgroundColor = RGB888(0, 0, 0);
      mouseOverTextColor       = RGB888(255, 255, 255);
      downTextColor            = RGB888(255, 255, 255);
      downBackgroundColor      = RGB888(0, 0, 0);
    } else if (displayColors < 16) {
      mouseOverBackgroundColor = RGB888(255, 255, 255);
      mouseDownBackgroundColor = RGB888(255, 255, 255);
      backgroundColor          = RGB888(0, 0, 255);
      downBackgroundColor      = RGB888(0, 128, 0);
      downTextColor            = displayColors < 8 ? RGB888(0, 0, 0) : RGB888(255, 255, 255);
      textColor                = RGB888(255, 255, 255);
      mouseOverTextColor       = RGB888(0, 0, 0);
    }
  }
};
 
 
enum class uiButtonKind {
  Button,   
  Switch,   
};
 
 
class uiButton : public uiControl {
 
public:
 
  uiButton(uiWindow * parent, char const * text, const Point & pos, const Size & size, uiButtonKind kind = uiButtonKind::Button, bool visible = true, uint32_t styleClassID = 0);
 
  virtual ~uiButton();
 
  virtual void processEvent(uiEvent * event);
 
  void setText(char const * value);
 
  char const * text() { return m_text; }
 
  uiButtonStyle & buttonStyle() { return m_buttonStyle; }
 
  bool down() { return m_down; }
 
  void setDown(bool value);
 
 
  // Delegates
 
  Delegate<> onChange;
 
  Delegate<> onClick;
 
  Delegate<uiMouseEventInfo const&> onMouseDown;
 
  Delegate<uiMouseEventInfo const&> onMouseUp;
 
 
private:
 
  void paintButton();
  void paintContent(Rect const & rect);
 
  void trigger();
 
 
  uiButtonStyle  m_buttonStyle;
 
  char *         m_text;
  int            m_textExtent;  // calculated by setText(). TODO: changing font doesn't update m_textExtent!
 
  bool           m_down;
 
  uiButtonKind   m_kind;
 
};
 
 
 
// uiTextEdit
// single line text edit
 
 
struct uiTextEditStyle {
  RGB888           backgroundColor            = RGB888(128, 128, 128);     
  RGB888           mouseOverBackgroundColor   = RGB888(255, 255, 255);     
  RGB888           focusedBackgroundColor     = RGB888(255, 255, 255);     
  RGB888           textColor                  = RGB888(0, 0, 0);           
  FontInfo const * textFont                   = &FONT_std_14;              
  void adaptToDisplayColors(int displayColors) {
    if (displayColors < 16) {
    }
  }
};
 
 
struct uiTextEditProps {
  uint8_t hasCaret     : 1;   
  uint8_t allowEdit    : 1;   
  uint8_t passwordMode : 1;   
  uiTextEditProps()
    : hasCaret(true),
      allowEdit(true),
      passwordMode(false)
    {
    }
};
 
 
class uiTextEdit : public uiControl {
 
public:
 
  uiTextEdit(uiWindow * parent, char const * text, const Point & pos, const Size & size, bool visible = true, uint32_t styleClassID = 0);
 
  virtual ~uiTextEdit();
 
  virtual void processEvent(uiEvent * event);
 
  uiTextEditStyle & textEditStyle() { return m_textEditStyle; }
 
  uiTextEditProps & textEditProps() { return m_textEditProps; }
 
  void setText(char const * value);
 
  void setTextFmt(const char *format, ...);
 
  char const * text() { return m_text; }
 
 
  // Delegates
 
  Delegate<> onChange;
 
  Delegate<uiKeyEventInfo const &> onKeyType;
  
 
 
protected:
 
  virtual Rect getEditRect();
 
private:
 
  void paintTextEdit();
  void paintContent();
 
  uint8_t const * getCharInfo(char ch, int * width);
  int charColumnToWindowX(int col);
  void updateCaret();
  void moveCursor(int col, int selCol);
  int getColFromMouseX(int mouseX);
  void handleKeyDown(uiKeyEventInfo const & key);
  void checkAllocatedSpace(int requiredLength);
  void insert(char c);
  void removeSel();
  int getWordPosAtLeft();
  int getWordPosAtRight();
  void selectWordAt(int mouseX);
  int keyToASCII(uiKeyEventInfo const & key);
 
 
  uiTextEditStyle m_textEditStyle;
  uiTextEditProps m_textEditProps;
 
  char *           m_text;
  int              m_textLength; // text length NOT including ending zero
  int              m_textSpace;  // actual space allocated including ending zero
 
  // rectangle where text will be painted (this is also the text clipping rect)
  Rect             m_contentRect;  // updated on painting
 
  // where text starts to be painted. Values less than m_contentRect.X1 are used to show characters which do not fit in m_contentRect
  int              m_viewX;
 
  // character index of cursor position (0 = at first char)
  int              m_cursorCol;
 
  // character index at start of selection (not included if < m_cursorCol, included if > m_cursorCol)
  int              m_selCursorCol;
 
  CodePage const * m_codepage;
 
};
 
 
 
// uiLabel
 
 
struct uiLabelStyle {
  FontInfo const * textFont                 = &FONT_std_14;              
  RGB888           backgroundColor          = RGB888(255, 255, 255);     
  RGB888           textColor                = RGB888(0, 0, 0);           
  uiHAlign         textAlign                = uiHAlign::Left;            
  void adaptToDisplayColors(int displayColors) {
    if (displayColors < 16) {
    }
  }
};
 
 
class uiLabel : public uiControl {
 
public:
 
  uiLabel(uiWindow * parent, char const * text, const Point & pos, const Size & size = Size(0, 0), bool visible = true, uint32_t styleClassID = 0);
 
  virtual ~uiLabel();
 
  virtual void processEvent(uiEvent * event);
 
  void setText(char const * value);
 
  void setTextFmt(const char *format, ...);
 
  char const * text() { return m_text; }
 
  uiLabelStyle & labelStyle() { return m_labelStyle; }
 
  void update();
 
  Delegate<> onClick;
 
 
private:
 
  void paintLabel();
 
 
  char *         m_text;
 
  uiLabelStyle   m_labelStyle;
 
  uint8_t        m_autoSize;
 
};
 
 
 
// uiStaticLabel
 
 
struct uiStaticLabelStyle {
  FontInfo const * textFont                 = &FONT_std_14;              
  RGB888           backgroundColor          = RGB888(255, 255, 255);     
  RGB888           textColor                = RGB888(0, 0, 0);           
  void adaptToDisplayColors(int displayColors) {
    if (displayColors < 16) {
    }
  }
};
 
 
class uiStaticLabel : public uiControl {
 
public:
 
  uiStaticLabel(uiWindow * parent, char const * text, const Point & pos, bool visible = true, uint32_t styleClassID = 0);
  
  virtual void processEvent(uiEvent * event);
 
  void setText(char const * value);
 
  char const * text() { return m_text; }
 
  uiStaticLabelStyle & labelStyle() { return m_staticLabelStyle; }
 
  void update();
 
 
private:
 
  void paintLabel();
 
 
  char const *       m_text;
 
  uiStaticLabelStyle m_staticLabelStyle;
 
};
 
 
 
// uiImage
 
 
struct uiImageStyle {
  RGB888 backgroundColor = RGB888(255, 255, 255);   
  void adaptToDisplayColors(int displayColors) {
    if (displayColors < 16) {
    }
  }
};
 
 
class uiImage : public uiControl {
 
public:
 
  uiImage(uiWindow * parent, Bitmap const * bitmap, const Point & pos, const Size & size = Size(0, 0), bool visible = true, uint32_t styleClassID = 0);
 
  virtual ~uiImage();
 
  virtual void processEvent(uiEvent * event);
 
  void setBitmap(Bitmap const * bitmap);
 
  Bitmap const * bitmap() { return m_bitmap; }
 
  uiImageStyle & imageStyle() { return m_imageStyle; }
 
 
private:
 
  void paintImage();
 
 
  Bitmap const * m_bitmap;
 
  uiImageStyle   m_imageStyle;
 
  bool           m_autoSize;
 
};
 
 
 
// uiPanel
 
 
struct uiPanelStyle {
  RGB888 backgroundColor = RGB888(128, 128, 128);    
  void adaptToDisplayColors(int displayColors) {
    if (displayColors < 16) {
    }
  }
};
 
 
class uiPanel : public uiControl {
 
public:
 
  uiPanel(uiWindow * parent, const Point & pos, const Size & size, bool visible = true, uint32_t styleClassID = 0);
 
  virtual ~uiPanel();
 
  virtual void processEvent(uiEvent * event);
 
  uiPanelStyle & panelStyle() { return m_panelStyle; }
 
 
private:
 
  void paintPanel();
 
 
  uiPanelStyle   m_panelStyle;
};
 
 
 
// uiPaintBox
 
 
struct uiPaintBoxStyle {
  RGB888 backgroundColor = RGB888(128, 128, 128);   
  void adaptToDisplayColors(int displayColors) {
    if (displayColors < 16) {
    }
  }
};
 
 
class uiPaintBox : public uiScrollableControl {
 
public:
 
  uiPaintBox(uiWindow * parent, const Point & pos, const Size & size, bool visible = true, uint32_t styleClassID = 0);
 
  virtual ~uiPaintBox();
 
  virtual void processEvent(uiEvent * event);
 
  uiPaintBoxStyle & paintBoxStyle() { return m_paintBoxStyle; }
 
  using uiScrollableControl::setScrollBar;
 
  // Delegates
 
  Delegate<Rect const &> onPaint;
 
 
private:
 
  void paintPaintBox();
 
 
  uiPaintBoxStyle m_paintBoxStyle;
};
 
 
 
// uiColorBox
 
class uiColorBox : public uiControl {
 
public:
 
  uiColorBox(uiWindow * parent, const Point & pos, const Size & size, Color color = Color::BrightWhite, bool visible = true, uint32_t styleClassID = 0);
 
  virtual ~uiColorBox();
 
  virtual void processEvent(uiEvent * event);
 
  Color color() { return m_color; }
 
  void setColor(Color value);
 
private:
 
  void paintColorBox();
 
 
  Color m_color;
};
 
 
 
// uiCustomListBox
 
 
struct uiListBoxStyle {
  RGB888           backgroundColor                = RGB888(128, 128, 128);   
  RGB888           focusedBackgroundColor         = RGB888(255, 255, 255);   
  RGB888           selectedBackgroundColor        = RGB888(0, 0, 255);       
  RGB888           focusedSelectedBackgroundColor = RGB888(0, 0, 255);       
  int              itemHeight                     = 16;                      
  FontInfo const * textFont                       = &FONT_std_14;            
  RGB888           textColor                      = RGB888(0, 0, 0);         
  RGB888           selectedTextColor              = RGB888(255, 255, 255);   
  void adaptToDisplayColors(int displayColors) {
    if (displayColors < 4) {
      selectedBackgroundColor        = RGB888(0, 0, 0);
      focusedSelectedBackgroundColor = RGB888(0, 0, 0);
      selectedTextColor              = RGB888(255, 255, 255);
    }
  }
};
 
 
struct uiListBoxProps {
  uint8_t allowMultiSelect  : 1;   
  uint8_t selectOnMouseOver : 1;   
  uiListBoxProps()
    : allowMultiSelect(true),
      selectOnMouseOver(false)
    {
    }
};
 
 
class uiCustomListBox : public uiScrollableControl {
 
public:
 
  uiCustomListBox(uiWindow * parent, const Point & pos, const Size & size, bool visible = true, uint32_t styleClassID = 0);
 
  virtual ~uiCustomListBox();
 
  virtual void processEvent(uiEvent * event);
 
  uiListBoxStyle & listBoxStyle() { return m_listBoxStyle; }
 
  uiListBoxProps & listBoxProps() { return m_listBoxProps; }
 
  int firstSelectedItem();
 
  int lastSelectedItem();
 
  void selectItem(int index, bool add = false, bool range = false);
 
  void deselectAll();
 
 
  // Delegates
 
  Delegate<> onChange;
 
  Delegate<> onKillFocus;
 
  Delegate<uiKeyEventInfo const &> onKeyType;
 
  Delegate<uiKeyEventInfo const &> onKeyUp;
 
  Delegate<> onClick;
 
  Delegate<> onDblClick;
 
 
 
protected:
 
  void setScrollBar(uiOrientation orientation, int position, int visible, int range, bool repaintScrollbar);
  int getItemAtMousePos(int mouseX, int mouseY);
 
  // must be implemented by inherited class
  virtual int items_getCount()                              = 0;
  virtual void items_deselectAll()                          = 0;
  virtual void items_select(int index, bool select)         = 0;
  virtual bool items_selected(int index)                    = 0;
  virtual void items_draw(int index, const Rect & itemRect) = 0;
 
private:
 
  void paintListBox();
  void mouseDownSelect(int mouseX, int mouseY);
  void mouseMoveSelect(int mouseX, int mouseY);
  void handleKeyDown(uiKeyEventInfo key);
  void makeItemVisible(int index);
 
 
  uiListBoxStyle m_listBoxStyle;
  uiListBoxProps m_listBoxProps;
  int            m_firstVisibleItem;     // the item on the top
};
 
 
 
// uiListBox
 
 
class uiListBox : public uiCustomListBox {
 
public:
 
  uiListBox(uiWindow * parent, const Point & pos, const Size & size, bool visible = true, uint32_t styleClassID = 0);
 
  StringList & items()                              { return m_items; }
 
protected:
 
  virtual int items_getCount()                      { return m_items.count(); }
  virtual void items_deselectAll()                  { m_items.deselectAll(); }
  virtual void items_select(int index, bool select) { m_items.select(index, select); }
  virtual bool items_selected(int index)            { return m_items.selected(index); }
  virtual void items_draw(int index, const Rect & itemRect);
 
 
private:
 
  StringList     m_items;
};
 
 
// uiFileBrowser
 
class uiFileBrowser : public uiCustomListBox {
 
public:
 
  uiFileBrowser(uiWindow * parent, const Point & pos, const Size & size, bool visible = true, uint32_t styleClassID = 0);
 
  void setDirectory(char const * path);
 
  void changeDirectory(char const * path);
 
  char const * directory() { return m_dir.directory(); }
 
  int count()              { return m_dir.count(); }
 
  char const * filename();
 
  bool isDirectory();
 
  void processEvent(uiEvent * event);
 
  void update();
 
  FileBrowser & content() { return m_dir; }
 
 
protected:
 
  virtual int items_getCount()                      { return m_dir.count(); }
  virtual void items_deselectAll()                  { m_selected = -1; }
  virtual void items_select(int index, bool select);
  virtual bool items_selected(int index)            { return index == m_selected; }
  virtual void items_draw(int index, const Rect & itemRect);
 
private:
 
  void enterSubDir();
 
  FileBrowser m_dir;
  int         m_selected;  // -1 = no sel
 
};
 
 
// uiColorListBox
 
class uiColorListBox : public uiCustomListBox {
 
public:
 
  uiColorListBox(uiWindow * parent, const Point & pos, const Size & size, bool visible = true, uint32_t styleClassID = 0);
 
  Color color();
 
 
protected:
 
  virtual int items_getCount()                      { return 16; }
  virtual void items_deselectAll()                  { }
  virtual void items_select(int index, bool select) { if (select) m_selectedColor = (Color)index; }
  virtual bool items_selected(int index)            { return index == (int)m_selectedColor; }
  virtual void items_draw(int index, const Rect & itemRect);
 
 
private:
 
  Color m_selectedColor;
};
 
 
 
// uiCustomComboBox
 
 
struct uiComboBoxStyle {
  RGB888 buttonBackgroundColor = RGB888(64, 64, 64);     
  RGB888 buttonColor           = RGB888(128, 128, 128);  
  void adaptToDisplayColors(int displayColors) {
    if (displayColors < 16) {
    }
  }
};
 
 
struct uiComboBoxProps {
  uint8_t openOnFocus  : 1;  
  uiComboBoxProps()
    : openOnFocus(true)
  {
  }
};
 
 
class uiCustomComboBox : public uiControl
{
 
public:
 
  uiCustomComboBox(uiWindow * parent, const Point & pos, const Size & size, int listHeight, bool visible, uint32_t styleClassID);
 
  ~uiCustomComboBox();
 
  virtual void processEvent(uiEvent * event);
 
  uiComboBoxStyle & comboBoxStyle() { return m_comboBoxStyle; }
 
  uiListBoxStyle & listBoxStyle() { return listbox()->listBoxStyle(); }
 
  uiComboBoxProps & comboBoxProps() { return m_comboBoxProps; }
 
  int selectedItem() { return listbox()->firstSelectedItem(); }
 
  void selectItem(int index);
 
 
  // Delegates
 
  Delegate<> onChange;
 
 
protected:
 
  virtual uiCustomListBox * listbox() = 0;
  virtual uiControl * editcontrol()   = 0;
  virtual void updateEditControl()    = 0;
 
  Size getEditControlSize();
 
  virtual void openListBox();
  virtual void closeListBox();
  void switchListBox();
 
  virtual void paintButton();
  Rect getButtonRect();
 
  uiWindow * getListBoxParent() { return m_listBoxParent; }
 
  bool isListBoxOpen()          { return m_listBoxParent->state().visible; }
 
private:
 
  int buttonWidth();
 
 
  int16_t           m_listHeight;
  int16_t           m_loseFocusBy;
  uiComboBoxStyle   m_comboBoxStyle;
  uiComboBoxProps   m_comboBoxProps;
  uiWindow *        m_listBoxParent;
};
 
 
 
 
// uiComboBox
 
 
class uiComboBox : public uiCustomComboBox
{
 
public:
 
  uiComboBox(uiWindow * parent, const Point & pos, const Size & size, int listHeight, bool visible = true, uint32_t styleClassID = 0);
 
  ~uiComboBox();
 
  StringList & items() { return m_listBox->items(); }
 
  uiTextEditStyle & textEditStyle() { return m_textEdit->textEditStyle(); }
 
  uiTextEditProps & textEditProps() { return m_textEdit->textEditProps(); }
 
  void setText(char const * value) { m_textEdit->setText(value); }
 
  char const * text() { return m_textEdit->text(); }
 
 
protected:
 
  uiCustomListBox * listbox()  { return m_listBox; }
  uiControl * editcontrol()    { return m_textEdit; }
  void updateEditControl();
 
private:
  uiTextEdit * m_textEdit;
  uiListBox *  m_listBox;
 
};
 
 
 
// uiColorComboBox
 
 
class uiColorComboBox : public uiCustomComboBox
{
 
public:
 
  uiColorComboBox(uiWindow * parent, const Point & pos, const Size & size, int listHeight, bool visible = true, uint32_t styleClassID = 0);
 
  ~uiColorComboBox();
 
  void selectColor(Color value) { selectItem((int)value); }
 
  Color selectedColor()         { return (Color) selectedItem(); }
 
 
protected:
 
  uiCustomListBox * listbox()  { return m_colorListBox; }
  uiControl * editcontrol()    { return m_colorBox; }
  void updateEditControl();
 
private:
  uiColorBox *     m_colorBox;
  uiColorListBox * m_colorListBox;
 
};
 
 
 
// uiCheckBox
 
 
struct uiCheckBoxStyle {
  RGB888              backgroundColor          = RGB888(128, 128, 128);  
  RGB888              checkedBackgroundColor   = RGB888(128, 128, 128);  
  RGB888              mouseOverBackgroundColor = RGB888(128, 128, 255);  
  RGB888              mouseOverForegroundColor = RGB888(0, 0, 0);        
  RGB888              foregroundColor          = RGB888(0, 0, 0);        
  void adaptToDisplayColors(int displayColors) {
    if (displayColors < 4) {
    } else if (displayColors < 16) {
      mouseOverForegroundColor = RGB888(255, 255, 255);
    }
  }
};
 
 
enum class uiCheckBoxKind : int8_t {
  CheckBox,          
  RadioButton,       
};
 
 
class uiCheckBox : public uiControl {
 
public:
 
  uiCheckBox(uiWindow * parent, const Point & pos, const Size & size, uiCheckBoxKind kind = uiCheckBoxKind::CheckBox, bool visible = true, uint32_t styleClassID = 0);
 
  virtual ~uiCheckBox();
 
  virtual void processEvent(uiEvent * event);
 
  uiCheckBoxStyle & checkBoxStyle() { return m_checkBoxStyle; }
 
  bool checked()                    { return m_checked; }
 
  void setChecked(bool value);
 
  int groupIndex()                  { return m_groupIndex; }
 
  void setGroupIndex(int value)     { m_groupIndex = value; }
 
 
  // Delegates
 
  Delegate<> onChange;
 
  Delegate<> onClick;
 
 
private:
 
  void paintCheckBox();
  void trigger();
  void unCheckGroup();
 
 
  uiCheckBoxStyle m_checkBoxStyle;
  bool            m_checked;
  uiCheckBoxKind  m_kind;
  int16_t         m_groupIndex; // -1 = no group
 
};
 
 
 
// uiSlider
 
 
struct uiSliderStyle {
  RGB888 backgroundColor    = RGB888(255, 255, 255);    
  RGB888 slideColor         = RGB888(0, 128, 128);      
  RGB888 rangeColor         = RGB888(0, 128, 255);      
  RGB888 gripColor          = RGB888(0, 0, 255);        
  RGB888 ticksColor         = RGB888(255, 255, 255);    
  RGB888 mouseOverGripColor = RGB888(255, 255, 255);        
  void adaptToDisplayColors(int displayColors) {
    if (displayColors < 4) {
      slideColor         = RGB888(0, 0, 0);
      rangeColor         = RGB888(0, 0, 0);
      gripColor          = RGB888(0, 0, 0);
      mouseOverGripColor = RGB888(255, 255, 255);
    } else if (displayColors < 16) {
      slideColor         = RGB888(0, 0, 0);
      mouseOverGripColor = RGB888(255, 255, 255);
    }
  }
};
 
 
class uiSlider : public uiControl {
 
public:
 
  uiSlider(uiWindow * parent, const Point & pos, const Size & size, uiOrientation orientation, bool visible = true, uint32_t styleClassID = 0);
 
  virtual ~uiSlider();
 
  virtual void processEvent(uiEvent * event);
 
  uiSliderStyle & sliderStyle() { return m_sliderStyle; }
 
  int position() { return m_position; }
 
  void setPosition(int value);
 
  int min() { return m_min; }
 
  int max() { return m_max; }
 
  void setup(int min, int max, int ticksFrequency);
 
 
  Delegate<> onChange;
 
 
private:
 
  void paintSlider();
  Rect getGripRect();
  void moveGripTo(int x, int y);
  void handleKeyDown(uiKeyEventInfo key);
 
 
  uiSliderStyle m_sliderStyle;
  uiOrientation m_orientation;
 
  int16_t       m_position;
  int16_t       m_min;
  int16_t       m_max;
  int16_t       m_ticksFrequency;
};
 
 
 
// uiProgressBar
 
 
struct uiProgressBarStyle {
  RGB888           backgroundColor = RGB888(128, 128, 128);   
  RGB888           foregroundColor = RGB888(64, 128, 64);     
  FontInfo const * textFont        = &FONT_std_14;            
  RGB888           textColor       = RGB888(255, 255, 255);   
  void adaptToDisplayColors(int displayColors) {
    if (displayColors < 4) {
      foregroundColor = RGB888(0, 0, 0);
    } else if (displayColors < 8) {
      textColor       = RGB888(0, 0, 0);
    }
  }
};
 
 
struct uiProgressBarProps {
  uint8_t showPercentage : 1;   
  uiProgressBarProps()
    : showPercentage(true)
    {
    }
};
 
 
class uiProgressBar : public uiControl {
 
public:
 
  uiProgressBar(uiWindow * parent, const Point & pos, const Size & size, bool visible = true, uint32_t styleClassID = 0);
 
  virtual ~uiProgressBar();
 
  virtual void processEvent(uiEvent * event);
 
  uiProgressBarStyle & progressBarStyle() { return m_progressBarStyle; }
 
  uiProgressBarProps & progressBarProps() { return m_progressBarProps; }
 
  void setPercentage(int value);
 
 
private:
 
  void paintProgressBar();
 
 
  uiProgressBarStyle   m_progressBarStyle;
  uiProgressBarProps   m_progressBarProps;
 
  int                  m_percentage;
};
 
 
 
// uiSimpleMenu
 
 
class uiSimpleMenu : public uiCustomListBox {
 
public:
 
  uiSimpleMenu(uiWindow * parent, const Point & pos, const Size & size, bool visible = true, uint32_t styleClassID = 0);
 
  StringList & items()                              { return m_items; }
 
  virtual void processEvent(uiEvent * event);
 
 
  // Delegates
 
  Delegate<int> onSelect;
 
protected:
 
  virtual int items_getCount()                      { return m_items.count(); }
  virtual void items_deselectAll()                  { m_items.deselectAll(); }
  virtual void items_select(int index, bool select) { m_items.select(index, select); }
  virtual bool items_selected(int index)            { return m_items.selected(index); }
  virtual void items_draw(int index, const Rect & itemRect);
 
 
private:
 
  StringList     m_items;
};
 
 
 
 
// uiSplitButton
 
 
class uiSplitButton : public uiCustomComboBox
{
 
public:
 
  uiSplitButton(uiWindow * parent, char const * text, const Point & pos, const Size & size, int listHeight, char const * itemsText, char separator = ';', bool visible = true, uint32_t styleClassID = 0);
 
  ~uiSplitButton();
 
  StringList & items()         { return m_menu->items(); }
 
  void processEvent(uiEvent * event);
 
 
  // Delegates
 
  Delegate<int> onSelect;
 
 
protected:
 
  uiCustomListBox * listbox()  { return m_menu; }
  uiControl * editcontrol()    { return m_button; }
  void updateEditControl();
  virtual void openListBox();
  virtual void paintButton();
 
private:
  uiButton *     m_button;
  uiSimpleMenu * m_menu;
  int            m_selectedItem;
 
};
 
 
 
// uiStyle
 
struct uiStyle {
  virtual void setStyle(uiObject * object, uint32_t styleClassID) = 0;
};
 
 
 
// uiApp
 
 
struct uiAppProps {
  uint16_t caretBlinkingTime = 500;   
  uint16_t doubleClickTime   = 250;   
  bool     realtimeReshaping = false; 
  bool     realtimeMoving    = false; 
};
 
 
enum class uiMessageBoxResult {
  Cancel   = 0,   
  Button1  = 1,   
  ButtonOK = 1,   
  Button2  = 2,   
  Button3  = 3,   
};
 
 
enum class uiMessageBoxIcon {
  None,      
  Question,  
  Info,      
  Warning,   
  Error,     
};
 
 
struct ModalWindowState {
  uiWindow * window;
  uiWindow * prevFocusedWindow;
  uiWindow * prevActiveWindow;
  uiWindow * prevModal;
  int        modalResult;
};
 
 
typedef pair<uiEvtHandler *, TimerHandle_t> uiTimerAssoc;
 
 
class Keyboard;
class Mouse;
 
 
class uiApp : public uiEvtHandler {
 
public:
 
  uiApp();
 
  virtual ~uiApp();
 
  int run(BitmappedDisplayController * displayController, Keyboard * keyboard = nullptr, Mouse * mouse = nullptr);
 
  uiApp & runAsync(BitmappedDisplayController * displayController, int taskStack = 3000, Keyboard * keyboard = nullptr, Mouse * mouse = nullptr);
 
  void joinAsyncRun();
 
  void quit(int exitCode);
 
  bool postEvent(uiEvent const * event);
 
  bool insertEvent(uiEvent const * event);
 
  void postDebugMsg(char const * msg);
 
  virtual void processEvent(uiEvent * event);
 
  void processEvents();
 
  uiFrame * rootWindow() { return m_rootWindow; }
 
  uiWindow * activeWindow() { return m_activeWindow; }
 
  uiWindow * setActiveWindow(uiWindow * value);
 
  uiWindow * focusedWindow() { return m_focusedWindow; }
 
  uiWindow * setFocusedWindow(uiWindow * value);
 
  uiWindow * moveFocus(int delta);
 
  void captureMouse(uiWindow * window);
 
  uiWindow * capturedMouseWindow() { return m_capturedMouseWindow; }
 
  void repaintWindow(uiWindow * window);
 
  void repaintRect(Rect const & rect);
 
  void moveWindow(uiWindow * window, int x, int y);
 
  void resizeWindow(uiWindow * window, int width, int height);
 
  void resizeWindow(uiWindow * window, Size size);
 
  void reshapeWindow(uiWindow * window, Rect const & rect);
 
  uiWindow * screenToWindow(Point & point);
 
  void showWindow(uiWindow * window, bool value);
 
  int showModalWindow(uiWindow * window);
 
  ModalWindowState * initModalWindow(uiWindow * window);
 
  bool processModalWindowEvents(ModalWindowState * state, int timeout);
 
  int endModalWindow(ModalWindowState * state);
 
  void maximizeFrame(uiFrame * frame, bool value);
 
  void minimizeFrame(uiFrame * frame, bool value);
 
  void combineMouseMoveEvents(bool value) { m_combineMouseMoveEvents = value; }
 
  void showCaret(uiWindow * window);
 
  void setCaret(bool value);
 
  void setCaret(Point const & pos);
 
  void setCaret(Rect const & rect);
 
  uiTimerHandle setTimer(uiEvtHandler * dest, int periodMS);
 
  void killTimer(uiTimerHandle handle);
 
  void killEvtHandlerTimers(uiEvtHandler * dest);
 
  uiAppProps & appProps() { return m_appProps; }
 
  void destroyWindow(uiWindow * window);
 
  void cleanWindowReferences(uiWindow * window);
 
  void enableKeyboardAndMouseEvents(bool value);
 
  uiMessageBoxResult messageBox(char const * title, char const * text, char const * button1Text, char const * button2Text = nullptr, char const * button3Text = nullptr, uiMessageBoxIcon icon = uiMessageBoxIcon::Question);
 
  uiMessageBoxResult inputBox(char const * title, char const * text, char * inOutString, int maxLength, char const * button1Text, char const * button2Text = nullptr);
 
  uiMessageBoxResult fileDialog(char const * title, char * inOutDirectory, int maxDirNameSize, char * inOutFilename, int maxFileNameSize, char const * buttonOKText, char const * buttonCancelText, int frameWidth = 200, int frameHeight = 250);
 
  virtual void init();
 
  void setStyle(uiStyle * value)                   { m_style = value; }
 
  uiStyle * style()                                { return m_style; }
 
  Keyboard * keyboard()                            { return m_keyboard; }
 
  Mouse * mouse()                                  { return m_mouse; }
 
  BitmappedDisplayController * displayController() { return m_displayController; }
 
  int displayColors()                              { return m_displayColors; }
 
  Canvas * canvas()                                { return m_canvas; }
 
  int lastUserActionTime()                         { return m_lastUserActionTimeMS; }
 
 
  // delegates
 
  Delegate<uiTimerHandle> onTimer;
 
 
protected:
 
  bool getEvent(uiEvent * event, int timeOutMS);
  bool peekEvent(uiEvent * event, int timeOutMS);
 
 
private:
 
  void preprocessEvent(uiEvent * event);
  void preprocessMouseEvent(uiEvent * event);
  void preprocessKeyboardEvent(uiEvent * event);
  void filterModalEvent(uiEvent * event);
 
  static void timerFunc(TimerHandle_t xTimer);
 
  static void asyncRunTask(void * arg);
 
  void blinkCaret(bool forceOFF = false);
  void suspendCaret(bool value);
 
 
  BitmappedDisplayController * m_displayController;
 
  int                          m_displayColors;
 
  Canvas *        m_canvas;
 
  Keyboard *      m_keyboard;
 
  Mouse *         m_mouse;
 
  uiAppProps      m_appProps;
 
  QueueHandle_t   m_eventsQueue;
 
  uiFrame *       m_rootWindow;
 
  uiWindow *      m_activeWindow;        // foreground window. Also gets keyboard events (other than focused window)
 
  uiWindow *      m_focusedWindow;       // window that captures keyboard events (other than active window)
 
  uiWindow *      m_lastFocusedWindow;   // previous focused window
 
  uiWindow *      m_capturedMouseWindow; // window that has captured mouse
 
  uiWindow *      m_freeMouseWindow;     // window where mouse is over
 
  uiWindow *      m_modalWindow;         // current modal window
 
  bool            m_combineMouseMoveEvents;
 
  uiEvtHandler *  m_keyDownHandler;      // used to produce UIEVT_KEYTYPE
 
  uiWindow *      m_caretWindow;         // nullptr = caret is not visible
  Rect            m_caretRect;           // caret rect relative to m_caretWindow
  uiTimerHandle   m_caretTimer;
  int             m_caretInvertState;    // -1 = suspended, 1 = rect reversed (cat visible), 0 = rect not reversed (caret invisible)
 
  int             m_lastMouseUpTimeMS;   // time (MS) at mouse up. Used to measure double clicks
  Point           m_lastMouseUpPos;      // screen position of last mouse up
 
  uiStyle *       m_style;
 
  int             m_lastUserActionTimeMS; // time when last user action (mouse/keyboard) has been received, measured in milliseconds since boot
 
  // associates event handler with FreeRTOS timer
  list<uiTimerAssoc> m_timers;
 
  // used to wait for asyncRunTask to terminate
  SemaphoreHandle_t m_asyncRunWait;
};
 
 
 
 
} // end of namespace
 
 
// get out of namespace frequently used names
using fabgl::uiObject;
using fabgl::uiButtonKind;
using fabgl::uiTimerHandle;
using fabgl::uiTextEdit;
using fabgl::uiApp;
using fabgl::uiFrame;
using fabgl::uiButton;
using fabgl::uiLabel;
using fabgl::uiStaticLabel;
using fabgl::uiImage;
using fabgl::uiPanel;
using fabgl::uiMessageBoxIcon;
using fabgl::uiPaintBox;
using fabgl::uiOrientation;
using fabgl::uiListBox;
using fabgl::uiComboBox;
using fabgl::uiCheckBox;
using fabgl::uiCheckBoxKind;
using fabgl::uiSlider;
using fabgl::uiStyle;
using fabgl::uiWindowStyle;
using fabgl::uiFrameStyle;
using fabgl::uiScrollableControlStyle;
using fabgl::uiButtonStyle;
using fabgl::uiTextEditStyle;
using fabgl::uiLabelStyle;
using fabgl::uiHAlign;
using fabgl::uiImageStyle;
using fabgl::uiPanelStyle;
using fabgl::uiPaintBoxStyle;
using fabgl::uiListBoxStyle;
using fabgl::uiComboBoxStyle;
using fabgl::uiCheckBoxStyle;
using fabgl::uiSliderStyle;
using fabgl::uiColorListBox;
using fabgl::uiColorBox;
using fabgl::uiColorComboBox;
using fabgl::uiProgressBar;
using fabgl::uiMessageBoxResult;
using fabgl::uiKeyEventInfo;
using fabgl::uiCustomListBox;
using fabgl::uiFileBrowser;
using fabgl::uiSplitButton;
using fabgl::uiSimpleMenu;