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

---

OglDemo.h

Go to the documentation of this file.

//345678901234567890123456789012345678901234567890123456789012345678901234567890
// Author: Richard van Balen
#ifndef OglGui_OglDemo_h
#define OglGui_OglDemo_h

#include <stddef.h>
#include "OglGui/Window.h"
#include "OglGui/Tabs.h"
#include "OglGui/TitledWindow.h"
#include "OglGui/ScrollWnd.h"
#include "OglGui/FourPanesWindow.h"
#include "OglGui/DropDownWindow.h"
#include "OglGui/ViewSphere.h"
#include "OglGui/FramesPerSecond.h"
#include "OglGui/Camera3DControl.h"
#include "OglGui/Camera3DControlEx.h"
#include "OglGui/SelectedViewControl.h"
#include "OglGui/SixView2DWindow.h"
#include "OglGui/ZoomPanControl.h"
#include "OglGui/LenseControl.h"
#include "OglGui/ClusterApp.h"

#include "OglGui/RadioGroup.h"

//#include "OglGui/OglLib.cpp"

//#include "Link/OGL/LinkListMacros.h"

namespace OglGui {

class OglDemo : public Window, WindowListener
{
public:
    static const int scExtraControl = 333; 

    OglDemo(int width, int height) :
        Window(0, 0, width, height)
        {
        SetBackground(oglGUI_BG);
        BuildGUI(width, height);
    }

    OglDemo(Window* parent, int x, int y, int width, int height) :
        Window(parent, x, y, 1100, 700)
        {
        SetBackground(oglGUI_BG);
        BuildGUI(1100, 700);
        SetDimensions(width, height);
        ConnectTo(parent);
        }

    OglDemo(OGLWND* parent, int x, int y, int width, int height) :
        Window(parent, x, y, 1100, 700)
        {
        SetBackground(oglGUI_BG);
        BuildGUI(1100, 700);
        SetDimensions(width, height);
        Window* stub = new Window(parent);
        ConnectTo(stub);
        }


    void BuildGUI( int w, int h )
        {
        mTabs = new Tabs(this, w, h);
        mTabs->ConnectTo(this);

        BuildTab_Basic2D3D(mTabs);
        BuildTab_ZoomPanLense(mTabs);
        BuildTab_SixViewers(mTabs);
        BuildTab_Animations(mTabs);
        BuildTab_Galaxy(mTabs);
        BuildTab_GalaxyGrid(mTabs);
        BuildTab_Regions(mTabs);
        BuildTab_TreeView(mTabs);
        mTabs->SetActiveTab(0);
    }

    virtual void
    WindowKeyboardEvent(Window *src, int c, int state, void* userData)
    {
        if (userData == (void*)scExtraControl)
        {
            if (c == '!')
            {
                TitledViewControl(src, 4, 4, src);
                if (!src->Is2d())
                    TitledCamera3DControl(src, 378, 4, src);
            }
            if (c == 'R' && src->Is2d())
                RotateSelectedViews(src);
            if (c == 'G' || c == 'g')
                SetOnDrawViewGraphics(src, c=='G');
            if (c == 'P' && src->Is2d())
                TitledPanControl(src, 30, 30, 100, 100, src);
        }
    }

    void BuildTab_Basic2D3D(Tabs* tabs)
    {
        Window*       tab = tabs->CreateTab( "Basic 2D/3D", 100 );
        int           w  = tab->W();
        int           h  = tab->H();
        TitledWindow* wnd;

        wnd = TitledViews(tab, 10, 10, (w-30)/2, h-20, "Basic 2D", true);
        wnd->ContentPane()->SetWindowListener(this, scExtraControl);
        oglSys.SetAllowCameraMove(wnd->ContentPane()->GetOGLWND(), true);

        wnd = TitledViews(tab,(w-30)/2+20,10, (w-30)/2,h-20, "Basic 3D", false);
        wnd->ContentPane()->SetWindowListener(this, scExtraControl);
        int mode = CamMove_Keys | CamMove_Mouse;
        oglSys.SetAllowCameraMove(wnd->ContentPane()->GetOGLWND(), mode);
        Camera3DControlEx* cam3DControl =
            new Camera3DControlEx(wnd->ContentPane(), 0, 0, 300, 150,
                                  wnd->ContentPane());
    }


    void BuildTab_ZoomPanLense(Tabs* tabs)
    {
        Window* tab = tabs->CreateTab("Zoom Pan Lense", 140);

        TitledZoomPanLense(tab, 10, 10, tab->W()-20, tab->H()-20);
    }

    void BuildTab_SixViewers(Tabs* tabs)
    {
        Window* tab = tabs->CreateTab("Six View Control", 140);

        TitledSixViewer(tab, 10, 10, tab->W()-20, tab->H()-20);
    }

    void MNAnimTab(Tabs* tabs)
    {
        Window*  tab = tabs->CreateTab("MultimediaN", 100);
        MNAnimFuncs(tab->GetOGLWND());
    }

    Window* WoggelWindow(Window* wnd, int x, int y, int w, int h)
    {
        OGLWND* oglWnd = oglSys.CreateOGLViewPort(wnd->GetOGLWND(),x,y,w,h);

        WoggelFuncs(oglWnd);
        Window* woggelWnd = new Window(oglWnd, false);
        return woggelWnd;
    }

    void WoggelTab(Tabs* tabs)
    {
        Window* tab    = tabs->CreateTab("Woggel");
        Window* wogWnd = WoggelWindow(tab, 0, 0, tab->W(), tab->H());
        
        wogWnd->ConnectTo(tab);
    }

    void ViewSphereTab(Tabs* tabs)
    {
        Window*     tab = tabs->CreateTab("ViewSphere");
        ViewSphere* vS  = new ViewSphere(tab,0,0,tab->W(),tab->H());

        vS->ConnectTo(tab);
        vS->SetBackground(0);
        vS->SetWindowListener(this,scExtraControl);
    }

    TitledWindow* TitledAnimations(Window* parent, int x, int y, int w, int h)
    {
        TitledWindow* titledWnd = new TitledWindow(parent, x, y, w, h,
                                                   "Animation Window",
                                                   TitledWindow::BtnMax);
        Tabs*         animTabs  = new Tabs(titledWnd, 0, 0, w-8, h-32, 100);

        titledWnd->SetContentPane(animTabs);

        WoggelTab(animTabs);
        MNAnimTab(animTabs);
        ViewSphereTab(animTabs);

        new FramesPerSecond(animTabs, 0, 0, 80, 24);

        animTabs->SetActiveTab(0);
        return titledWnd;
    }

    void BuildTab_Animations(Tabs* tabs)
    {
        Window*       tab  = tabs->CreateTab("Animations",100);
        TitledAnimations(tab, 10, 10, 800, 632);
        Titled4Woggels(tab, 200, 100, 400, 400);
    }

    TitledWindow* TitledGalaxy(Window* parent, int x, int y, int w, int h)
    {
        TitledWindow* viewTW = TitledViews(parent, x, y, w, h, "Galaxy");
        Window*       viewCP = viewTW->ContentPane();
        TitledWindow* navTW  = new TitledWindow(viewCP,8,8,208,232,"Navigate");
        OGLWND*       oglWnd = Navigate2DChild(navTW->GetOGLWND(),
                                               viewCP->GetOGLWND(),0,0,10,10);
        Window*       navWnd  = new Window(oglWnd);

        oglSys.SetUserData(oglWnd, 2, (void*)1); // Also copy OnDrawView in van viewers

        navTW->SetContentPane(navWnd);
        Lense2D(viewCP->GetOGLWND(), 200, 200, 200, 200);
        viewCP->SetWindowListener(this, scExtraControl);
        return viewTW;
    }

    void BuildTab_Galaxy(Tabs* tabs)
    {
        Window*       tab   = tabs->CreateTab("Galaxy", 100);

        TitledGalaxy(tab, 10, 10, tab->W()-100, tab->H()-100);
    }

    class OnPixDisplay : public WindowListener
    {
        virtual void
        WindowDisplayEvent(Window *src, void* userData)
        {
            LENSE*  detail = (LENSE*) userData;
            int     w, h;
            src->GetDimensions(w,h);
            viewSys.SetDimensions(detail->view, -10, -10, w+20, h+20);
        }
    };

    void BuildTab_GalaxyGrid(Tabs* tabs)
    {
        Window*       tab    = tabs->CreateTab("Large Grid", 120);
        TitledWindow* navTW  = new TitledWindow(tab,0,0,300,300,"Navigate");
        TitledWindow* viewTW = new TitledWindow(tab,300,0,600,600,"ViewGrid");
        TitledWindow* pixTW  = new TitledWindow(tab,0,304,300,300,"Pixel Info");
        Window*       pixCP  = pixTW->ContentPane();
        Window*       viewCP = viewTW->ContentPane();
        OGLWND*       oglWnd = Navigate2DChild(navTW->GetOGLWND(),
                                               viewCP->GetOGLWND(), 0,0, 10,10);
        Window*       navWnd = new Window(oglWnd);
        OGLIMAGE*     oglIms[6];


        for (int i=0; i<6; i++)
        {
            char        buf[100];
            sprintf(buf, "Im_%d.png", i+1);
            oglIms[i] = TryReadPNG(buf);
        }

        navTW->SetContentPane(navWnd);

        oglWnd = viewCP->GetOGLWND();
        oglSys.AllowPicking(oglWnd, 1, 1);

        for (int col=0; col<10; col++)
        for (int row=0; row<10; row++)
        {
            OGLVIEW* view = viewSys.View2D(oglWnd, oglIms[ABSRND(6)],
                                           4 + col*520, 4 + row*520, 512, 512);
            viewSys.SetZoom(view, 2.f, 2.f);
            viewSys.SetTexturing(view, true);
            viewSys.SetTags(view, FlexViewTags);
        }

        for (int j=0; j<6; j++)
            oglSys.ReleaseOglImage(oglIms[j]);

        int clW, clH;
        pixCP->GetDimensions(clW, clH);
        LENSE* lense = Lense2D(oglWnd, 200, 200, 200, 200);
        LENSE* detail = Lense2D(pixCP->GetOGLWND(), -10, -10, clW+20, clH+20);
        DetailLense(detail, lense);
        detail->absZooming = true;
        detail->zoomX = 100.f;
        detail->zoomY = 100.f;
        pixCP->SetWindowListener(new OnPixDisplay(), (void*) detail);
    }

    void BuildTab_Regions(Tabs* tabs)
    {
        Window* tab = tabs->CreateTab("Regions", 120);
        int     w, h;

        tab->GetDimensions(w,h);
        ClusterApp* app    = new ClusterApp(tab, 0, 0, w, h);
        OGLWND*     oglWnd = app->ClusterWnd()->GetOGLWND();

        ExampleViewers2dMinMax(oglWnd,100, 0,2000, 0,2000, 128,0, 128,0);
        app->ClusterWnd()->InitClusterViewers();

        app->ConnectTo(tab);
    }

    DropDownWindow*
    NestedDropDown(DropDownWindow *parent, strconst txt, int nest, int tNest)
    {
        DropDownWindow* dropDownWnd = new DropDownWindow(parent, 130, 20, txt);

        for (int i=0; i<3; i++)
        {
            char    buf[100];
            sprintf(buf, "Een text %d", i);
            dropDownWnd->AddWindow(new Button(dropDownWnd, 70, 20, buf));

            sprintf(buf, "Try Level %d", tNest - nest + 2);
            if (nest && !i)
                dropDownWnd->AddWindow(NestedDropDown(dropDownWnd, buf,
                                       nest-1, tNest));
            if (nest == 1 && !i)
            {
                Window* wnd = new Window(dropDownWnd,0,0,700,400);
                wnd->SetBorderType(BEV_ETCHED);
                TitledSixViewer(wnd, 0, 0, 400, 300);
                dropDownWnd->AddWindow(wnd);
            }
            if (!i){
                Window* wogWnd = WoggelWindow(dropDownWnd,0,0,300,200);
                wogWnd->SetBorderType(BEV_ETCHED);
                dropDownWnd->AddWindow(wogWnd);
            }
            if (!nest && !i)
            {
                Window* wnd = new Window(dropDownWnd,0,0,900,400);
                wnd->SetBorderType(BEV_ETCHED);
                TitledGalaxy(wnd, 10, 10, 800, 360);
                dropDownWnd->AddWindow(wnd);
             }
        }
        if (!nest)
            return dropDownWnd;

        ViewSphere* viewSphere = new ViewSphere(dropDownWnd, 0, 0, 300, 200);
        viewSphere->SetBackground(0);
        viewSphere->SetBorderType(BEV_ETCHED);
        viewSphere->SetWindowListener(this,scExtraControl);

        dropDownWnd->AddWindow(viewSphere);

        return dropDownWnd;
    }

    void TitledFancyTreeView(Window* parent, int x, int y, int w, int h)
    {
        TitledWindow*   treeTWnd   = new TitledWindow(parent, x, y, w, h,
                                                      "Fancy TreeView",
                                                      TitledWindow::BtnMax);
        ScrollWnd*      scrollWnd  = new ScrollWnd(treeTWnd, 4, 4, w-8, h-32);
        Window*         scrollHold = scrollWnd->ContentHolder();
        DropDownWindow* dDownWnd   = new DropDownWindow(scrollHold,130,20,
                                                        "Fancy Tree");
        
        treeTWnd->SetContentPane(scrollWnd);
        scrollWnd->ReplaceContentPane(dDownWnd);

        for (int i=0; i<2; i++)
            dDownWnd->AddWindow(NestedDropDown(dDownWnd, "Try Me", 1, 1));
    }

    DropDownWindow*
    ControlDrop(DropDownWindow *parent, strconst txt, int nest)
    {
        DropDownWindow* dropDW = new DropDownWindow(parent, 130, 20, txt);

        if (nest>0)
            dropDW->AddWindow(ControlDrop(dropDW, "Next", nest-1));

        dropDW->AddWindow(new Button(dropDW, 70, 20, "A Button"));

        StaticText* sT = new StaticText(dropDW, 0,0,150,20, "ScrollBar below");
        sT->SetAlign(oglLeftAlign, oglBottomAlign);
        dropDW->AddWindow(sT);

        ScrollBar* sB = new ScrollBar(dropDW, 0, 0, 100, 20, true);
        sB->SetRange(100,10);
        dropDW->AddWindow(sB);

        return dropDW;
    }

    void TitledControlTreeView(Window* parent, int x, int y, int w, int h)
    {
        TitledWindow*   treeTWnd   = new TitledWindow(parent,x,y,w,h,"TreeView",
                                                      TitledWindow::BtnMax);
        ScrollWnd*      scrollWnd  = new ScrollWnd(treeTWnd,4,4,w-8,h-32);
        Window*         scrollHold = scrollWnd->ContentHolder();
        DropDownWindow* dDownWnd   = new DropDownWindow(scrollHold,130,20,
                                                        "Control Tree");
        
        treeTWnd->SetContentPane(scrollWnd);
        scrollWnd->ReplaceContentPane(dDownWnd);

        for (int i=0; i<3; i++)
            dDownWnd->AddWindow(ControlDrop(dDownWnd, "DropDown", 2));
    }

    void BuildTab_TreeView(Tabs* tabs)
    {
        Window*       tab    = tabs->CreateTab("TreeView", 100);
        
        TitledControlTreeView(tab, 10, 20, 300, 400);
        TitledFancyTreeView(tab, 320, 20, 300, 400);
        new FramesPerSecond(tab, 0, 0, 60, 30);
    }

    TitledWindow*
    TitledViews(Window* parent, int x, int y, int w, int h,
                std::string title, bool is2D=true, int brdType=BEV_LINE)
    {
        TitledWindow* tWnd = new TitledWindow(parent, x, y, w, h, title,
                                              TitledWindow::BtnMaxClose, is2D);
        tWnd->SetBorderType(brdType);

        OGLWND* pOGLWND = tWnd->ContentPane()->GetOGLWND();
        if (is2D)
            ExampleViewers2dMinMax(pOGLWND,100, 0,1000, 0,650, 100,30, 100,30);
        else
            ExampleViewers3d(pOGLWND, 6, 5, 4);

        oglSys.AllowPicking(pOGLWND, true, true);
        oglSys.AllowDeleteView(pOGLWND, true);
        return tWnd;
    }

    SelectedViewControl*
    TitledViewControl(Window* parent, int x, int y, Window* target)
    {
        TitledWindow*           titleWnd;
        SelectedViewControl*    selVC;
        int                     prefW, prefH;
        
        SelectedViewControl::PreferredSize(prefW, prefH);
        titleWnd = new TitledWindow(parent, 4, 4, prefW+8, prefH+32,
                                    "Selected Viewers Control", 1);

        selVC = new SelectedViewControl(titleWnd, 0, 0, prefW, prefH, target);
        selVC->SetBorderType(0);
        selVC->SetGroupBorderShading(0x40a0a0a0, 1);
        titleWnd->SetContentPane(selVC);
        return selVC;
    }

    Camera3DControl*
    TitledCamera3DControl(Window *parent, int x, int y, Window* target)
    {
        int prefW, prefH;
        Camera3DControl::PreferredSize(prefW, prefH);

        TitledWindow*    titWnd  = new TitledWindow(parent,x,y,prefW+8,prefH+32,
                                                    "Camera Control", 1);
        Camera3DControl* camCtrl = new Camera3DControl(titWnd, 0, 0,
                                                       prefW, prefH, target);
        titWnd->SetContentPane(camCtrl);
        camCtrl->SetGroupBorderShading(0x40a0a0a0, 1);
        return camCtrl;
    }

    void Titled4Woggels(Window* wnd, int x, int y, int w, int h)
    {
        TitledWindow*    tWnd;
        FourPanesWindow* panesWnd;
        Window*          woggelWnd;
        int              i, clX, clY, clW, clH;

        tWnd = new TitledWindow(wnd, x, y, w, h, "Woggel",
                                TitledWindow::NoContent |
                                TitledWindow::BtnMaxClose);

        tWnd->SetMinMaxSizes(250, RETAIN, 250, RETAIN);
        tWnd->GetClientArea(clX, clY, clW, clH);
        panesWnd = new FourPanesWindow(tWnd, clX, clY, clW, clH);
        tWnd->SetContentPane(panesWnd);

        for (i=0; i<4; i++)
        {
            woggelWnd = WoggelWindow(panesWnd, 0, 0, 100, 100);
            panesWnd->RegisterPane(woggelWnd, i);
        }
        panesWnd->LayoutPanes();
        FramesPerSecond* fpsWnd = new FramesPerSecond(panesWnd, 0, 0, 100, 20);
    }

    void FillScrollContent(Window *wnd, char *str, int n, int m)
    {
        char        buf[100];
        Button*     btn;
        int         i, j;

        wnd->SetDisableOGLViewKeys(true);
        wnd->SetDisableOGLViewMouse(true);

        wnd->SetDimensions(0, 0, 4 + m * 180, 4 + n * 80);
        for (i=0; i<n; i++)
            for (j=0; j<m; j++)
            {
                sprintf(buf, "%s[%d,%d]", str, i, j);
                btn = new Button(wnd, 2 + j * 180, 2 + i * 80, 70, 60,
                                 buf, 1 + (j+i)%6, !(i%2));
                                if (i < (n/2))
                                        btn->SetBorderFillShaded(1 );
            }        
    }

    void RotateSelectedViews(Window* wnd)
    {
        TitledWindow* titW = new TitledWindow(wnd, 20, 20, 408, 332, "Rotating",
                                              TitledWindow::BtnMaxClose);
        Window*       pane = new Window(GroupRotateChild(titW->GetOGLWND(),
                                        0, 0, 10, 10), false);
        OGLWND*       oglW = wnd->GetOGLWND();
        LIST*         obj  = oglW->objectList;

        if (!obj) return;

        titW->SetContentPane(pane);

        float z = -5.0;
        while (obj->next) obj = obj->next;
        while (obj)
        {
                    OGLVIEW* view = (OGLVIEW *) obj->info;
                    if (viewSys.HasTags(view,selectedTag))
            {
                            float x = -2.0f + view->x / 100.0f;
                float y = -2.0f + view->y / 100.0f;
                            OGLVIEW3D* v3D = ImToGroupRotate(pane->GetOGLWND(), view->im,
                                                 x, y, z, view->w/100.f,
                                                 view->h/100.f,1.f );
                view3DSys.SetZoom(v3D, view->w/100.0f, view->h/100.f);
//                                                    x, y, z, 1.f, 1.f, 1.f );
                view3DSys.SetTags(v3D, selectedTag);
                            z -= 0.2f;
                    }
                    obj = obj->prev;
            }
        pane->KeyboardFunc('s', 0);
        oglSys.AllowPicking(pane->GetOGLWND(),true,true);
        oglSys.SetAllowCameraMove(pane->GetOGLWND(),true);
    }

    TitledWindow* TitledSixViewer(Window* parent, int x, int y, int w, int h)
    {
        TitledWindow*    titWnd = new TitledWindow(parent, 0, 0, 508, 532,
                                                   "Six Viewer Control",
                                                   TitledWindow::BtnMax);
        Window*          pane   = titWnd->ContentPane();
        int              W      = pane->W();
        int              H      = pane->H();
        SixView2DWindow* v6Wnd  = new SixView2DWindow(pane,0,108,W,H-112);
        ZoomPanControl*  zPanC  = new ZoomPanControl(pane,0,0,W/2,108,v6Wnd,10);
        LenseControl*    lenseC = new LenseControl(pane,W/2+2,2,W/2-2,104,100);
        LENSE*           lense  = Lense2D(v6Wnd->GetOGLWND(),100,200,128,128);
       
        for (int i=0; i<6; i++)
        {
            OGLIMAGE*   oglIm;
            char        buf[100];
            sprintf(buf, "Im_%d.png", i+1);
            oglIm = TryReadPNG(buf);
            v6Wnd->SetImage(oglIm, i);
            oglSys.ReleaseOglImage( oglIm );
        }

        viewSys.SetTags(v6Wnd->GetView(0), selectedTag);
        v6Wnd->SetWindowListener(this, scExtraControl);
        v6Wnd ->ConnectTo(pane);
        zPanC ->ScaleTo(pane, NoVertical);
        lenseC->ScaleTo(pane, NoVertical);
        lenseC->ScaleChildren(0, 1);
        lenseC->SetLenseTarget(lense);
        titWnd->SetDimensions(x, y, w, h);
        return titWnd;
    }

    TitledWindow*
    TitledZoomControl(Window* parent, int x,int y, int w,int h, Window* target)
    {
        TitledWindow* titWnd = new TitledWindow(parent,x,y,w,h,"Zoom Control");
        Window*       pane   = titWnd->ContentPane();
        ZoomControl*  zoomC  = new ZoomControl(pane,0,0,pane->W(),pane->H(),10);
        zoomC->SetZoomTarget(target);
        zoomC->ConnectTo(pane);
        return titWnd;
    }

    TitledWindow*
    TitledPanControl(Window* parent, int x,int y, int w,int h, Window* target)
    {
        TitledWindow* titWnd = new TitledWindow(parent,x,y,w,h,"Pan Control",
                                                TitledWindow::BtnMaxClose);
        Window*       pane   = titWnd->ContentPane();
        Window*       panC   = new Window(pane, 0, 0, pane->W(), pane->H());

        ZoomPanFuncs(panC->GetOGLWND(), target->GetOGLWND(), 1, 1, "Pan");
        panC->SetBorderFillShaded(2);
        panC->ConnectTo(pane);
        return titWnd;
    }

    TitledWindow*
    TitledLenseControl(Window* parent, int x,int y,int w,int h, Window* target)
    {
        TitledWindow* titWnd = new TitledWindow(parent,x,y,w,h,"Lense Control");
        Window*       pane   = titWnd->ContentPane();
        int           pW     = pane->W();
        int           pH     = pane->H();

        LenseControl* lenseC = new LenseControl(pane,0, 0, pW, pH, 100);
        LENSE*        lense  = Lense2D(target->GetOGLWND(), 100, 200, 128, 128);
        lenseC->SetLenseTarget(lense);
        lenseC->ConnectTo(pane);
        return  titWnd;
    }

    TitledWindow*
    TitledZoomPanLense(Window* parent, int x, int y, int w, int h)
    {
        TitledWindow*    titWnd = TitledViews(parent,x,y,w,h,"Zoom Pan Lense");
        Window*          pane   = titWnd->ContentPane();
        int              pW     = pane->W();

        TitledZoomControl(pane, 0, 0, pW/2, 140, pane);
        TitledPanControl(pane, 0, 160, 160, 160, pane);
        TitledLenseControl(pane, pW/2+2, 0, pW/2, 140, pane);
        pane->SetWindowListener(this, scExtraControl);
       
        return titWnd;
    }

    static void MyOnDrawView2D(OGLVIEW* view)
    {
        OGC myOGC;
        int bInfo[3];

        OGCSave(&myOGC);
        glPushMatrix();
        oglSys.StartBlend(bInfo);

        SetFillColors(oglRED, oglGREEN, oglBLUE, oglWHITE, 0x80000000);
        // Draw oval centered on upper right corner of view
        viewSys.View2DNormTransform(view);
        FillOval(1.f, 1.f, 0.25f, 0.25f);

        // Draw oval centered on lower left corner of image
        viewSys.View2DImageNormTransform(view);
        FillOval(0.f,0.f, 0.25f, 0.25f);

        oglSys.EndBlend(bInfo);
        glPopMatrix();
        OGCRestore(&myOGC);
    }

    static void MyOnDrawView3D(OGLVIEW3D* view)
    {
        OGC myOGC;
        int bInfo[3];

        OGCSave(&myOGC);
        glPushMatrix();
        oglSys.StartBlend(bInfo);

        SetFillColors(oglRED, oglGREEN, oglBLUE, oglBLACK, 0x80ffffff);
        // Oval in upper corner of view, origin is in center
        view3DSys.View3DNormTransform(view);
        FillEllipse3D(0.5f, 0.5f, 0.01f, 0.25f, 0.25f, 0.35f, 0.15f);

        SetFillColors(oglBLACK, oglBLACK, oglBLACK, oglRED, oglTrWHITE);
        // Oval in lower left corner of image, origin is lower left
        view3DSys.View3DImageNormTransform(view);
        FillOval3D(0.0f, 0.0f, 0.01f, 0.25f, 0.25f);

        oglSys.EndBlend(bInfo);
        glPopMatrix();
        OGCRestore(&myOGC);
    }

    void SetOnDrawViewGraphics(Window* src, bool drawGraphics=true)
    {
        OGLWND* oglWnd = src->GetOGLWND();
        LIST*   obj;

        ForAllElements(obj, oglWnd->objectList)
        {
            if (src->Is2d())
            {
                OGLVIEW* view = (OGLVIEW*) obj->info;
                if (viewSys.HasTags(view, selectedTag))
                    view->OnDrawView = drawGraphics ? MyOnDrawView2D : 0;
            }
            else
            {
                OGLVIEW3D* view = (OGLVIEW3D*) obj->info;
                if (view3DSys.HasTags(view, selectedTag))
                    view->OnDrawView = drawGraphics ? MyOnDrawView3D : 0;
            }
        }
    }

private:
    Tabs    *mTabs;
};

} // namespace OglGui

extern "C" OGLWND* C_OglDemo(OGLWND* parent, int x, int y ,int w, int h)
{
    OglGui::OglDemo* oglDemo = new OglGui::OglDemo(parent, x, y, w, h);
    return oglDemo->GetOGLWND();
}
#endif

---