viewerglutogl.h

Go to the documentation of this file.

#ifndef VART_VIEWERGLUTOGL_H
#define VART_VIEWERGLUTOGL_H

#include "vart/scene.h"
#include "vart/contrib/mousecontrol.h"
#include <list>

namespace VART {
    const int KEY_F1 = GLUT_KEY_F1 + 255;
    const int KEY_F2 = GLUT_KEY_F2 + 255;
    const int KEY_F3 = GLUT_KEY_F3 + 255;
    const int KEY_F4 = GLUT_KEY_F4 + 255;
    const int KEY_F5 = GLUT_KEY_F5 + 255;
    const int KEY_F6 = GLUT_KEY_F6 + 255;
    const int KEY_F7 = GLUT_KEY_F7 + 255;
    const int KEY_F8 = GLUT_KEY_F8 + 255;
    const int KEY_F9 = GLUT_KEY_F9 + 255;
    const int KEY_F10 = GLUT_KEY_F10 + 255;
    const int KEY_F11 = GLUT_KEY_F11 + 255;
    const int KEY_F12 = GLUT_KEY_F12 + 255;
    const int KEY_LEFT = GLUT_KEY_LEFT + 255;
    const int KEY_UP = GLUT_KEY_UP + 255;
    const int KEY_RIGHT = GLUT_KEY_RIGHT + 255;
    const int KEY_DOWN = GLUT_KEY_DOWN + 255;
    const int KEY_PAGE_UP = GLUT_KEY_PAGE_UP + 255;
    const int KEY_PAGE_DOWN = GLUT_KEY_PAGE_DOWN + 255;
    const int KEY_HOME = GLUT_KEY_HOME + 255;
    const int KEY_END = GLUT_KEY_END + 255;
    const int KEY_INSERT = GLUT_KEY_INSERT + 255;

    class ViewerGlutOGL {
        public:
        // PUBLIC NESTED CLASSES
            // These classes are nested because other types of viewers may have different
            // needs for their handlers.

            class KbHandler
            {
                friend class ViewerGlutOGL;
                public:
                    virtual ~KbHandler() {};
                    virtual void HandleKey(unsigned char key) { }
                    virtual void OnKeyDown(int key); // FixMe: make pure virtual
                    virtual void HandleSpecialKey(int key) { }
                    virtual void OnKeyUp(int key) { }
                protected:
                    ViewerGlutOGL* viewerPtr;
            };
            class IdleHandler
            {
                friend class ViewerGlutOGL;
                public:
                    virtual ~IdleHandler() {};
                    virtual void OnIdle()=0;
                protected:
                    ViewerGlutOGL* viewerPtr;
            };
            class DrawHandler
            {
                friend class ViewerGlutOGL;
                public:
                    virtual ~DrawHandler() {};
                    virtual void OnDraw()=0;
                protected:
                    ViewerGlutOGL* viewerPtr;
            };
        // PUBLIC METHODS
            ViewerGlutOGL();

            ViewerGlutOGL(int newWidth, int newHeight);

            ~ViewerGlutOGL();

            void SetScene(Scene& scene);

            void SetPosition(int x, int y);

            void SetKbHandler(KbHandler* ptrKbH);

            void SetIdleHandler(IdleHandler* newIHPtr);

            void SetDrawHandler(DrawHandler* newDHPtr);

            void SetCamera(Camera* camPtr);

            void SetClickHandler(MouseControl::ClickHandler* newCHPtr);

            void SetDragHandler(MouseControl::DragHandler* newDHPtr);

            void SetMotionHandler(MouseControl::MotionHandler* newMHPtr);

            void Idle();

            void SetSize(int newWidth, int newHeight);
            int GetWidth() { return width; }
            int GetHeight() { return height; }

            const Camera* GetCurrentCamera() const { return cameraPtr; }

            void Hide();

            void Show();

            void TurnIntoCurrentWindow();

            void SetTitle(const std::string& newTitle);

            void Iconify();

            void PostRedisplay();

            void UseNextCamera() { ptScene->UseNextCamera(); }

        // PUBLIC STATIC METHODS

            static void MainLoop();

            static void Init(int* argcPtr, char* argv[]);

            static void RedisplayAll();

        // PUBLIC ATTRIBUTES
            bool autoChangeCameraAspect;

            bool redrawOnIdle;

            float walkStep;

            bool autoNavigationEnabled;

            bool autoRespondKeys;

        protected:
            void ClearOGLBuffers();

        private:
        // PRIVATE STATIC METHODS (GLUT CALLBACKS)
            // Drawing callbacks
            static void DrawCB0();
            static void DrawCB1();
            static void DrawCB2();
            static void DrawCB3();
            static void DrawCB4();
            static void DrawCB5();
            // Mouse click callbacks
            static void MouseCB0(int, int, int, int);
            static void MouseCB1(int, int, int, int);
            static void MouseCB2(int, int, int, int);
            static void MouseCB3(int, int, int, int);
            static void MouseCB4(int, int, int, int);
            static void MouseCB5(int, int, int, int);
            // Mouse drag callbacks
            static void DragMouseCB0(int x, int y);
            static void DragMouseCB1(int x, int y);
            static void DragMouseCB2(int x, int y);
            static void DragMouseCB3(int x, int y);
            static void DragMouseCB4(int x, int y);
            static void DragMouseCB5(int x, int y);
            // Special keys callbacks for key down
            static void SpecialKeyCB0(int key, int x, int y);
            static void SpecialKeyCB1(int key, int x, int y);
            static void SpecialKeyCB2(int key, int x, int y);
            static void SpecialKeyCB3(int key, int x, int y);
            static void SpecialKeyCB4(int key, int x, int y);
            static void SpecialKeyCB5(int key, int x, int y);
            // Special keys callbacks for key up
            static void SpecialKeyUpCB0(int key, int x, int y);
            static void SpecialKeyUpCB1(int key, int x, int y);
            static void SpecialKeyUpCB2(int key, int x, int y);
            static void SpecialKeyUpCB3(int key, int x, int y);
            static void SpecialKeyUpCB4(int key, int x, int y);
            static void SpecialKeyUpCB5(int key, int x, int y);
            // Keyboard callbacks
            static void KeyboardCB0(unsigned char key, int x, int y);
            static void KeyboardCB1(unsigned char key, int x, int y);
            static void KeyboardCB2(unsigned char key, int x, int y);
            static void KeyboardCB3(unsigned char key, int x, int y);
            static void KeyboardCB4(unsigned char key, int x, int y);
            static void KeyboardCB5(unsigned char key, int x, int y);
            // Callbacks for key ups:
            static void OnKeyUpCB0(unsigned char key, int x, int y);
            static void OnKeyUpCB1(unsigned char key, int x, int y);
            static void OnKeyUpCB2(unsigned char key, int x, int y);
            static void OnKeyUpCB3(unsigned char key, int x, int y);
            static void OnKeyUpCB4(unsigned char key, int x, int y);
            static void OnKeyUpCB5(unsigned char key, int x, int y);
            // Resize callbacks
            static void ResizeCB0(int newWidth, int newHeight);
            static void ResizeCB1(int newWidth, int newHeight);
            static void ResizeCB2(int newWidth, int newHeight);
            static void ResizeCB3(int newWidth, int newHeight);
            static void ResizeCB4(int newWidth, int newHeight);
            static void ResizeCB5(int newWidth, int newHeight);
            // Idle callback
            static void IdleMngr();
        // PRIVATE STATIC ATRIBUTES
            static int glutIDVec[6]; // GLUT window IDs
            static ViewerGlutOGL* instancePtrVec[6]; // pointers to class instances
        // PRIVATE METHODS
            void RegisterCallbacks();
            void CommonConstructor();
            void HandleKey(unsigned char key);
        // PRIVATE ATRIBUTES
            Scene* ptScene; // objects, lights and cameras
            int glutID; // GLUT window id
            KbHandler* kbHandlerPtr;
            DrawHandler* drawHandlerPtr; // pointer to draw handler
            IdleHandler* idleHndPtr; // pointer to idle handler
            MouseControl mouseController;
            int height; // window height in pixels
            int width;  // window width in pixels
            Camera* cameraPtr;
    }; // end class declaration
} // end namespace

#endif