tb_widgets.h

// ================================================================================
// ==      This file is a part of Turbo Badger. (C) 2011-2014, Emil Segerås      ==
// ==                     See tb_core.h for more information.                    ==
// ================================================================================

#ifndef TB_WIDGETS_H
#define TB_WIDGETS_H

#include "tb_core.h"
#include "tb_geometry.h"
#include "tb_skin.h"
#include "tb_linklist.h"
#include "tb_widget_value.h"
#include "tb_object.h"
#include "tb_font_desc.h"

namespace tb {

class TBWindow;
class TBWidget;
class TBFontFace;
class TBScroller;
class TBWidgetListener;
class TBLongClickTimer;
struct INFLATE_INFO;

// == Generic widget stuff =================================================

enum TB_ALIGN {
    TB_ALIGN_LEFT,      
    TB_ALIGN_TOP,       
    TB_ALIGN_RIGHT,     
    TB_ALIGN_BOTTOM     
};

enum EVENT_TYPE {
    EVENT_TYPE_CLICK,

    EVENT_TYPE_LONG_CLICK,
    EVENT_TYPE_POINTER_DOWN,
    EVENT_TYPE_POINTER_UP,
    EVENT_TYPE_POINTER_MOVE,
    EVENT_TYPE_WHEEL,

    EVENT_TYPE_MULTI_GESTURE,

    EVENT_TYPE_FINGER_DOWN,
    EVENT_TYPE_FINGER_UP,
    EVENT_TYPE_FINGER_MOVE,
    EVENT_TYPE_CHANGED,
    EVENT_TYPE_KEY_DOWN,
    EVENT_TYPE_KEY_UP,

    EVENT_TYPE_SHORTCUT,

    EVENT_TYPE_CONTEXT_MENU,

    EVENT_TYPE_FILE_DROP,

    EVENT_TYPE_CUSTOM
};

enum MODIFIER_KEYS {
    TB_MODIFIER_NONE    = 0,
    TB_CTRL             = 1,
    TB_SHIFT            = 2,
    TB_ALT              = 4,
    TB_SUPER            = 8
};
MAKE_ENUM_FLAG_COMBO(MODIFIER_KEYS);

enum SPECIAL_KEY
{
    TB_KEY_UNDEFINED = 0,
    TB_KEY_UP, TB_KEY_DOWN, TB_KEY_LEFT, TB_KEY_RIGHT,
    TB_KEY_PAGE_UP, TB_KEY_PAGE_DOWN, TB_KEY_HOME, TB_KEY_END,
    TB_KEY_TAB, TB_KEY_BACKSPACE, TB_KEY_INSERT, TB_KEY_DELETE,
    TB_KEY_ENTER, TB_KEY_ESC,
    TB_KEY_F1, TB_KEY_F2, TB_KEY_F3, TB_KEY_F4, TB_KEY_F5, TB_KEY_F6,
    TB_KEY_F7, TB_KEY_F8, TB_KEY_F9, TB_KEY_F10, TB_KEY_F11, TB_KEY_F12
};

class TBWidgetEvent : public TBTypedObject
{
public:
    TBWidget *target;   
    EVENT_TYPE type;    
    int target_x;       
    int target_y;       
    int delta_x;        
    int delta_y;        
    int count;          
    int key;            
    SPECIAL_KEY special_key;
    MODIFIER_KEYS modifierkeys;
    TBID ref_id;        
    bool touch;         

    TBOBJECT_SUBCLASS(TBWidgetEvent, TBTypedObject);

    TBWidgetEvent(EVENT_TYPE type) : target(nullptr), type(type), target_x(0), target_y(0), delta_x(0), delta_y(0), count(1),
                                            key(0), special_key(TB_KEY_UNDEFINED), modifierkeys(TB_MODIFIER_NONE), touch(false) {}

    TBWidgetEvent(EVENT_TYPE type, int x, int y, bool touch, MODIFIER_KEYS modifierkeys = TB_MODIFIER_NONE) :
                                            target(nullptr), type(type), target_x(x), target_y(y), delta_x(0), delta_y(0),
                                            count(1), key(0), special_key(TB_KEY_UNDEFINED), modifierkeys(modifierkeys),
                                            touch(touch) {}

    int GetCountCycle(int max) { return ((count - 1) % max) + 1; }

    bool IsPointerEvent() const { return    type == EVENT_TYPE_POINTER_DOWN ||
                                            type == EVENT_TYPE_POINTER_UP ||
                                            type == EVENT_TYPE_POINTER_MOVE; }
    bool IsKeyEvent() const { return    type == EVENT_TYPE_KEY_DOWN ||
                                        type == EVENT_TYPE_KEY_UP; }
};

class TBWidgetEventMultiGesture : public TBWidgetEvent
{
public:
    float center_x;     
    float center_y;     
    float dTheta;       
    float dDist;        

    TBOBJECT_SUBCLASS(TBWidgetEventMultiGesture, TBWidgetEvent);

    TBWidgetEventMultiGesture(int target_x, int target_y, float cx, float cy, float dTheta, float dDist, uint16_t numFingers)
        : TBWidgetEvent(EVENT_TYPE_MULTI_GESTURE, target_x, target_y, 1),
          center_x(cx), center_y(cy), dTheta(dTheta), dDist(dDist) 
    {
        count = numFingers;
    }
};

class TBWidgetEventFinger : public TBWidgetEvent
{
public:
    float x;  
    float y;  
    float dx; 
    float dy; 

    TBOBJECT_SUBCLASS(TBWidgetEventFinger, TBWidgetEvent);

    TBWidgetEventFinger(EVENT_TYPE type, int target_x, int target_y, float x, float y, float dx, float dy, int fingerid)
        : TBWidgetEvent(type, target_x, target_y, 1), x(x), y(y), dx(dx), dy(dy)
    {
        //count = numFingers;
        key = fingerid;
    }
};

class TBWidgetEventFileDrop : public TBWidgetEvent
{
public:
    TBListAutoDeleteOf<TBStr> files;

    TBOBJECT_SUBCLASS(TBWidgetEventFileDrop, TBWidgetEvent);

    TBWidgetEventFileDrop() : TBWidgetEvent(EVENT_TYPE_FILE_DROP) {}
};

enum WIDGET_STATE {
    WIDGET_STATE_NONE           = 0,
    WIDGET_STATE_DISABLED       = 1,
    WIDGET_STATE_FOCUSED        = 2,
    WIDGET_STATE_PRESSED        = 4,
    WIDGET_STATE_SELECTED       = 8,
    WIDGET_STATE_HOVERED        = 16,

    WIDGET_STATE_ALL            =   WIDGET_STATE_DISABLED |
                                    WIDGET_STATE_FOCUSED |
                                    WIDGET_STATE_PRESSED |
                                    WIDGET_STATE_SELECTED |
                                    WIDGET_STATE_HOVERED
};
MAKE_ENUM_FLAG_COMBO(WIDGET_STATE);

enum WIDGET_GRAVITY {
    WIDGET_GRAVITY_NONE         = 0,
    WIDGET_GRAVITY_LEFT         = 1,
    WIDGET_GRAVITY_RIGHT        = 2,
    WIDGET_GRAVITY_TOP          = 4,
    WIDGET_GRAVITY_BOTTOM       = 8,

    WIDGET_GRAVITY_LEFT_RIGHT   = WIDGET_GRAVITY_LEFT | WIDGET_GRAVITY_RIGHT,
    WIDGET_GRAVITY_TOP_BOTTOM   = WIDGET_GRAVITY_TOP | WIDGET_GRAVITY_BOTTOM,
    WIDGET_GRAVITY_ALL          = WIDGET_GRAVITY_LEFT_RIGHT | WIDGET_GRAVITY_TOP_BOTTOM,
    WIDGET_GRAVITY_DEFAULT      = WIDGET_GRAVITY_LEFT | WIDGET_GRAVITY_TOP
};
MAKE_ENUM_FLAG_COMBO(WIDGET_GRAVITY);

enum AXIS {
    AXIS_X, 
    AXIS_Y, 
    AXIS_Z, 
};

enum SIZE_DEP {
    SIZE_DEP_NONE                       = 0,
    SIZE_DEP_WIDTH_DEPEND_ON_HEIGHT     = 1,
    SIZE_DEP_HEIGHT_DEPEND_ON_WIDTH     = 2,
    SIZE_DEP_BOTH                       =   SIZE_DEP_WIDTH_DEPEND_ON_HEIGHT |
                                            SIZE_DEP_HEIGHT_DEPEND_ON_WIDTH
};
MAKE_ENUM_FLAG_COMBO(SIZE_DEP);

class PreferredSize
{
public:
    PreferredSize() : min_w(0), min_h(0)
                    , max_w(10000), max_h(10000)
                    , pref_w(0), pref_h(0)
                    , size_dependency(SIZE_DEP_NONE) {}
    PreferredSize(int w, int h) : min_w(w), min_h(h)
                                , max_w(w), max_h(h)
                                , pref_w(w), pref_h(h)
                                , size_dependency(SIZE_DEP_NONE) {}

    int min_w, min_h;           
    int max_w, max_h;           
    int pref_w, pref_h;         
    SIZE_DEP size_dependency;   
};

class LayoutParams
{
public:
    static const int UNSPECIFIED = TB_INVALID_DIMENSION;
    LayoutParams() : min_w(UNSPECIFIED), min_h(UNSPECIFIED)
                    , max_w(UNSPECIFIED), max_h(UNSPECIFIED)
                    , pref_w(UNSPECIFIED), pref_h(UNSPECIFIED) {}
    LayoutParams(int w, int h) : min_w(w), min_h(h)
                                , max_w(w), max_h(h)
                                , pref_w(w), pref_h(h) {}

    void SetWidth(int width) { min_w = max_w = pref_w = width; }

    void SetHeight(int height) { min_h = max_h = pref_h = height; }

    int min_w, min_h;           
    int max_w, max_h;           
    int pref_w, pref_h;         
};

class SizeConstraints
{
public:
    static const int NO_RESTRICTION = 10000;

    int available_w, available_h;

    SizeConstraints(int w, int h) : available_w(w), available_h(h) {}

    SizeConstraints() : available_w(NO_RESTRICTION), available_h(NO_RESTRICTION) {}

    SizeConstraints ConstrainByPadding(int horizontal_padding, int vertical_padding) const
    {
        return SizeConstraints(available_w == NO_RESTRICTION ? NO_RESTRICTION : available_w - horizontal_padding,
                                available_h == NO_RESTRICTION ? NO_RESTRICTION : available_h - vertical_padding);
    }

    SizeConstraints ConstrainByLayoutParams(const LayoutParams &lp) const
    {
        return SizeConstraints(ConstrainByLPMax(available_w, lp.min_w, lp.max_w),
                                ConstrainByLPMax(available_h, lp.min_h, lp.max_h));
    }

    bool operator == (const SizeConstraints &sc) const { return available_w == sc.available_w &&
                                                                available_h == sc.available_h; }

private:
    int ConstrainByLPMax(int constraint, int lp_min, int lp_max) const
    {
        if (constraint == NO_RESTRICTION)
            return lp_max != LayoutParams::UNSPECIFIED ? lp_max : NO_RESTRICTION;
        int ret = constraint;
        if (lp_min != LayoutParams::UNSPECIFIED)
            ret = MAX(ret, lp_min);
        if (lp_max != LayoutParams::UNSPECIFIED)
            ret = MIN(ret, lp_max);
        return ret;
    }
};

enum WIDGET_Z {
    WIDGET_Z_TOP,               
    WIDGET_Z_BOTTOM             
};

enum WIDGET_Z_REL {
    WIDGET_Z_REL_BEFORE,        
    WIDGET_Z_REL_AFTER          
};

enum WIDGET_VISIBILITY {
    WIDGET_VISIBILITY_VISIBLE,      
    WIDGET_VISIBILITY_INVISIBLE,    
    WIDGET_VISIBILITY_GONE          
};

enum WIDGET_INVOKE_INFO {
    WIDGET_INVOKE_INFO_NORMAL,
    WIDGET_INVOKE_INFO_NO_CALLBACKS
};

enum WIDGET_FOCUS_REASON {
    WIDGET_FOCUS_REASON_NAVIGATION, 
    WIDGET_FOCUS_REASON_POINTER,    
    WIDGET_FOCUS_REASON_UNKNOWN     
};

enum WIDGET_HIT_STATUS {
    WIDGET_HIT_STATUS_NO_HIT = 0,           
    WIDGET_HIT_STATUS_HIT,                  
    WIDGET_HIT_STATUS_HIT_NO_CHILDREN       
};

class TBWidget : public TBTypedObject, public TBLinkOf<TBWidget>
{
public:
    TBOBJECT_SUBCLASS(TBWidget, TBTypedObject);

    TBWidget(TBValue::TYPE sync_type = TBValue::TYPE_NULL);
    virtual ~TBWidget();

    virtual void SetRect(const TBRect &rect);
    inline const TBRect & GetRect() const { return m_rect; }

    void SetPosition(const TBPoint &pos) { SetRect(TBRect(pos.x, pos.y, m_rect.w, m_rect.h)); }

    void SetSize(int width, int height);

    void Invalidate();

    void InvalidateStates();

    void InvalidateSkinStates();

    void Die();

    bool GetIsDying() const { return m_packed.is_dying || (m_parent && m_parent->GetIsDying()); }

    void SetID(const TBID &id);
    TBID &GetID() { return m_id; }
    const TBID &GetID() const { return m_id; }

    void SetGroupID(const TBID &id) { m_group_id = id; }
    TBID &GetGroupID() { return m_group_id; }
    const TBID &GetGroupID() const { return m_group_id; }

    TBWidget *GetWidgetByID(const TBID &id) const { return GetWidgetByIDInternal(id); }

    template<class T> T *GetWidgetByIDAndType(const TBID &id) const
        { return (T*) GetWidgetByIDInternal(id, GetTypeId<T>()); }

    void SetState(WIDGET_STATE state, bool on);

    bool GetState(WIDGET_STATE state) const { return (m_state & state) ? true : false; }

    void SetStateRaw(WIDGET_STATE state);

    WIDGET_STATE GetStateRaw() const { return m_state; }

    WIDGET_STATE GetAutoState() const;

    static void SetAutoFocusState(bool on);

    void SetOpacity(float opacity);
    float GetOpacity() const { return m_opacity; }

    void SetVisibility(WIDGET_VISIBILITY vis);
    WIDGET_VISIBILITY GetVisibility() const;

    bool GetVisibilityCombined() const;

    bool GetDisabled() const;

    void AddChild(TBWidget *child, WIDGET_Z z = WIDGET_Z_TOP, WIDGET_INVOKE_INFO info = WIDGET_INVOKE_INFO_NORMAL);

    void AddChildRelative(TBWidget *child, WIDGET_Z_REL z, TBWidget *reference, WIDGET_INVOKE_INFO info = WIDGET_INVOKE_INFO_NORMAL);

    void RemoveChild(TBWidget *child, WIDGET_INVOKE_INFO info = WIDGET_INVOKE_INFO_NORMAL);

    void RemoveFromParent() { if (m_parent) m_parent->RemoveChild(this); }

    void DeleteAllChildren();

    void SetZ(WIDGET_Z z);

    void SetZInflate(WIDGET_Z z) { m_packed.inflate_child_z = z; }
    WIDGET_Z GetZInflate() const { return (WIDGET_Z) m_packed.inflate_child_z; }

    void SetGravity(WIDGET_GRAVITY g);
    WIDGET_GRAVITY GetGravity() const { return m_gravity; }

    void SetSkinBg(const TBID &skin_bg, WIDGET_INVOKE_INFO info = WIDGET_INVOKE_INFO_NORMAL);

    TBID GetSkinBg() const { return m_skin_bg; }

    TBSkinElement *GetSkinBgElement();

    void SetIsGroupRoot(bool group_root) { m_packed.is_group_root = group_root; }
    bool GetIsGroupRoot() const { return m_packed.is_group_root; }

    void SetIsFocusable(bool focusable) { m_packed.is_focusable = focusable; }
    bool GetIsFocusable() const { return m_packed.is_focusable; }

    void SetClickByKey(bool click_by_key) { m_packed.click_by_key = click_by_key; }
    bool GetClickByKey() const { return m_packed.click_by_key; }

    void SetWantLongClick(bool want_long_click) { m_packed.want_long_click = want_long_click; }
    bool GetWantLongClick() const { return m_packed.want_long_click; }

    void SetIgnoreInput(bool ignore_input) { m_packed.ignore_input = ignore_input; }
    bool GetIgnoreInput() const { return m_packed.ignore_input; }

    bool GetIsInteractable() const;

    bool SetFocus(WIDGET_FOCUS_REASON reason, WIDGET_INVOKE_INFO info = WIDGET_INVOKE_INFO_NORMAL);
    bool GetIsFocused() const { return focused_widget == this; }

    bool SetFocusRecursive(WIDGET_FOCUS_REASON reason = WIDGET_FOCUS_REASON_UNKNOWN);

    bool MoveFocus(bool forward);

    TBWidget *GetWidgetAt(int x, int y, bool include_children) const;

    TBWidget *GetChildFromIndex(int index) const;

    int GetIndexFromChild(TBWidget *child) const;

    TBStr GetTextByID(const TBID &id);

    int GetValueByID(const TBID &id);

    TBWidget *GetNextDeep(const TBWidget *bounding_ancestor = nullptr) const;
    TBWidget *GetPrevDeep() const;
    TBWidget *GetLastLeaf() const;
    inline TBWidget *GetFirstChild() const { return m_children.GetFirst(); }
    inline TBWidget *GetLastChild() const { return m_children.GetLast(); }
    TBLinkListOf<TBWidget>::Iterator GetIteratorForward() { return m_children.IterateForward(); }
    TBLinkListOf<TBWidget>::Iterator GetIteratorBackward() { return m_children.IterateBackward(); }

    bool IsAncestorOf(TBWidget *other_widget) const;

    bool IsEventDestinationFor(TBWidget *other_widget) const;

    // == Callbacks ==============================================

    void AddListener(TBWidgetListener *listener);
    void RemoveListener(TBWidgetListener *listener);
    bool HasListener(TBWidgetListener *listener) const;

    virtual bool OnEvent(const TBWidgetEvent & /*ev*/) { return false; }

    virtual void OnProcess() {}

    virtual void OnProcessAfterChildren() {}

    virtual void OnProcessStates() {}

    class PaintProps
    {
    public:
        PaintProps();

        TBColor text_color;
    };

    virtual void OnPaint(const PaintProps & /*paint_props*/) {}

    virtual void OnPaintChildren(const PaintProps &paint_props);

    virtual void OnInvalid() {}

    virtual void OnSkinChanged() {}

    virtual void OnFontChanged() {}

    virtual void OnFocusChanged(bool /*focused*/) {}

    virtual void OnVisibilityChanged() {}

    virtual void OnCaptureChanged(bool /*captured*/) {}

    virtual void OnChildAdded(TBWidget * /*child*/) {}

    virtual void OnChildRemove(TBWidget * /*child*/) {}

    virtual void OnAdded() {}

    virtual void OnRemove() {}

    virtual void OnDie() {}

    virtual void OnResized(int old_w, int old_h);

    virtual void OnScroll(int /*scroll_x*/, int /*scroll_y*/) {}

    virtual void OnInflateChild(TBWidget *child);

    virtual void OnInflate(const INFLATE_INFO &info);

    virtual void OnDeflate(const INFLATE_INFO &info);

    virtual WIDGET_HIT_STATUS GetHitStatus(int x, int y);

    virtual bool GetCustomSkinCondition(const TBSkinCondition::CONDITION_INFO & /*info*/) { return false; }

    virtual TBWidget *GetContentRoot() { return this; }

    TBWidget *GetParentRoot();

    TBWindow *GetParentWindow();

    inline TBWidget *GetParent() const { return m_parent; }

    virtual TBWidget *GetEventDestination() { return m_parent; }

    virtual void GetChildTranslation(int &x, int &y) const { x = y = 0; }

    virtual void ScrollTo(int /*x*/, int /*y*/) {}

    void ScrollToSmooth(int x, int y);

    void ScrollBy(int dx, int dy);

    void ScrollBySmooth(int dx, int dy);

    class ScrollInfo
    {
    public:
        ScrollInfo() : min_x(0), min_y(0), max_x(0), max_y(0), x(0), y(0) {}
        bool CanScrollX() const { return max_x > min_x; }
        bool CanScrollY() const { return max_y > min_y; }
        bool CanScrollLeft() const { return x > min_x; }
        bool CanScrollRight() const { return x < max_x; }
        bool CanScrollUp() const { return y > min_y; }
        bool CanScrollDown() const { return y < max_y; }
        bool CanScroll() const { return CanScrollX() || CanScrollY(); }
        int min_x, min_y;   
        int max_x, max_y;   
        int x, y;           
    };

    virtual ScrollInfo GetScrollInfo() { return ScrollInfo(); }

    virtual TBWidget *GetScrollRoot() { return this; }

    void ScrollByRecursive(int &dx, int &dy);

    void ScrollIntoViewRecursive();

    void ScrollIntoView(const TBRect &rect);

    TBScroller *GetScroller();

    // == Setter shared for many types of widgets ============

    virtual void SetAxis(AXIS /*axis*/) {}
    virtual AXIS GetAxis() const { return AXIS_X; }

    virtual void SetValue(long /*value*/) {}
    virtual void SetValue(const TBValue & value) { data = value; }
    virtual long GetValue() const { return 0; }

    virtual void SetValueDouble(double value) { SetValue((long) value); }

    virtual double GetValueDouble() const { return (double) GetValue(); }

    virtual bool SetText(const TBStr & /*text*/) { return true; }

    virtual bool GetText(TBStr &text) const { text.Clear(); return true; }

    TBStr GetText() const { TBStr str; GetText(str); return str; }

    void Connect(TBWidgetValue *value) { m_connection.Connect(value, this); }

    void Unconnect() { m_connection.Unconnect(); }

    const TBWidgetValueConnection & GetConnection() const { return m_connection; }

    virtual TBRect GetPaddingRect();

    virtual PreferredSize OnCalculatePreferredContentSize(const SizeConstraints &constraints);

    virtual PreferredSize OnCalculatePreferredSize(const SizeConstraints &constraints);

    PreferredSize GetPreferredSize(const SizeConstraints &constraints);
    PreferredSize GetPreferredSize() { return GetPreferredSize(SizeConstraints()); }

    enum INVALIDATE_LAYOUT {
        INVALIDATE_LAYOUT_TARGET_ONLY,  
        INVALIDATE_LAYOUT_RECURSIVE     
    };

    virtual void InvalidateLayout(INVALIDATE_LAYOUT il);

    void SetLayoutParams(const LayoutParams &lp);

    const LayoutParams *GetLayoutParams() const { return m_layout_params; }

    // == Misc methods for invoking events. Should normally be called only on the root widget ===============

    void InvokeProcess();

    void InvokeProcessStates(bool force_update = false);

    void InvokePaint(const PaintProps &parent_paint_props);

    void InvokeFontChanged();

    bool InvokeEvent(TBWidgetEvent &ev);

    bool InvokePointerDown(int x, int y, int click_count, MODIFIER_KEYS modifierkeys, bool touch);
    bool InvokePointerUp(int x, int y, int click_count, MODIFIER_KEYS modifierkeys, bool touch);
    void InvokePointerMove(int x, int y, MODIFIER_KEYS modifierkeys, bool touch);
    bool InvokeWheel(int x, int y, int delta_x, int delta_y, MODIFIER_KEYS modifierkeys);

    bool InvokeMultiGesture(float dTheta, float dDist, int targetx, int targety, float x, float y, uint16_t numFingers);
    bool InvokeFingerMotion(int x, int y, float cx, float cy, float dx, float dy, int finger);
    bool InvokeFingerDown(int x, int y, float cx, float cy, float dx, float dy, int finger);
    bool InvokeFingerUp(int x, int y, float cx, float cy, float dx, float dy, int finger);

    bool InvokeKey(int key, SPECIAL_KEY special_key, MODIFIER_KEYS modifierkeys, bool down);

    void ReleaseCapture();

    void ConvertToRoot(int &x, int &y) const;

    void ConvertFromRoot(int &x, int &y) const;

    bool SetFontDescription(const TBFontDescription &font_desc);

    TBFontDescription GetFontDescription() const { return m_font_desc; }

    TBFontDescription GetCalculatedFontDescription() const;

    TBFontFace *GetFont() const;

private:
    friend class TBWidgetListener;  
    TBWidget *m_parent;             
    TBRect m_rect;                  
    TBID m_id;                      
    TBID m_group_id;                
    TBID m_skin_bg;                 
    TBID m_skin_bg_expected;        
    TBLinkListOf<TBWidget> m_children;
    TBWidgetValueConnection m_connection; 
    TBLinkListOf<TBWidgetListener> m_listeners; 
    float m_opacity;                
    WIDGET_STATE m_state;           
    WIDGET_GRAVITY m_gravity;       
    TBFontDescription m_font_desc;  
    PreferredSize m_cached_ps;      
    SizeConstraints m_cached_sc;    
    LayoutParams *m_layout_params;  
    TBScroller *m_scroller;         
    TBLongClickTimer *m_long_click_timer;
    union {
        struct {
            uint16_t is_group_root : 1;
            uint16_t is_focusable : 1;
            uint16_t click_by_key : 1;
            uint16_t has_key_pressed_state : 1;
            uint16_t ignore_input : 1;
            uint16_t is_dying : 1;
            uint16_t is_cached_ps_valid : 1;
            uint16_t no_automatic_hover_state : 1;
            uint16_t is_panning : 1;
            uint16_t want_long_click : 1;
            uint16_t visibility : 2;
            uint16_t inflate_child_z : 1; // Should have enough bits to hold WIDGET_Z values.
        } m_packed;
        uint16_t m_packed_init;
    };

public:
    TBValue::TYPE m_sync_type;

    TBValue data;

    // Debugging
#ifdef TB_RUNTIME_DEBUG_INFO
    double last_measure_time;
    double last_layout_time;
#endif // TB_RUNTIME_DEBUG_INFO

    // TBWidget related globals
    static TBWidget *hovered_widget;    
    static TBWidget *captured_widget;   
    static TBWidget *focused_widget;    
    static int pointer_down_widget_x;   
    static int pointer_down_widget_y;   
    static int pointer_move_widget_x;   
    static int pointer_move_widget_y;   
    static bool cancel_click;           
    static bool update_widget_states;   
    static bool update_skin_states;     
    static bool show_focus_state;       

    void StopLongClickTimer();
private:
    TBWidget *FindScrollableWidget(bool scroll_x, bool scroll_y);
    TBScroller *FindStartedScroller();
    TBScroller *GetReadyScroller(bool scroll_x, bool scroll_y);
    TBWidget *GetWidgetByIDInternal(const TBID &id, const TB_TYPE_ID type_id = nullptr) const;
    void InvokeSkinUpdatesInternal(bool force_update);
    void InvokeProcessInternal();
    static void SetHoveredWidget(TBWidget *widget, bool touch);
    static void SetCapturedWidget(TBWidget *widget);
    void HandlePanningOnMove(int x, int y);
    void StartLongClickTimer(bool touch);
    friend class TBLongClickTimer;
    void MaybeInvokeLongClickOrContextMenu(bool touch);
    float CalculateOpacityInternal(WIDGET_STATE state, TBSkinElement *skin_element);
};

} // namespace tb

#endif // TB_WIDGETS_H