gfx_gui.hh

Go to the documentation of this file.

/*
 * LEGAL:   COPYRIGHT (C) 2004 JIM E. BROOKS
 *          THIS SOURCE CODE IS RELEASED UNDER THE TERMS
 *          OF THE GNU GENERAL PUBLIC LICENSE VERSION 2 (GPL 2).
 ******************************************************************************/

#ifndef GFX_GUI_HH
#define GFX_GUI_HH 1


#include "gfx_rgba.hh"
#include "gfx_font.hh"
// more at bottom

namespace gfx {

const uint GUIBASE_PUSH_FONT_SOFT_LIMIT = 30;

class GuiScreen;
class GuiObject;
class GuiButton;
class Font;

// -----------------------------------------------------------------------------
// Fonts.

enum eScreenFontType
{
    eScreenFontType_NORMAL,
    eScreenFontType_THIN
};

enum eScreenFontSize
{
    eScreenFontSize_SMALLEST,
    eScreenFontSize_SMALLER,
    eScreenFontSize_SMALL,
    eScreenFontSize_NORMAL,
    eScreenFontSize_LARGE,
    eScreenFontSize_LARGER,
    eScreenFontSize_LARGEST,
};

class Gfont
{

public:
                    Gfont( SafePtr<Font> font, eScreenFontSize size, fp zoom, const RGBA rgba );
                    ~Gfont();
    void            SetFont( SafePtr<Font> font )    { mFont = font; }
    SafePtr<Font>   GetFont( void ) const            { return mFont; }
    void            SetSize( eScreenFontSize size )  { mSize = size; }
    eScreenFontSize GetSize( void ) const            { return mSize; }
    void            SetZoom( fp zoom );
    fp              GetZoom( void ) const            { return mZoom; }
    void            SetRgba( const RGBA rgba )       { mRgba = rgba; }
    RGBA            GetRgba( void ) const            { return mRgba; }
    void            Print( const char* text, uint textLen, fp x, fp y, eFontMode fontMode );
    void            Print( const char* text, uint textLen, fp x, fp y, eFontMode fontMode, const RGBA rgba );

private:
    SafePtr<Font>       mFont;      // underlying font object: may be repointed but never deleted
    eScreenFontSize     mSize;      // parameters to underlying font object
    fp                  mZoom;
    RGBA                mRgba;
};

// -----------------------------------------------------------------------------
// Mouse.

typedef void (*fnMouseButtonCallback)(GuiObject* obj, uint buttons);

enum eMouseEvent
{
    eMouseEvent_NONE            = 0,
    eMouseEvent_MOTION_ENTER    = (1<<0),
    eMouseEvent_MOTION_EXIT     = (1<<1),
    eMouseEvent_BUTTON_1        = (1<<2),
    eMouseEvent_BUTTON_2        = (1<<3),
    eMouseEvent_BUTTON_3        = (1<<4),
    eMouseEvent_BUTTON_MASK     = (eMouseEvent_BUTTON_1|eMouseEvent_BUTTON_2|eMouseEvent_BUTTON_3)
};

class GuiBase
{

friend class GuiScreen;
friend class GuiObject;
friend class GuiPrint;

public:
                        GuiBase( void );
    virtual             ~GuiBase();
    virtual void        Draw( void );
    // screens
    GuiScreen*          NewScreen( void );
    void                DeleteScreen( GuiScreen* screen );
    // viewport
    void                ReshapeViewport( const Rect<int>& viewport, const Rect<int>& window );
    void                SetZoom( const fp zoom );
    fp                  GetZoom( void ) { return mZoom; }
    fp                  GetZoomViewport( void ) { return mZoomViewport; }
    uint                GetReshapeCnt( void ) { return mReshapeCnt; }
    // misc
    bool                IfBlend( void ) { return mBlend; }
    void                ToggleBlend( void ) { mBlend = not mBlend; }
    RGBA                GetColorBg( void ) { return mColorBg; }
    void                AppTimerOneSecond( void );
    void                AppMouseMotionHandler( fp x, fp y );
    void                AppMouseButtonHandler( eMouseEvent button, bool down );
    // mouse
    bool                GetMousePos( Vector2& pos /*OUT*/ );  
    void                SetMousePos( const Vector2& pos );
    virtual Vector2     MousePos2ViewportPos( const Vector2& mousePos ) = 0;
    uint                GetMouseButtons( void );
    void                SetMouseButtons( uint buttons );
    SafePtr<Font>       GetButtonFont( void ) { return mLfontButton; }
private:
    void                MouseHandler( bool motionEvent );
    SafePtr<Font>       GetFont( eScreenFontType type );

public:
    Rect<int>           mViewport;
    Rect<int>           mViewportInitial;
    Rect<int>           mWindow;
protected:
    bool                mBlend;             
    RGBA                mColorBg;           
    fp                  mZoom;              
    fp                  mZoomViewport;      
    fp                  mViewportDelta[2];  
    uint                mReshapeCnt;
    Dlist<GuiScreen>    mScreenDlist;
    Vector2             mMousePos;          
    uint                mMouseButtons;      
protected:
    // --------- logical fonts --------------------
    Font*               mLfontText;
    Font*               mLfontTextThin;
    Font*               mLfontButton;
    // --------- logical fonts --------------------
};

class PrintDesc
{

friend class GuiPrint;

public:
                        PrintDesc( void );
public:
    string              mText;
    Vector2             mPos;
    RGBA                mRgba;
    eFontMode           mFontMode;
    eScreenFontType     mFontType;
    eScreenFontSize     mFontSize;
};

class GuiScreen
{

friend class GuiBase;
friend class GuiObject;

public:
    explicit            GuiScreen( GuiBase& gui );
                        ~GuiScreen();
    void                Draw( void );
    // visibility
    void                SetVisi( bool f )   { mVisible = f; }
    bool                IfVisi( void )      { return mVisible; }
    void                ToggleVisi( void )  { mVisible = ! mVisible; }
    // sensitivity
    void                SetSens( bool f )   { mSensitive = f; }
    void                ToggleSens( void )  { mSensitive = ! mSensitive; }
    bool                IfSens( void )      { return IfVisi() && mSensitive; }
    // shorthand
    void                SetVisiSens( bool f ) { SetVisi(f); SetSens(f); }
    // printing, fonts
    void                Print( const char* text, uint textLen, fp x, fp y, eFontMode fontMode );
    void                Print( const char* text, uint textLen, fp x, fp y, eFontMode fontMode, const RGBA rgba );
    void                PrintTimer( Seconds seconds, const PrintDesc& desc );
                        // amount of messages that are still alive
    uint                PrintTimerPopulation( void ) { return mPrintTimerCnt; }
                        // can be used to avoid printing duplicate messages
    bool                IfPrintTimerDuplicate( const char* str );
    void                SetPrintColor( const RGBA rgba );
    // PushPrint() minus the RGBA arg keeps the current color.
    void                PushPrint( eScreenFontType type, eScreenFontSize size ); // push-then-change
    void                PushPrint( eScreenFontType type, eScreenFontSize size, const RGBA rgba );  // push-then-change
    void                PopPrint( void );
private:
    void                PushFont( Gfont& gfont, eScreenFontType type, eScreenFontSize size, const RGBA rgba );
    void                PopFont( Gfont& gfont );
public:
    // button
    GuiButton*          NewButton( fp x, fp y, eFontMode fontMode, fnMouseButtonCallback callback );
    void                DeleteButton( GuiButton* button );

private:
    void                LinkObject( GuiObject* obj );
    void                UnlinkObject( GuiObject* obj );

    GuiBase&                mGui;
    bool                    mVisible;       // whether to draw all objects or none
    bool                    mSensitive;     // whether will respond to events
    Dlink<GuiScreen>*       mLinkScreen;    // link in GuiBase's screen list
    uint                    mPrintTimerCnt; // amount of PrintTimer() that are alive
    Gfont                   mGfont;         // font used by Print()
    Dlist<GuiObject>        mObjectDlist;   // list of objects in this screen
    stack<Gfont>            mGfontStack;
};

enum eGuiObject
{
    eGuiObject_INVALID,
    eGuiObject_BASE,
    eGuiObject_PRINT,
    eGuiObject_BUTTON,
};

class GuiObject
{

friend class GuiBase;
friend class GuiScreen;

public:
                        GuiObject( GuiScreen& screen, fp x, fp y, fnMouseButtonCallback buttonCallback );
    virtual             ~GuiObject();
    virtual void        Draw( void ) = 0;
    // visibility
    void                SetVisi( bool f )   { mVisible = f; }
    bool                IfVisi( void )      { return mScreen.IfVisi() && mVisible; }
    void                ToggleVisi( void )  { mVisible = ! mVisible; }
    // sensitivity
    void                SetSens( bool f )   { mSensitive = f; }
    void                ToggleSens( void )  { mSensitive = ! mSensitive; }
    bool                IfSens( void )      { return IfVisi() && mSensitive; }
    // shorthand
    void                SetVisiSens( bool f ) { SetVisi(f); SetSens(f); }
    // position
    Vector2             GetPos( void );
    void                SetPos( const Vector2& pos );
protected:
    bool                IfHasArea( void ) { return int(mRect.x2 - mRect.x1) | int(mRect.y2 - mRect.y1); }
    void                SetZeroArea( void ) { mRect.x1 = mRect.x2 = mRect.y1 = mRect.y2 = 0; }
protected:

    GuiBase&                mGui;           // reference to Gui object
    GuiScreen&              mScreen;        // which screen object belongs to
    eGuiObject              mType;          // which type of GuiObject
    bool                    mVisible;       // !! Use Visi() functions if possible !!
    bool                    mSensitive;     // !! Use Sens() functions if possible !!
    fnMouseButtonCallback   mMouseButtonCallback; // may be NULL
    uint                    mMouseEvent;    // mouse event
    Vector2                 mPos;           // position of object on 2D viewport
    // Defines the area the object occupies on the viewport.
    // If x2-x1==0 && y2-y1==0 then it has zero area
    // and will be ignored by the mouse handler.
    Rect<fp>                mRect;
    Dlink<GuiObject>*       mLinkObject;    // link in GuiScreen's object list
};

class GuiPrint : public GuiObject
{

typedef GuiObject Parent;
friend class GuiBase;
friend class GuiScreen;

public:
                        GuiPrint( GuiScreen& screen, Seconds seconds, const PrintDesc& desc );
    virtual             ~GuiPrint();
    void                Draw( void );

protected:
    string                  mText;
    int                     mTimer;         // decremented every second
    RGBA                    mRgbaBase;
    eFontMode               mFontMode;
    eScreenFontType         mFontType;
    eScreenFontSize         mFontSize;
    SafePtr<Font>           mFont;
};

class GuiButtonBase : public GuiObject
{

typedef GuiObject Parent;

public:
                        GuiButtonBase( GuiScreen& screen, fp x, fp y, eFontMode fontMode, fnMouseButtonCallback callback );
    virtual             ~GuiButtonBase();
    void                SetText( const char* text, uint textLen );
    void                SetText( const string& text );
    const string&       GetText( void ) { return mText; }
    void                SetRGBA( const RGBA rgba ) { mRgbaBase = rgba; }
    virtual void        ResetRGBA( void ) = 0;

protected:
    eFontMode       mFontMode;
    string          mText;
    RGBA            mRgbaBase;
};

} // namespace gfx

#include "gfx_gfxsys.hh"
#if GFXSYS_OPENGL
#include "gfx_gui_opengl.hh"
#endif

#endif // GFX_GUI_HH

Palomino 3D Engine documents generated by doxygen 1.5.3 on Fri Nov 23 11:26:10 2007