NvUI.h

Go to the documentation of this file.

// TAGRELEASE: PUBLIC

#ifndef _NV_UI_H
#define _NV_UI_H

#include <NvFoundation.h>

#include <NvUI/NvGestureEvent.h>
#include "NvUI/NvPackedColor.h"
#include "NV/NvVector.h"

#include <string.h>
#include <string>
#include <map>

// fwd decl of BFText class.
class BFText;

#define INHERIT_FROM(c) typedef c INHERITED;

typedef uint64_t               NvUST; // U64 unadjusted system time value
#define UST2SECS(t)     ((double)(((double)(t)) / 1.0e9));

#define SECS2UST(t)     ((NvUST)(((double)(t)) * 1.0e9));

 
typedef enum {
    nvuiEventNotHandled     = 0x000, 
    nvuiEventHandled        = 0x001, 
    nvuiEventWantsHover     = 0x010, 
    nvuiEventHandledHover   = nvuiEventHandled | nvuiEventWantsHover,  
    nvuiEventWantsFocus     = 0x020, 
    nvuiEventHandledFocus   = nvuiEventHandled | nvuiEventWantsFocus,  
    nvuiEventHadReaction    = 0x100, 
    nvuiEventHandledReaction = nvuiEventHandled | nvuiEventHadReaction,  
    nvuiEventHandledFocusReaction = nvuiEventHandled | nvuiEventWantsFocus | nvuiEventHadReaction, 
    nvuiEventNoReaction    = ~nvuiEventHadReaction, 
} NvUIEventResponse;


#define NV_PURE_VIRTUAL     0

struct NvReactFlag {
    enum Enum { 
        NONE =           0x00, 
        FORCE_UPDATE =   0x01, 
        CLEAR_STATE =    0x02, 
    };
};

typedef struct
{
    uint32_t uid;   
    uint32_t code;  
    uint32_t state; 
    NvGestureKind::Enum causeKind; 
    uint8_t causeIndex; 
    NvReactFlag::Enum flags; 
    float fval;   
    uint32_t ival;   
} NvUIReaction;


//=============================================================================
//=============================================================================
// !!!!TBD should have m_ prefixed this stuff. 
class NvUIDrawState
{
public:
    NvUST   time; 
    int32_t   width; 
    int32_t   height; 
    int32_t   designWidth; 
    int32_t   designHeight; 
    float alpha; 
    float rotation; 
    NvUIDrawState(NvUST inTime, int32_t inWidth, int32_t inHeight, int32_t inDesignWidth=0, int32_t inDesignHeight=0)
        : time(inTime), width(inWidth), height(inHeight),
            designWidth(inDesignWidth), designHeight(inDesignHeight),
            alpha(1.0f), rotation(0.0f)
    {
    }    
};
        

//=============================================================================
//=============================================================================
class NvUIRect
{
public:    
    float left; 
    float top; 
    float width; 
    float height; 
    float zdepth; 
    NvUIRect()
        : left(0), top(0), width(0), height(0), zdepth(0)
        { /* empty */ };
        
    NvUIRect(float l, float t, float w, float h, float z=0.0f)
        : left(l), top(t), width(w), height(h), zdepth(z)
        { /* empty */ };

    virtual ~NvUIRect();

    virtual void Set(float l, float t, float w, float h, float z=0.0f)
        {
            left = l;
            top = t;
            width = w;
            height = h;
            zdepth = z;
        };

    virtual bool Inside(float x, float y, float mx=0, float my=0)
        {
            if (x >= left-mx && x <= left+width+mx)
                if (y >= top-my && y <= top+height+my)
                    return true;
            return false;
        }

    friend class NvUIElement;
};


// fwd decl container, as elements hold their parent whenever possible.
class NvUIContainer;

//=============================================================================
// >>> ABSTRACT BASE CLASS <<<
//=============================================================================
class NvUIElement
{
protected:
    uint32_t m_uiuid;           
    bool m_isVisible;           
    NvUIRect m_rect;            
    float m_alpha;              
    uint32_t m_slideFocusGroup; 
    NvUIContainer *m_parent;    
//  bool m_isPressed;  // if needed to track 'direct manipulation focus', i.e., who got the press-down initially.

public:
    NvUIElement()
        : m_uiuid(ms_uiuid_next++)
        , m_isVisible(true)
        , m_rect()
        , m_alpha(1.0f)
        , m_slideFocusGroup(0)
        , m_parent(NULL)
        , m_currDrawState(0)
        , m_prevDrawState(0)
        , m_maxDrawState(0)
        , m_llnext(NULL)
        , m_llprev(NULL)
        { /* empty */ };
    
    virtual ~NvUIElement();

    virtual void Draw(const NvUIDrawState &drawState) = NV_PURE_VIRTUAL; 

    virtual NvUIEventResponse HandleEvent(const NvGestureEvent &ev, NvUST timeUST, NvUIElement *hasFocus)
        {
           return nvuiEventNotHandled;
        }

    virtual NvUIEventResponse HandleReaction(const NvUIReaction& react)
        {
           return nvuiEventNotHandled;
        }

    virtual void SetOrigin(float x, float y)
        { // unless overridden, just drop into the m_rect top/left.
            m_rect.left = x;
            m_rect.top = y;
        }

    virtual void SetDimensions(float w, float h)
        {
            m_rect.width = w;
            m_rect.height = h;
        }

    virtual void SetDepth(float z)
        {
            m_rect.zdepth = z;
        }
    
    virtual bool HasDepth()
        {
            return (m_rect.zdepth > 0);
        }
    
    virtual void GetScreenRect(NvUIRect& rect)
        {
            rect = m_rect;
        }

        virtual float GetWidth()
                {
                        return m_rect.width;
                }
    
        virtual float GetHeight()
                {
                        return m_rect.height;
                }
      
    virtual void SetVisibility(bool show) // virtual for customization.
        {
            m_isVisible = show;
        }

    virtual bool GetVisibility() // virtual for customization.
        {
            return(m_isVisible);
        }

    virtual void SetAlpha(float a) // virtual for customization.
        {
            m_alpha = a;
        }

    virtual float GetAlpha()
        {
            return m_alpha;
        }

    static const NvUIReaction& GetReaction()
        {
            return ms_reaction;
        }

    static NvUIReaction& GetReactionEdit(bool clear=true)
        {
            if (clear)
                memset(&ms_reaction, 0, sizeof(ms_reaction));
            return ms_reaction;
        }

    virtual void GotFocus()
        {
        }

    virtual void LostFocus()
        {
        }

    virtual NvUIContainer* GetParent() { return m_parent; };
    virtual void SetParent(NvUIContainer* p) { m_parent = p; };
    
    virtual uint32_t GetSlideFocusGroup() { return m_slideFocusGroup; };
    virtual void SetSlideFocusGroup(uint32_t group) { m_slideFocusGroup = group; };

    static uint32_t GetActiveSlideFocusGroup() { return ms_activeSlideFocusGroup; };
    static void SetActiveSlideFocusGroup(uint32_t group) { ms_activeSlideFocusGroup = group; };

    uint32_t GetUID()
        {
            return m_uiuid;
        }

    virtual bool Hit(float x, float y)
        {
            return (m_rect.Inside(x, y, 0, 0));
        }

    static void SystemResChange(int32_t w, int32_t h);

    inline uint32_t GetDrawState()
        {
            return m_currDrawState;
        }

    virtual void SetDrawState(uint32_t n) // must be virtual so we can catch it
        {
            if (n<=m_maxDrawState)
                m_currDrawState = n;
        }
        
    inline void SetDrawStatePrev()
        {
            SetDrawState(m_prevDrawState);
        }
        
    inline uint32_t GetPrevDrawState()
        {
            return m_prevDrawState;
        }

    inline void SetPrevDrawState(uint32_t n)
        {
            if (n<=m_maxDrawState)
                m_prevDrawState = n;
        }

    inline uint32_t GetMaxDrawState()
        {
            return m_maxDrawState;
        }

     inline void SetMaxDrawState(uint32_t n)
        {
            m_maxDrawState = n;
        }

private:
    uint32_t m_currDrawState; 
    uint32_t m_prevDrawState; 
    uint32_t m_maxDrawState; 
    static NvUIReaction ms_reaction; 
    static uint32_t ms_uiuid_next; 
    static int32_t ms_designWidth; 
    static int32_t ms_designHeight; 
    static uint32_t ms_activeSlideFocusGroup;  
    // declare container as friend so it can access the internal LL variables,
    // until we otherwise reimplement container storage as a std::vector or map or the like.
    friend class NvUIContainer;
    class NvUIElement *m_llnext, *m_llprev; 
};


//=============================================================================
//=============================================================================
class NvUIProxy : public NvUIElement
{
private:
    INHERIT_FROM(NvUIElement);
        NvUIElement *m_proxy;
    
public:
    NvUIProxy(NvUIElement *el)
        : m_proxy(el) // we own the proxy now.
        { /* empty */ };
    
    virtual ~NvUIProxy()
        {
                delete m_proxy; // since we owned it.
        }

    // --- OVERRIDE VIRTUALS TO PROXIED OBJECT ---
        virtual void Draw(const NvUIDrawState &drawState)
        { m_proxy->Draw(drawState); }
    virtual NvUIEventResponse HandleEvent(const NvGestureEvent &ev, NvUST timeUST, NvUIElement *hasFocus)
        { return m_proxy->HandleEvent(ev, timeUST, (hasFocus==this)?m_proxy:hasFocus); }
        virtual NvUIEventResponse HandleReaction(const NvUIReaction& react)
        { return m_proxy->HandleReaction(react); }

        virtual void SetOrigin(float x, float y)
        { m_proxy->SetOrigin(x,y); }
    virtual void SetDimensions(float w, float h)
        { m_proxy->SetDimensions(w,h); }
    virtual void SetDepth(float z)
        { m_proxy->SetDepth(z); }   
    virtual bool HasDepth()
        { return m_proxy->HasDepth(); }

    virtual void GetScreenRect(NvUIRect& rect)
        { m_proxy->GetScreenRect(rect); }
        virtual float GetWidth()
        { return m_proxy->GetWidth(); }
        virtual float GetHeight()
        { return m_proxy->GetHeight(); }
      
    virtual void SetVisibility(bool show)
        { m_proxy->SetVisibility(show); }
    virtual bool GetVisibility()
        { return m_proxy->GetVisibility(); }

    virtual void SetAlpha(float a)
        { m_proxy->SetAlpha(a); }
    virtual float GetAlpha()
        { return m_proxy->GetAlpha(); }

    virtual void GotFocus()
        { m_proxy->GotFocus(); }
    virtual void LostFocus()
        { m_proxy->LostFocus(); }
    
    virtual uint32_t GetSlideFocusGroup()
        { return m_proxy->GetSlideFocusGroup(); }

    uint32_t GetUID()
        { return m_proxy->GetUID(); }

    virtual bool Hit(float x, float y)
        { return m_proxy->Hit(x,y); }

    //=============================================================================
        // !!!!TBD
    //inline uint32_t GetDrawState()
    virtual void SetDrawState(uint32_t n)
        { m_proxy->SetDrawState(n); }
    //inline void SetDrawStatePrev();
    //inline uint32_t GetPrevDrawState();
    //inline void SetPrevDrawState(uint32_t n);
    //inline uint32_t GetMaxDrawState();
    //inline void SetMaxDrawState(uint32_t n);
};


//=============================================================================
//=============================================================================
class NvGLSLProgram;
class NvGraphicShader
{
public:
    NvGLSLProgram *m_program; 
    //int32_t m_shader; // now stored inside program
    int32_t m_positionIndex; 
    int32_t m_uvIndex;  
    int32_t m_matrixIndex; 
    int32_t m_alphaIndex; 
    int32_t m_colorIndex; 
    virtual void Load(const char* vs, const char* fs);
};


//=============================================================================
//=============================================================================
class NvUITexture
{
private:
    // !!!!TBD TODO change this over to a std::map or hash table.
    NvUITexture *m_llnext; 
    static const int32_t NV_UITEX_HASHMAX = 19; 
    static NvUITexture *ms_texTable[NV_UITEX_HASHMAX]; 
protected:
    std::string m_filename; 
    uint32_t m_glID; 
    int32_t m_width; 
    int32_t m_height; 
    bool m_validTex; 
    bool m_hasAlpha; 
    bool m_ownsID; 
    uint32_t m_refcount;  // !!!!TBD TODO use a real ref system?
    bool m_cached; 
private:
    static uint32_t CalculateNameHash(const std::string& texname);
    bool DerefTexture(); 

public:
    NvUITexture(const std::string& texname, bool noMips=true);
    NvUITexture(const uint32_t texID, bool alpha,
                int32_t srcw, int32_t srch, bool ownsID = false, bool isCubeMap = false);
    virtual ~NvUITexture();
    
    inline int32_t GetWidth() { return m_width; };
    inline int32_t GetHeight() { return m_height; };
    inline uint32_t GetGLTex() { return m_glID; };
    inline bool GetHasAlpha() { return m_hasAlpha; };
#if later
    inline uint32_t GetGLTarget() { return m_isCubeMap ? GL_TEXTURE_CUBE_MAP:GL_TEXTURE_2D; };
#endif
    
    void AddRef() { m_refcount++; }; // that one is easy.
    void DelRef(); // this one is trickier...

    static NvUITexture *CacheTexture(const std::string& texname, bool noMips=true);
};


//=============================================================================
// The base, static visual element class.
//=============================================================================
class NvUIGraphic : public NvUIElement
{
private:
    INHERIT_FROM(NvUIElement);

protected:
    NvUITexture *m_tex; 
    bool m_scale; 
    bool m_vFlip; 
    NvPackedColor m_color;  // !!!!TBD
    
public:
    NvUIGraphic(const std::string& texname, float dstw=0, float dsth=0);
    NvUIGraphic(uint32_t texId, bool alpha, // dynamic/fbo/ext texture.
                    uint32_t srcw, uint32_t srch,
                    float dstw=0, float dsth=0); 
    NvUIGraphic(NvUITexture* tex, float dstw=0, float dsth=0);
    virtual ~NvUIGraphic();
    virtual bool LoadTexture(const std::string& texname, bool resetDimensions=true);
    void SetTexture(NvUITexture *tex);
    void SetTextureID(const uint32_t texID, bool alpha,
                        uint32_t srcw, uint32_t srch);    

    void SetTextureFiltering(uint32_t minFilter, uint32_t magFilter);

        //virtual void SetDimensions(float w, float h); // no need to override atm.

    virtual void Draw(const NvUIDrawState &drawState); // leaf, needs to implement!

    virtual void SetColor(NvPackedColor color);
    
    void FlushTexture(); // made public in case needed.
    
    // !!!!TBD might need to override for subgraphic.
    uint32_t GetTexWidth() { return (m_tex?m_tex->GetWidth():0); };
    uint32_t GetTexHeight() { return (m_tex?m_tex->GetHeight():0); };
    int32_t GetTexID() { return (m_tex?m_tex->GetGLTex():-1); };

    void FlipVertical(bool flipped = true)
    {
        m_vFlip = flipped;
    };

private:
    bool StaticInit();
    void StaticCleanup();
    void PrivateInit(void);

    static uint32_t ms_vbo; 
    static uint32_t ms_vboFlip; 
    static uint32_t ms_ibo; 
    static float s_pixelToClipMatrix[4][4];
    static float s_pixelScaleFactorX;
    static float s_pixelScaleFactorY;
    static int32_t s_pixelXLast;
    static int32_t s_pixelYLast;
    static float s_graphicWidth, s_graphicHeight;
};


//=============================================================================
//=============================================================================
class NvGraphicFrameShader : public NvGraphicShader
{
private:
    INHERIT_FROM(NvGraphicShader);

public:
    uint32_t m_borderIndex;
    uint32_t m_thicknessIndex;
    uint32_t m_texBorderIndex;

    virtual void Load(const char* vs, const char* fs);
};

//=============================================================================
// STATIC visual element
//=============================================================================
class NvUIGraphicFrame : public NvUIGraphic
{
private:
    INHERIT_FROM(NvUIGraphic);

protected:
    nv::vec2<float> m_texBorder; 
    nv::vec2<float> m_borderThickness; 
    bool m_drawCenter; 
public:
    NvUIGraphicFrame(const std::string& texname, float texBorder);
    NvUIGraphicFrame(const std::string& texname, float texBorderX, float texBorderY);
    NvUIGraphicFrame(NvUITexture *uiTex, float border);
    virtual ~NvUIGraphicFrame();

    virtual bool LoadTexture(const std::string& texname, bool resetDimensions=true);

    void SetBorderThickness(float thickness);
    void SetBorderThickness(float width, float height);
    void GetBorderThickness(float *x, float *y);
    void SetDrawCenter(bool m_drawCenter);

    virtual void Draw(const NvUIDrawState &drawState); // Override parent class drawing

private:
    bool StaticInit();
    void StaticCleanup();
};

//=============================================================================
//=============================================================================
struct NvUIFontFamily {
    enum Enum
    {
        DEFAULT = 0, 
        SANS = DEFAULT, 
        MONO = 1, 
        COUNT // should get set to right value...
    };
};

struct NvUITextAlign {
    enum Enum {
        LEFT = 0, 
        RIGHT = 1, 
        CENTER = 2, 
        TOP  = 0, 
        BOTTOM = 1 
    };
};

//=============================================================================
// STATIC visual element
//=============================================================================
class NvUIText : public NvUIElement
{
private:
    INHERIT_FROM(NvUIElement);

protected:
    BFText *m_bftext; 
    float m_size; 
    NvPackedColor m_color; 
    bool m_wrap; 
public:
    NvUIText(const char* str, NvUIFontFamily::Enum font, float size, NvUITextAlign::Enum halign);
    virtual ~NvUIText();
    
    static uint8_t GetFontID(NvUIFontFamily::Enum font);
    static bool StaticInit(float width=1280, float height=720);
    static void StaticCleanup();
    
    void SetAlignment(NvUITextAlign::Enum halign);
    virtual void SetAlpha(float alpha);
    void SetColor(const NvPackedColor& color);
    void SetShadow(char offset, NvPackedColor color=NV_PC_PREDEF_BLACK);
    void SetTextBox(float width, float height, uint32_t lines, uint32_t dots);

    virtual void SetDimensions(float w, float h);

    virtual void Draw(const NvUIDrawState &drawState); // leaf, needs to implement!

    void SetString(const char* in);
    void SetFontSize(float size);
    float GetFontSize() { return m_size; }

//    virtual void GetString(char *string, uint32_t buflen); // copies out to a buffer.

    float GetStringPixelWidth();

    void SetDrawnChars(int32_t count);
};


//=============================================================================
//=============================================================================
struct NvUIButtonState {
    enum Enum {
        ACTIVE=0, 
        SELECTED, 
        INACTIVE, 
        MAX
    };
};

struct NvUIButtonType {
    enum Enum {
        PUSH,    
        RADIO,   
        CHECK,   
    };
};

//=============================================================================
//=============================================================================
class NvUIButton : public NvUIElement
{
private:
    INHERIT_FROM(NvUIElement);

protected:
    NvUIElement *m_visrep[NvUIButtonState::MAX]; 
        NvUIText *m_title; 
    NvUIButtonType::Enum m_type; 
        uint32_t m_action; 
    uint32_t m_subcode; 
        NvGestureUID m_reactGestureUID;  
    NvGestureUID m_failedHitUID; 
    bool m_wasHit; 
    float m_hitMarginWide; 
    float m_hitMarginTall; 
    bool m_stickyClick; 
public:
    NvUIButton(NvUIButtonType::Enum btntype, uint32_t actionCode, NvUIElement *visrep[NvUIButtonState::MAX],
        const char *title=NULL, float pt=0, bool shadowed=false); // visrep has w/h set already.
    NvUIButton(NvUIButtonType::Enum btntype, uint32_t actionCode, NvUIElement *visrep,
        const char *title=NULL, float pt=0, bool shadowed=false); // visrep has w/h set already.
        NvUIButton(NvUIButtonType::Enum btntype, uint32_t actionCode, NvUIRect &size,
        const char *title, float pt, bool shadowed=false);
    virtual ~NvUIButton();

        virtual void SetTitle(const char *title, float ptsize, bool shadowed=false);
    virtual void SetTitleColor(const NvPackedColor& c);

    virtual void SetHitMargin(float hitwide, float hittall);

    virtual void Draw(const NvUIDrawState &drawState); // visual, must implement
    virtual void SetOrigin(float x, float y);

    virtual NvUIEventResponse HandleEvent(const NvGestureEvent &ev, NvUST timeUST, NvUIElement *hasFocus); // interactive, must override.
    virtual NvUIEventResponse HandleReaction(const NvUIReaction& react); // interactive, must override.

//    bool WasHit() { return m_wasHit; };

    virtual void LostFocus();
    
    uint32_t GetActionCode() { return m_action; };

        void SetSubCode(uint32_t c) { m_subcode = c; };
    uint32_t GetSubCode() { return m_subcode; };

    void SetStickyClick(bool b) { m_stickyClick = b; };

    void ConsumeGesture(const NvGestureEvent& ev) { m_reactGestureUID = ev.uid; }

private:
    void PrivateInit(NvUIButtonType::Enum btntype, uint32_t actionCode);

#ifdef BTN_SUPPORTS_HOVER
        bool m_wantsHover;
        bool m_wasHover;
#endif
};


//=============================================================================
//=============================================================================
#if later

struct NvUIContainerFlags {
    enum Enum {
        NONE =          0x00,
        CLIPCHILDREN =  0x01, 
    };
};
#endif


//=============================================================================
//=============================================================================
class NvUIContainer : public NvUIElement
{
private:
    INHERIT_FROM(NvUIElement);

protected:
    NvUIGraphic *m_background; 
    bool m_consumeClicks;
    NvUIElement *m_childrenHead; 
    NvUIElement *m_childrenTail;
    uint32_t m_numChildren; 
    NvUIElement *m_focusedChild; 
    NvUIElement *m_popup; 
    //NvUIContainerFlags::Enum m_flags; /**< Flags as defined by NvUIContainerFlags. */

public:
    NvUIContainer(float width, float height, NvUIGraphic *bg=NULL);
    virtual ~NvUIContainer();
    
    void SetBackground(NvUIGraphic *bg)
    {
        m_background = bg;
    };
        void SetConsumeClicks(bool b)
        {
                m_consumeClicks = b;
        };

    virtual void Add(NvUIElement *el, float desiredleft, float desiredtop);
    virtual bool Remove(NvUIElement *child);

    virtual void AddPopup(NvUIElement *el);
    virtual void RemovePopup(NvUIElement *el);

    virtual void SetOrigin(float x, float y);
    virtual void SetDimensions(float w, float h);

    virtual NvUIEventResponse HandleEvent(const NvGestureEvent &ev, NvUST timeUST, NvUIElement *hasFocus);
    virtual void Draw(const NvUIDrawState &drawState);

    virtual NvUIEventResponse HandleReaction(const NvUIReaction& react);

    virtual void HandleReshape(float w, float h)
    {
        // TODO
    };

    virtual void LostFocus();
    virtual bool MakeChildFrontmost(NvUIElement *child);
    
    NvUIElement *GetFocusedChild()
        {
            return m_focusedChild;
        };
    virtual uint32_t GetSlideFocusGroup()
        {
            if (m_focusedChild)
                return m_focusedChild->GetSlideFocusGroup();
            return NvUIElement::GetSlideFocusGroup(); // in case inherited does something...
        };

private:
    /* this internal/private method is what handles actually adding a
        child element to our linked list and setting back pointer. */
    virtual void Add(NvUIElement *el);
};


//=============================================================================
//=============================================================================
class NvUIWindow : public NvUIContainer
{
private:
    INHERIT_FROM(NvUIContainer);

public:
    NvUIWindow(float width, float height)
    : NvUIContainer(width, height)
    {
        // !!!!TBD TODO error handling.
        NvUIText::StaticInit(width, height);
    };

    virtual ~NvUIWindow()
    {
        NvUIText::StaticCleanup();
    }

    virtual NvUIEventResponse HandleEvent(const NvGestureEvent &ev, NvUST timeUST, NvUIElement *hasFocus)
    {
        // !!!!TBD note we ignore hasFocus, and just pass in the window as the top level focus holder.
            NvUIEventResponse r = INHERITED::HandleEvent(ev, timeUST, this);
        return r;
    }

    virtual void HandleReshape(float w, float h)
    {
        // !!!!!TBD TODO !!!!!TBD TODO
        // resize container, notify contents
        // update UIText/BitFont of view size change as needed.
    }
};


//=============================================================================
//=============================================================================
class NvUIValueBar : public NvUIElement
{
private:
    INHERIT_FROM(NvUIElement);

protected:
    float m_value;                  
    float m_maxValue;               
    float m_minValue;               
    bool m_integral;                
    bool m_useRawBorders;           
    bool m_flipDirection;           
    NvUIGraphicFrame *m_emptyFrame; 
    NvUIGraphicFrame *m_fullFrame;  
public:
    NvUIValueBar(NvUIGraphicFrame *emptybar, NvUIGraphicFrame *fullbar,
                    bool useRawBorders=false, bool flipDir=false);
    virtual ~NvUIValueBar();

    virtual void SetDimensions(float w, float h);
    virtual void SetOrigin(float x, float y);

    void SetIntegral(bool isint);
    bool GetIntegral();

    virtual void SetAlpha(float a);

    virtual void SetValue(float value);
    void SetMaxValue(float value);
    void SetMinValue(float value);

    float GetValue();
    float GetMaxValue();
    float GetMinValue();
    
    //NvUIGraphicFrame *GetActiveFrame() { return m_active; };

    virtual void Draw(const NvUIDrawState &drawState);

protected:
    void UpdateBar();
};


//=============================================================================
//=============================================================================
class NvUISlider : public NvUIValueBar
{
private:
    INHERIT_FROM(NvUIValueBar);

protected:
    NvUIGraphic *m_thumb; 
    bool m_wasHit; 
    float m_startValue; 
    float m_stepValue; 
    uint32_t m_action; 
    bool m_smooth; 
    NvUIText *m_output; 
        bool m_ownsOutput; 
public:
    NvUISlider(NvUIGraphicFrame *emptybar, NvUIGraphicFrame *fullbar, NvUIGraphic *thumb, uint32_t actionCode);
    virtual ~NvUISlider();

    virtual NvUIEventResponse HandleEvent(const NvGestureEvent &ev, NvUST timeUST, NvUIElement *hasFocus); // interactive, must override
    virtual NvUIEventResponse HandleReaction(const NvUIReaction& react); // interactive, must override

    virtual void SetDimensions(float w, float h);
    virtual void SetOrigin(float x, float y);
    virtual void SetAlpha(float a);

    virtual void SetValue(float value);

    virtual void SetHitMargin(float hitwide, float hittall);

    virtual void Draw(const NvUIDrawState &drawState);

        void SetOutput(NvUIText *out, bool owns=false);

    void SetSmoothScrolling(bool smooth) { m_smooth = smooth; }

    void SetStepValue(float step) { m_stepValue = step; }

        uint32_t GetActionCode() { return m_action; }

private:
    void SetValueReal(float value); // This function does the real work. This is because
                                    // when we are sliding the slider manually, we don't
                                    // want "external" SetValues to influence the position
                                    // of the thumb.
    void PositionThumb();

    float m_hitMarginWide; 
    float m_hitMarginTall; 
};


//=============================================================================
//=============================================================================
class NvUIPopup;
class NvUIPopupMenu : public NvUIContainer
{
private:
    INHERIT_FROM(NvUIContainer);
    NvUIPopup *m_myButton; 
public:
    NvUIPopupMenu(NvUIPopup *btn, float width, float height, NvUIGraphic *bg=NULL);
    virtual ~NvUIPopupMenu();
    virtual NvUIEventResponse HandleEvent(const NvGestureEvent &ev, NvUST timeUST, NvUIElement *hasFocus);
};


//======================================================================
//======================================================================
class NvUIPopup : public NvUIButton
{
private:
    INHERIT_FROM(NvUIButton);
    NvUIPopupMenu *m_menu; 
    NvUIButton *m_popper; 
    uint32_t m_itemCount; 
    float m_lineHeight; 
    float m_nextItemTop; 
    uint32_t m_padTop; 
    uint32_t m_padBottom; 
    std::string m_titlePre; 
    typedef std::map<uint32_t, std::string> ItemValueName; 
    ItemValueName m_itemNames; 
public:
    NvUIPopup(uint32_t actionCode, NvUIElement *visrep[NvUIButtonState::MAX],
                NvUIGraphicFrame *popupFrame, NvUIButton *popper,
                const char *title=NULL, float pt=0, bool shadowed=false);
    virtual ~NvUIPopup();

    void AddItem(NvUIElement *el, const char *name, uint32_t value);

    void SetActiveItemValue(uint32_t value);

    virtual NvUIEventResponse HandleEvent(const NvGestureEvent &ev, NvUST timeUST, NvUIElement *hasFocus);
        virtual NvUIEventResponse HandleReaction(const NvUIReaction& react);

    virtual void Draw(const NvUIDrawState &ds);
    virtual void SetDrawState(uint32_t n);
    virtual void SetOrigin(float x, float y);

protected:
    void PopupStart();
    void PopupFinish();

private:
    void UpdateTitleValue(uint32_t value);

    friend class NvUIPopupMenu;
};

#endif

©2014 NVIDIA Corporation.