tb_widgets_common.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_COMMON_H
#define TB_WIDGETS_COMMON_H

#include "tb_widgets.h"
#include "tb_layout.h"
#include "tb_msg.h"

namespace tb {

enum TB_TEXT_ALIGN {
    TB_TEXT_ALIGN_LEFT,     
    TB_TEXT_ALIGN_RIGHT,    
    TB_TEXT_ALIGN_CENTER    
};

class TBWidgetString
{
public:
    TBWidgetString();

    void Paint(TBWidget *widget, const TBRect &rect, const TBColor &color);

    int GetWidth(TBWidget *widget);
    int GetHeight(TBWidget *widget);

    bool SetText(const TBStr & text) { return m_text.Set(text); }
    bool GetText(TBStr &text) const { return text.Set(m_text); }

    bool IsEmpty() const { return m_text.IsEmpty(); }

    void SetTextAlign(TB_TEXT_ALIGN align) { m_text_align = align; }
    TB_TEXT_ALIGN GetTextAlign() const { return m_text_align; }
public:
    TBStr m_text;
    TB_TEXT_ALIGN m_text_align;
};

class TBTextField : public TBWidget
{
public:
    // For safe typecasting
    TBOBJECT_SUBCLASS(TBTextField, TBWidget);

    TBTextField();

    virtual bool SetText(const TBStr & text);
    virtual bool GetText(TBStr &text) const { return m_text.GetText(text); }
    using TBWidget::GetText; 

    virtual void SetValueDouble(double value);

    virtual double GetValueDouble() const { return GetText().atof(); }

    bool IsEmpty() const { return m_text.IsEmpty(); }

    void SetTextAlign(TB_TEXT_ALIGN align) { m_text.SetTextAlign(align); }
    TB_TEXT_ALIGN GetTextAlign() const { return m_text.GetTextAlign(); }

    void SetSqueezable(bool squeezable);
    bool GetSqueezable() const { return m_squeezable; }

    void SetFormat(TBStr format);
    const TBStr & GetFormat() const { return m_format; }

    virtual void OnInflate(const INFLATE_INFO &info);
    virtual void OnDeflate(const INFLATE_INFO &info);
    virtual PreferredSize OnCalculatePreferredContentSize(const SizeConstraints &constraints);
    virtual void OnFontChanged();
    virtual void OnPaint(const PaintProps &paint_props);
protected:
    TBWidgetString m_text;
    TBStr m_format;
    int m_cached_text_width; 
    bool m_squeezable;
};

class TBButton : public TBWidget, protected TBMessageHandler
{
public:
    // For safe typecasting
    TBOBJECT_SUBCLASS(TBButton, TBWidget);

    TBButton();
    ~TBButton();

    virtual void SetAxis(AXIS axis) { m_layout.SetAxis(axis); }
    virtual AXIS GetAxis() const { return m_layout.GetAxis(); }

    void SetSqueezable(bool squeezable) { m_textfield.SetSqueezable(squeezable); }
    bool GetSqueezable() { return m_textfield.GetSqueezable(); }

    void SetAutoRepeat(bool auto_repeat_click) { m_auto_repeat_click = auto_repeat_click; }
    bool GetAutoRepeat() { return m_auto_repeat_click; }

    void SetToggleMode(bool toggle_mode_on) { m_toggle_mode = toggle_mode_on; }
    bool GetToggleMode() const { return m_toggle_mode; }

    virtual bool SetText(const TBStr & text);
    virtual bool GetText(TBStr &text) const { return m_textfield.GetText(text); }
    using TBWidget::GetText; 

    virtual void SetValue(long value);
    virtual long GetValue() const;

    virtual void OnInflate(const INFLATE_INFO &info);
    virtual void OnDeflate(const INFLATE_INFO &info);
    virtual void OnCaptureChanged(bool captured);
    virtual void OnSkinChanged();
    virtual bool OnEvent(const TBWidgetEvent &ev);
    virtual WIDGET_HIT_STATUS GetHitStatus(int x, int y);
    virtual PreferredSize OnCalculatePreferredContentSize(const SizeConstraints & /*constraints*/)
    {
        return m_layout.GetPreferredSize();
    }

    virtual TBWidget *GetContentRoot() { return &m_layout; }

    // == TBMessageHandler ==============================================================
    virtual void OnMessageReceived(TBMessage *msg);
protected:
    void UpdateTextFieldVisibility();
    bool CanToggle() { return m_toggle_mode || GetGroupID(); }
    class ButtonLayout : public TBLayout
    {
        virtual void OnChildAdded(TBWidget *child);
        virtual void OnChildRemove(TBWidget *child);
    };
    ButtonLayout m_layout;
    TBTextField m_textfield;
    bool m_auto_repeat_click;
    bool m_toggle_mode;
};

class TBClickLabel : public TBWidget
{
public:
    // For safe typecasting
    TBOBJECT_SUBCLASS(TBClickLabel, TBWidget);

    TBClickLabel();
    ~TBClickLabel();

    virtual void SetAxis(AXIS axis) { m_layout.SetAxis(axis); }
    virtual AXIS GetAxis() const { return m_layout.GetAxis(); }

    virtual bool SetText(const TBStr & text) { return m_textfield.SetText(text); }
    virtual bool GetText(TBStr &text) const { return m_textfield.GetText(text); }
    using TBWidget::GetText; 

    virtual PreferredSize OnCalculatePreferredContentSize(const SizeConstraints & /*constraints*/) {
        return m_layout.GetPreferredSize();
    }

    virtual TBWidget *GetContentRoot() { return &m_layout; }

    virtual bool OnEvent(const TBWidgetEvent &ev);
protected:
    TBLayout m_layout;
    TBTextField m_textfield;
};

class TBSkinImage : public TBWidget
{
public:
    // For safe typecasting
    TBOBJECT_SUBCLASS(TBSkinImage, TBWidget);

    TBSkinImage() {}
    TBSkinImage(const TBID &skin_bg) { SetSkinBg(skin_bg); }

    virtual PreferredSize OnCalculatePreferredSize(const SizeConstraints &constraints);
};

class TBSeparator : public TBWidget
{
public:
    // For safe typecasting
    TBOBJECT_SUBCLASS(TBSeparator, TBWidget);

    TBSeparator();
};

class TBProgressSpinner : public TBWidget, protected TBMessageHandler
{
public:
    // For safe typecasting
    TBOBJECT_SUBCLASS(TBProgressSpinner, TBWidget);

    TBProgressSpinner();

    bool IsRunning() const { return m_value > 0; }

    void Begin() { SetValue(GetValue() + 1); }
    void End() { SetValue(GetValue() - 1); }

    virtual void SetValue(long value);
    virtual long GetValue() const { return m_value; }

    virtual void OnPaint(const PaintProps &paint_props);

    // == TBMessageHandler ==============================================================
    virtual void OnMessageReceived(TBMessage *msg);
protected:
    int m_value;
    int m_frame;
    TBID m_skin_fg;
};

class TBRadioCheckBox : public TBWidget
{
public:
    // For safe typecasting
    TBOBJECT_SUBCLASS(TBRadioCheckBox, TBWidget);

    TBRadioCheckBox();

    virtual void SetValue(long value);
    virtual long GetValue() const { return m_value; }

    virtual PreferredSize OnCalculatePreferredSize(const SizeConstraints &constraints);
    virtual bool OnEvent(const TBWidgetEvent &ev);

    static void UpdateGroupWidgets(TBWidget *new_leader);
protected:
    int m_value;
};

class TBCheckBox : public TBRadioCheckBox
{
public:
    // For safe typecasting
    TBOBJECT_SUBCLASS(TBCheckBox, TBRadioCheckBox);

    TBCheckBox() { SetSkinBg(TBIDC("TBCheckBox"), WIDGET_INVOKE_INFO_NO_CALLBACKS); }
};

class TBRadioButton : public TBRadioCheckBox
{
public:
    // For safe typecasting
    TBOBJECT_SUBCLASS(TBRadioButton, TBRadioCheckBox);

    TBRadioButton() { SetSkinBg(TBIDC("TBRadioButton"), WIDGET_INVOKE_INFO_NO_CALLBACKS); }
};

class TBScrollBar : public TBWidget
{
public:
    // For safe typecasting
    TBOBJECT_SUBCLASS(TBScrollBar, TBWidget);

    TBScrollBar();
    ~TBScrollBar();

    virtual void SetAxis(AXIS axis);
    virtual AXIS GetAxis() const { return m_axis; }

    void SetLimits(double min, double max, double visible);

    bool CanScroll() const { return m_visible > 0; }

    bool CanScrollPositive() const { return m_value < m_max; }

    bool CanScrollNegative() const { return m_value > m_min; }

    double GetMinValue() const { return m_min; }
    double GetMaxValue() const { return m_max; }
    double GetVisible() const { return m_visible; }

    virtual void SetValueDouble(double value);
    virtual double GetValueDouble() const { return m_value; }

    virtual void SetValue(long value) { SetValueDouble(value); }
    virtual long GetValue() const { return GetValueDouble(); }

    virtual void OnInflate(const INFLATE_INFO &info);
    virtual bool OnEvent(const TBWidgetEvent &ev);
    virtual void OnResized(int old_w, int old_h);
protected:
    TBWidget m_handle;
    AXIS m_axis;
    double m_value;
    double m_min, m_max, m_visible;
    double m_to_pixel_factor;
    void UpdateHandle();
};

// FIX: Add a "track value" showing as a line within the track (to be used for buffering etc).
// FIX: Also add a auto track that keeps it up to date with value (default).
template <typename VAL_T>
class TBSliderX : public TBWidget
{
public:
    // For safe typecasting
    TBOBJECT_SUBCLASS(TBSliderX<VAL_T>, TBWidget);

    TBSliderX<VAL_T>();
    ~TBSliderX<VAL_T>();

    virtual void SetAxis(AXIS axis);
    virtual AXIS GetAxis() const { return m_axis; }

    void SetLimits(VAL_T min, VAL_T max, int nstep = 100);

    VAL_T GetMinValue() const { return m_min; }
    VAL_T GetMaxValue() const { return m_max; }

    VAL_T GetSmallStep() const { return m_step; }
    void SetSmallStep(VAL_T step) { m_step = step; }

    virtual void SetValueVal(VAL_T value);
    virtual VAL_T GetValueVal() const { return m_value; }

    virtual void SetValue(long value) { SetValueVal(value); }
    virtual long GetValue() const { return m_value; }
    virtual void SetValueDouble(double value) { SetValueVal(value); }
    virtual double GetValueDouble() const { return GetValueVal(); }

    virtual void OnInflate(const INFLATE_INFO &info);
    virtual void OnDeflate(const INFLATE_INFO &info);
    virtual bool OnEvent(const TBWidgetEvent &ev);
    virtual void OnResized(int old_w, int old_h);
protected:
    TBWidget m_handle;
    AXIS m_axis;
    VAL_T m_value;
    VAL_T m_min, m_max, m_step;
    double m_to_pixel_factor;
    void UpdateHandle();
};
typedef TBSliderX<double> TBSlider;
typedef TBSliderX<int> TBSliderInt;
typedef TBSliderX<long> TBSliderLong;

class TBContainer : public TBWidget
{
public:
    // For safe typecasting
    TBOBJECT_SUBCLASS(TBContainer, TBWidget);

    TBContainer();
};

class TBMover : public TBWidget
{
public:
    // For safe typecasting
    TBOBJECT_SUBCLASS(TBMover, TBWidget);

    TBMover();

    virtual bool OnEvent(const TBWidgetEvent &ev);
};

class TBResizer : public TBWidget
{
public:
    // For safe typecasting
    TBOBJECT_SUBCLASS(TBResizer, TBWidget);

    TBResizer();
    virtual WIDGET_HIT_STATUS GetHitStatus(int x, int y);
    virtual bool OnEvent(const TBWidgetEvent &ev);
};

class TBDimmer : public TBWidget
{
public:
    // For safe typecasting
    TBOBJECT_SUBCLASS(TBDimmer, TBWidget);

    TBDimmer();

    virtual void OnAdded();
};

} // namespace tb

#endif // TB_WIDGETS_COMMON_H