|| || || || || || || ||

---

CheckBoxDrum.h

Go to the documentation of this file.

#ifndef OglGui_CheckBoxDrum_h
#define OglGui_CheckBoxDrum_h

// RvB: Status: Unfinished. To be completed on first need.

#ifndef OglGui_Window_h
#include "OglGui/Window.h"
#endif

static char *cbdKeyCmd[] = {
                "",             "",                                     // Empty string generates 6 pixel gap
                "i",    "show/hide this information",
                "",             "",                                     // Empty string generates 6 pixel gap
                "PageUp/PageDown",      "Move camera forward/backward",
                "",             "",                                     // Empty string generates 6 pixel gap
                "ScrollWheel",  "Rotate drum",
                "CTRL x / X", "Decrease/Increase Drum Rotation speed",
        "",     "",
                "3",    "Toggle 3D Text",
        "",     "",
                "#",    "Pauze/Continue",
                "ESC",  "Reset Drum Rotation",
                "@KEY", "@ACTION",
                NULL,   NULL // The string array must end with a row of NULL.
};

extern "C" {
    static void PickDrawFunc( OGLWND *oglWnd, void *User1, void *User2 )
    {
            oglSys.InitDrawScene( oglWnd );
            oglSys.DrawScene( oglWnd );
    }
};

static void
ShadeRect( int type, float x, float y, float w, float h )
{
        float   x1 = x;
        float   y1 = y;
        float   x2 = x1 + w;
        float   y2 = y1 + h;
        ULONG   Col1, Col2;

        Col1 = type==BEV_SUNKEN ? oglDARKGREY : oglWHITE;
        Col2 = type==BEV_SUNKEN ?  oglWHITE : oglDARKGREY;

        if( type == BEV_LINE ) Col1 = Col2;

        SetSolidLineColor( Col1 );
        DrawLine( x1, y1, x1, y2 );
        DrawLine( x1, y2, x2, y2);

        SetSolidLineColor( Col2 );
        DrawLine( x1, y1, x2, y1 );
        DrawLine( x2, y1, x2, y2 );
}

namespace OglGui
{

class CheckBox3D
{
public:

    CheckBox3D(OGLWND *oglWnd, std::string str, float w, float h, bool checked=false)
    {
        Init(oglWnd, str, w, h, checked);
    }

    void
    SetSelected(bool checked)
    {
        mChecked = checked;
    }

    bool
    GetSelected()
    {
        return mChecked;
    }

    void
    SetText(std::string txt)
    {
        mText = txt;
    }

    void
    SetSize(float w, float h)
    {
        mWidth = w;
        mHeight = h;
    }

    void
    ChangeSize(float dW, float dH)
    {
        SetSize(mWidth+dW, mHeight+dH);
    }

    void
    SetFrameBorderType( int checked, int unChecked )
    {
        mCheckedBorderType = checked;
        mUnCheckedBorderType = unChecked;
    }

    void
    SetBoxBorderType( int checked, int unChecked )
    {
        mCheckedBoxType = checked;
        mUnCheckedBoxType = unChecked;
    }

    void
    Draw(int fontBase, bool drawText=true, bool hitDetect=false)
    {
        int     brdType;
        float   hW = mWidth/2.0f;
        float   hH = mHeight/2.0f;
        float   tX = -mWidth/2 + 0.65f * mHeight;
        float   tY = -0.12f;
        float   tZ = 0;

        if( hitDetect ){
            glLoadName( (long long) this );
            SetSolidFillColor( oglGREEN );
            FillRectangle(-hW, -hH, mWidth, mHeight );
            return;
        }

        brdType = mChecked ? mCheckedBorderType : mUnCheckedBorderType;
        ShadeRect( brdType, -hW, -hH, mWidth, mHeight );
        if (mChecked)
        {
            SetFillColors( oglWHITE, 0xff60a060, 0xff004000, 0xff60a060, 0 );
            FillRectangle(-hW + 0.14f, -0.18f*mHeight, 0.36f*mHeight, 0.36f*mHeight );
        }
        brdType = mChecked ? mCheckedBoxType : mUnCheckedBoxType;
        ShadeRect( brdType, -hW + 0.12f, -0.2f*mHeight, 0.4f*mHeight, 0.4f*mHeight );

        glColor3f( 0.0f, 0.0f, 0.0f );
        if( !drawText )
            return;

        if (fontBase)
        {
                oglSys.Printf3D( fontBase, tX, tY, 0.01f, 0.4f, 0.4f, 0.02f, mText.c_str() );
        }
        else
        {
            oglSys.Transform1Coord( 1, &tX, &tY, &tZ );
            oglSys.TopWndToVP(mOglWnd, &tX, &tY );
            if( mShadow2D )
                oglSys.ShadowPrintf(mOglWnd, (int) tX, (int) tY, oglBLACK, oglWHITE,
                        "%s", mText.c_str() );
            else
                oglSys.PosColPrintf(mOglWnd, (int) tX, (int) tY, oglBLACK,
                        "%s", mText.c_str() );
        }

    }

private:

    std::string     mText;
    OGLWND*         mOglWnd;
    bool            mChecked;
    int             mCheckedBorderType;
    int             mUnCheckedBorderType;
    int             mCheckedBoxType;
    int             mUnCheckedBoxType;
    float           mWidth;
    float           mHeight;
    bool            mShadow2D;

    void
    Init(OGLWND *oglWnd, std::string str, float w, float h, bool checked)
    {
        mOglWnd = oglWnd;
        mText = str;
        mChecked = checked;
        mCheckedBorderType = BEV_SUNKEN;
        mUnCheckedBorderType = BEV_SUNKEN;
        mCheckedBoxType = BEV_SUNKEN;
        mUnCheckedBoxType = BEV_RAISED;
        mWidth = w;
        mHeight = h;
        mShadow2D = true;
    }
};

class CheckBoxDrum : public Window
{
public:

    CheckBoxDrum(int x, int y, int w, int h, int nRow, int nCol) :
        Window(x, y, w, h, false)
        {
                Init(nRow,nCol);
        }

    CheckBoxDrum( Window *parent, int w, int h, int nRow, int nCol) :
        Window( parent, w, h, false )
        {
                Init(nRow,nCol);
        }

    CheckBoxDrum(Window *parent, int x, int y, int w, int h, int nRow, int nCol) :
        Window( parent, x, y, w, h, false )
        {
                Init(nRow,nCol);
        }

    CheckBox3D*
    AddCheckBox(strconst str, int colNr, int rowNr, bool checked=false)
    {
        return
        mCheckBoxes[rowNr * mNrColumns + colNr] =
                new CheckBox3D( mOglWnd, str, mCbWidth, mCbHeight, checked );
    }

    void
    SetRadius(float radius)
    {
        mRadius = radius;
    }

    void
    SetPosition(float x, float y, float z)
    {
        mDrumX = x;
        mDrumY = y;
        mDrumZ = z;
    }

    void
    SetCheckBoxSize(float w, float h)
    {
        CheckBox3D  *cB;
        int n = mNrRows * mNrColumns;

        mCbWidth = w;
        mCbHeight = h;
        while (--n >= 0)
        {
            if (cB = mCheckBoxes[n])
                cB->SetSize(w,h);
        }
    }

    void
    ChangeCheckBoxSize(float dW, float dH)
    {
        SetCheckBoxSize(mCbWidth+dW, mCbHeight+dH);
    }

    void
    SetText3D(bool mode=true)
    {
        mTxt3D = mode;
    }

    void
    HandleCategory(CheckBox3D *cB)
    {
        bool    mode = false;
        int     i;

        for (i=0; i<mNrRows; i++)
            if ( mode = (mCheckBoxes[i*mNrColumns] == cB) )
                break;
        if( !mode )
            return;

        CheckBox3D *cbTarget;
        mode = cB->GetSelected();


        do {
            for (int j=1; j<mNrColumns; j++ )
                if (cbTarget = mCheckBoxes[i*mNrColumns+j] )
                    cbTarget->SetSelected(mode);
                    i++;
        } while( i<mNrRows && !mCheckBoxes[i*mNrColumns] );
    }

        virtual void InitFunc()
        {
                OGLWND *oglWnd = oglSys.GetTopOGLWND( mOglWnd );

        void* font = (void*)1;
#ifndef OGL_USING_GLUT
                font = (void*) CreateFont( -12, 0, 0, 0, FW_NORMAL, 0, 0, 0,
                        ANSI_CHARSET, OUT_TT_PRECIS, CLIP_DEFAULT_PRECIS,
                        ANTIALIASED_QUALITY, VARIABLE_PITCH | FF_DONTCARE, "Verdana" );
#endif
                // Transform MsWindows fonts to OpenGL fontBases
                txtFontBase = oglSys.Create3DFont( mOglWnd, font, 1, 0.6f, NULL );

#ifndef OGL_USING_GLUT
                // MsWindows font no longer needed
                DeleteObject( (HFONT) font );
#endif
                Window::InitFunc();

        DrumInfoBox = oglSys.InfoBoxStrArr( oglWnd, &cbdKeyCmd[0], 2, 20, 0x0080ff, oglRED, oglWHITE );
                oglSys.AllowPicking( mOglWnd, 0, 0 );
        }

    virtual void
    ExitFunc()
    {
        oglSys.InfoBoxDestroy( DrumInfoBox );
    }

        virtual void
        KeyboardFunc( INT c, INT state )
        {
                INT                     shiftDown = state & oglShift;
                FLOAT           add = shiftDown ? -0.01f : 0.01f;

        if( c == 'W' || c == 'w' )
            ChangeCheckBoxSize( (c=='W') ? 0.04:-0.04f, 0.f);
        else if( c == 'H' || c == 'h' )
            ChangeCheckBoxSize( 0.f, (c=='H') ? 0.04:-0.04f);
        else
            Window::KeyboardFunc( c, state );

        if( c == 'i' )
            mKeyInfo = !mKeyInfo;

                if( c == 'R' || c == 'r' ) // Radius of Drum
                        mRadius += (c=='R') ? 0.2f : -0.2f;

                if( c == oglESC ) // Reset: Set rotation and rotation speed to zero
                        mDrumRotDx = mDrumRotX  = 0.0f;

                if( c == oglCTRL('x') && (mDrumRotDx += add) ) oglSys.SetAlwaysDraw( mOglWnd, 1 );

                if( c == '3' ) mTxt3D = !mTxt3D;

                if( c == '#' ) // Pauze/continue
            oglSys.SetAlwaysDraw( mOglWnd, !oglSys.GetAlwaysDraw(mOglWnd) );

                oglSys.UpdateSceneFlag( mOglWnd, 1 );
        }


        virtual void
        DisplayFunc()
        {
        CheckBox3D*     checkBox;
            OGC                 myOGC;
                int                     i, j;
                int             angle, totAngle;

            OGCSave( &myOGC );
                view3DSys.View3DCameraTransform( mOglWnd );
                glTranslatef( mDrumX, mDrumY, mDrumZ );
                glRotatef( mDrumRotX, 1.0f, 0.0f, 0.0f );       // Rotate X
        glNormal3f(0.f,0.f,1.f);
                for( i=0; i<mNrColumns; i++)
                {
                        glPushMatrix();
            glTranslatef( (-(mNrColumns/2) + i) * (mCbWidth+0.2f) , 0.0f, 0.0f );

                        for( j=0; j<mNrRows; j++)
                        {
                angle = j * 360/mNrRows;
                totAngle = ((int) mDrumRotX + angle) % 360;
                totAngle = abs( totAngle );
                if( totAngle > 70 &&  totAngle < 290 )
                    continue;

                                glPushMatrix();
                                glRotatef( (float) angle, 1.0f, 0.0f, 0.0f );
                                glTranslatef( 0.0f, 0.0f, mRadius);

                if( checkBox = mCheckBoxes[j*mNrColumns + i] )
                    checkBox->Draw(mTxt3D ? txtFontBase : 0,
                                    totAngle < 60 || totAngle > 300, mPicking );
                                glPopMatrix();
                        }
                        glPopMatrix();
                }
                mDrumRotX += mDrumRotDx;

        if( !mPicking && mKeyInfo ){
                    oglSys.InfoBoxCenter( mOglWnd, DrumInfoBox );
                    oglSys.InfoBoxDraw( mOglWnd, DrumInfoBox );
            }

            OGCRestore( &myOGC );
        }

        virtual void
        MouseFunc( int msg, int but, int state, int x, int y )
        {
        if( msg == oglMouseDown && msg == oglLeftButton )
        {
            mPicking = true;
            int picked = (int) oglSys.StdPickObject( mOglWnd, (FLOAT) x, (FLOAT) y,
                          4.0f, 300.0f, PickDrawFunc, NULL, NULL );
            mPicking = false;
            if( picked ){
                CheckBox3D* cB = (CheckBox3D *) picked;
                cB->SetSelected( !cB->GetSelected() );
                HandleCategory( cB );
            }
        }
                if (msg == oglMouseWheelUp || msg == oglMouseWheelDown)
        {
            float   delta = ((msg == oglMouseWheelUp) ? -mWheelStep : mWheelStep);
            delta *= ((state & oglControl) ? 2 : 1);
            mDrumRotX += delta;
        }
        else
            Window::MouseFunc(msg, but, state, x, y);
        }

private:

    CheckBox3D** mCheckBoxes;
    int         mNrRows, mNrColumns;

        float           mDrumX, mDrumY, mDrumZ;
        float           mDrumRotX, mDrumRotDx;
    float       mWheelStep;
    bool        mTxt3D;
    bool        mPicking;

        float           mRadius;                                                        // Radius of Drum
    float       mCbWidth, mCbHeight;

        int                     txtFontBase;                                            // 3D font baes
    bool        mKeyInfo;

    INFOBOX     *DrumInfoBox;   // InfoBox for user instruction

        void Init( int nRow, int nColumn )
        {
        CheckBox3D  *cB;
        int     i, j;
        char    buf[100];

                SetBackground( 0xfff0c0a0 );
                oglSys.SetAllowCameraMove( mOglWnd, 1 );

                mRadius = 5.0f;
        mCbWidth = 3.8f;
        mCbHeight = 1.0;
        mNrRows = nRow;
        mNrColumns = nColumn;

        mCheckBoxes = (CheckBox3D ** ) calloc( mNrRows * mNrColumns, sizeof( CheckBox3D * ) );

        for ( i=0 ; i<nColumn ; i++ )
        for ( j=0 ; j<nRow ; j++ )
        {
            if (i==0)
                sprintf( buf, "Category %d", j );
            else
                sprintf( buf, "Text %d, %d", i, j );
            if( !(j%3) && i==0)
                continue;
            cB = AddCheckBox( buf, i, j, false );
            if (i==0)
            {
                cB->SetFrameBorderType(BEV_RAISED, BEV_RAISED);
                cB->SetBoxBorderType(BEV_SUNKEN, BEV_RAISED);
            }
        }

                mDrumX = mDrumY = 0;
                mDrumZ=-19;
                mDrumRotX = mDrumRotDx = 0;
        mPicking = false;
        mTxt3D = true;
        mWheelStep = 4;
        }
};

} // namespace OglGui
#endif

---