qglviewer.h

Go to the documentation of this file.

/****************************************************************************

 Copyright (C) 2002-2014 Gilles Debunne. All rights reserved.

 This file is part of the QGLViewer library version 2.6.3.

 http://www.libqglviewer.com - contact@libqglviewer.com

 This file may be used under the terms of the GNU General Public License 
 versions 2.0 or 3.0 as published by the Free Software Foundation and
 appearing in the LICENSE file included in the packaging of this file.
 In addition, as a special exception, Gilles Debunne gives you certain 
 additional rights, described in the file GPL_EXCEPTION in this package.

 libQGLViewer uses dual licensing. Commercial/proprietary software must
 purchase a libQGLViewer Commercial License.

 This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.

*****************************************************************************/

#ifndef QGLVIEWER_QGLVIEWER_H
#define QGLVIEWER_QGLVIEWER_H

#include "camera.h"

#include <QMap>
#include <QClipboard>
#include <QTime>

class QTabWidget;

namespace qglviewer {
class MouseGrabber;
class ManipulatedFrame;
class ManipulatedCameraFrame;
}

class QGLVIEWER_EXPORT QGLViewer : public QGLWidget
{
        Q_OBJECT

public:
        // Complete implementation is provided so that the constructor is defined with QT3_SUPPORT when .h is included.
        // (Would not be available otherwise since lib is compiled without QT3_SUPPORT).
#ifdef QT3_SUPPORT
        explicit QGLViewer(QWidget* parent=NULL, const char* name=0, const QGLWidget* shareWidget=0, Qt::WindowFlags flags=0)
                : QGLWidget(parent, name, shareWidget, flags)
        { defaultConstructor(); }

        explicit QGLViewer(const QGLFormat& format, QWidget* parent=0, const char* name=0, const QGLWidget* shareWidget=0,Qt::WindowFlags flags=0)
                : QGLWidget(format, parent, name, shareWidget, flags)
        { defaultConstructor(); }

        QGLViewer(QGLContext* context, QWidget* parent, const char* name=0, const QGLWidget* shareWidget=0, Qt::WindowFlags flags=0)
                : QGLWidget(context, parent, name, shareWidget, flags) {
                defaultConstructor(); }

#else

        explicit QGLViewer(QWidget* parent=0, const QGLWidget* shareWidget=0, Qt::WindowFlags flags=0);
        explicit QGLViewer(QGLContext *context, QWidget* parent=0, const QGLWidget* shareWidget=0, Qt::WindowFlags flags=0);
        explicit QGLViewer(const QGLFormat& format, QWidget* parent=0, const QGLWidget* shareWidget=0, Qt::WindowFlags flags=0);
#endif

        virtual ~QGLViewer();

public:
        bool axisIsDrawn() const { return axisIsDrawn_; }
        bool gridIsDrawn() const { return gridIsDrawn_; }
        bool FPSIsDisplayed() const { return FPSIsDisplayed_; }
        bool textIsEnabled() const { return textIsEnabled_; }

        bool cameraIsEdited() const { return cameraIsEdited_; }


public Q_SLOTS:
        void setAxisIsDrawn(bool draw=true) { axisIsDrawn_ = draw; Q_EMIT axisIsDrawnChanged(draw); update(); }
        void setGridIsDrawn(bool draw=true) { gridIsDrawn_ = draw; Q_EMIT gridIsDrawnChanged(draw); update(); }
        void setFPSIsDisplayed(bool display=true) { FPSIsDisplayed_ = display; Q_EMIT FPSIsDisplayedChanged(display); update(); }
        void setTextIsEnabled(bool enable=true) { textIsEnabled_ = enable; Q_EMIT textIsEnabledChanged(enable); update(); }
        void setCameraIsEdited(bool edit=true);

        void toggleAxisIsDrawn() { setAxisIsDrawn(!axisIsDrawn()); }
        void toggleGridIsDrawn() { setGridIsDrawn(!gridIsDrawn()); }
        void toggleFPSIsDisplayed() { setFPSIsDisplayed(!FPSIsDisplayed()); }
        void toggleTextIsEnabled() { setTextIsEnabled(!textIsEnabled()); }
        void toggleCameraIsEdited() { setCameraIsEdited(!cameraIsEdited()); }


public:
        QColor backgroundColor() const { return backgroundColor_; }

        QColor foregroundColor() const { return foregroundColor_; }
public Q_SLOTS:
        void setBackgroundColor(const QColor& color) { backgroundColor_=color; qglClearColor(color); }
        void setForegroundColor(const QColor& color) { foregroundColor_ = color; }


public:
        qreal sceneRadius() const { return camera()->sceneRadius(); }
        qglviewer::Vec sceneCenter() const { return camera()->sceneCenter(); }

public Q_SLOTS:
        virtual void setSceneRadius(qreal radius) { camera()->setSceneRadius(radius); }

        virtual void setSceneCenter(const qglviewer::Vec& center) { camera()->setSceneCenter(center); }

        void setSceneBoundingBox(const qglviewer::Vec& min, const qglviewer::Vec& max) { camera()->setSceneBoundingBox(min,max); }

        void showEntireScene() { camera()->showEntireScene(); update(); }


public:
        qglviewer::Camera* camera() const { return camera_; }

        qglviewer::ManipulatedFrame* manipulatedFrame() const { return manipulatedFrame_; }

public Q_SLOTS:
        void setCamera(qglviewer::Camera* const camera);
        void setManipulatedFrame(qglviewer::ManipulatedFrame* frame);


public:
        qglviewer::MouseGrabber* mouseGrabber() const { return mouseGrabber_; }

        void setMouseGrabberIsEnabled(const qglviewer::MouseGrabber* const mouseGrabber, bool enabled=true);
        bool mouseGrabberIsEnabled(const qglviewer::MouseGrabber* const mouseGrabber) { return !disabledMouseGrabbers_.contains(reinterpret_cast<size_t>(mouseGrabber)); }
public Q_SLOTS:
        void setMouseGrabber(qglviewer::MouseGrabber* mouseGrabber);


public:
        qreal aspectRatio() const { return width() / static_cast<qreal>(height()); }
        qreal currentFPS() { return f_p_s_; }
        bool isFullScreen() const { return fullScreen_; }
        bool displaysInStereo() const { return stereo_; }
        virtual QSize sizeHint() const { return QSize(600, 400); }

public Q_SLOTS:
        void setFullScreen(bool fullScreen=true);
        void setStereoDisplay(bool stereo=true);
        void toggleFullScreen() { setFullScreen(!isFullScreen()); }
        void toggleStereoDisplay() { setStereoDisplay(!stereo_); }
        void toggleCameraMode();

private:
        bool cameraIsInRotateMode() const;


public:
        static void drawArrow(qreal length=1.0, qreal radius=-1.0, int nbSubdivisions=12);
        static void drawArrow(const qglviewer::Vec& from, const qglviewer::Vec& to, qreal radius=-1.0, int nbSubdivisions=12);
        static void drawAxis(qreal length=1.0);
        static void drawGrid(qreal size=1.0, int nbSubdivisions=10);

        virtual void startScreenCoordinatesSystem(bool upward=false) const;
        virtual void stopScreenCoordinatesSystem() const;

        void drawText(int x, int y, const QString& text, const QFont& fnt=QFont());
        void displayMessage(const QString& message, int delay=2000);
        // void draw3DText(const qglviewer::Vec& pos, const qglviewer::Vec& normal, const QString& string, GLfloat height=0.1);

protected:
        virtual void drawLight(GLenum light, qreal scale = 1.0) const;

private:
        void displayFPS();
        void drawVectorial() { paintGL(); }

#ifndef DOXYGEN
        friend void drawVectorial(void* param);
#endif



#ifdef DOXYGEN

public:
        int width() const;
        int height() const;
        virtual void updateGL();
        static QImage convertToGLFormat(const QImage & image);
        void qglColor(const QColor& color) const;
        void qglClearColor(const QColor& color) const;
        bool isValid() const;
        bool isSharing() const;
        virtual void makeCurrent();
        bool hasMouseTracking () const;
public Q_SLOTS:
        virtual void resize(int width, int height);
        virtual void setMouseTracking(bool enable);
protected:
        bool autoBufferSwap() const;
protected Q_SLOTS:
        void setAutoBufferSwap(bool on);
#endif


public:
        const QString& snapshotFileName() const { return snapshotFileName_; }
#ifndef DOXYGEN
        const QString& snapshotFilename() const;
#endif

        const QString& snapshotFormat() const { return snapshotFormat_; }
        int snapshotCounter() const { return snapshotCounter_; }
        int snapshotQuality() { return snapshotQuality_; }

        // Qt 2.3 does not support qreal default value parameters in slots.
        // Remove "Q_SLOTS" from the following line to compile with Qt 2.3
public Q_SLOTS:
        void saveSnapshot(bool automatic=true, bool overwrite=false);

public Q_SLOTS:
        void saveSnapshot(const QString& fileName, bool overwrite=false);
        void setSnapshotFileName(const QString& name);

        void setSnapshotFormat(const QString& format) { snapshotFormat_ = format; }
        void setSnapshotCounter(int counter) { snapshotCounter_ = counter; }
        void setSnapshotQuality(int quality) { snapshotQuality_ = quality; }
        bool openSnapshotFormatDialog();
        void snapshotToClipboard();

private:
        bool saveImageSnapshot(const QString& fileName);

#ifndef DOXYGEN
        /* This class is used internally for screenshot that require tiling (image size size different
        from window size). Only in that case, is the private tileRegion_ pointer non null.
        It then contains the current tiled region, which is used by startScreenCoordinatesSystem
        to adapt the coordinate system. Not using it would result in a tiled drawing of the parts
        that use startScreenCoordinatesSystem. Also used by scaledFont for same purposes. */
        class TileRegion { public : qreal xMin, yMin, xMax, yMax, textScale; };
#endif

public:
        QFont scaledFont(const QFont& font) const {
                if (tileRegion_ == NULL)
                        return font;
                else {
                        QFont f(font);
                        if (f.pixelSize() == -1)
                                f.setPointSizeF(f.pointSizeF() * tileRegion_->textScale);
                        else
                                f.setPixelSize(int(f.pixelSize() * tileRegion_->textScale));
                        return f;
                }
        }


public:
        GLuint bufferTextureId() const;
        qreal bufferTextureMaxU() const { return bufferTextureMaxU_; }
        qreal bufferTextureMaxV() const { return bufferTextureMaxV_; }
public Q_SLOTS:
        void copyBufferToTexture(GLint internalFormat, GLenum format=GL_NONE);

public:
        bool animationIsStarted() const { return animationStarted_; }
        int animationPeriod() const { return animationPeriod_; }

public Q_SLOTS:
        void setAnimationPeriod(int period) { animationPeriod_ = period; }
        virtual void startAnimation();
        virtual void stopAnimation();
        virtual void animate() { Q_EMIT animateNeeded(); }
        void toggleAnimation() { if (animationIsStarted()) stopAnimation(); else startAnimation(); }

public:
Q_SIGNALS:
        void viewerInitialized();

        void drawNeeded();

        void drawFinished(bool automatic);

        void animateNeeded();

        void helpRequired();

        void axisIsDrawnChanged(bool drawn);
        void gridIsDrawnChanged(bool drawn);
        void FPSIsDisplayedChanged(bool displayed);
        void textIsEnabledChanged(bool enabled);
        void cameraIsEditedChanged(bool edited);
        void stereoChanged(bool on);
        void pointSelected(const QMouseEvent* e);

        void mouseGrabberChanged(qglviewer::MouseGrabber* mouseGrabber);

public:
        virtual QString helpString() const { return tr("No help available."); }

        virtual QString mouseString() const;
        virtual QString keyboardString() const;

#ifndef DOXYGEN

        virtual QString mouseBindingsString () const { return mouseString(); }
        virtual QString shortcutBindingsString () const { return keyboardString(); }
#endif

public Q_SLOTS:
        virtual void help();
        virtual void aboutQGLViewer();

protected:
        QTabWidget* helpWidget() { return helpWidget_; }


protected:
        virtual void resizeGL(int width, int height);
        virtual void initializeGL();

        virtual void init() { Q_EMIT viewerInitialized(); }

        virtual void paintGL();
        virtual void preDraw();
        virtual void preDrawStereo(bool leftBuffer=true);

        virtual void draw() {}
        virtual void fastDraw();
        virtual void postDraw();

protected:
        virtual void mousePressEvent(QMouseEvent *);
        virtual void mouseMoveEvent(QMouseEvent *);
        virtual void mouseReleaseEvent(QMouseEvent *);
        virtual void mouseDoubleClickEvent(QMouseEvent *);
        virtual void wheelEvent(QWheelEvent *);
        virtual void keyPressEvent(QKeyEvent *);
        virtual void keyReleaseEvent(QKeyEvent *);
        virtual void timerEvent(QTimerEvent *);
        virtual void closeEvent(QCloseEvent *);

public:
        int selectedName() const { return selectedObjectId_; }
        int selectBufferSize() const { return selectBufferSize_; }

        int selectRegionWidth() const { return selectRegionWidth_; }
        int selectRegionHeight() const { return selectRegionHeight_; }

        GLuint* selectBuffer() { return selectBuffer_; }

public Q_SLOTS:
        virtual void select(const QMouseEvent* event);
        virtual void select(const QPoint& point);

        void setSelectBufferSize(int size);
        void setSelectRegionWidth(int width) { selectRegionWidth_ = width; }
        void setSelectRegionHeight(int height) { selectRegionHeight_ = height; }
        void setSelectedName(int id) { selectedObjectId_=id; }

protected:
        virtual void beginSelection(const QPoint& point);
        virtual void drawWithNames() {}
        virtual void endSelection(const QPoint& point);
        virtual void postSelection(const QPoint& point) { Q_UNUSED(point); }


public:
        enum KeyboardAction { DRAW_AXIS, DRAW_GRID, DISPLAY_FPS, ENABLE_TEXT, EXIT_VIEWER,
                                                  SAVE_SCREENSHOT, CAMERA_MODE, FULL_SCREEN, STEREO, ANIMATION, HELP, EDIT_CAMERA,
                                                  MOVE_CAMERA_LEFT, MOVE_CAMERA_RIGHT, MOVE_CAMERA_UP, MOVE_CAMERA_DOWN,
                                                  INCREASE_FLYSPEED, DECREASE_FLYSPEED, SNAPSHOT_TO_CLIPBOARD };

        unsigned int shortcut(KeyboardAction action) const;
#ifndef DOXYGEN
        // QGLViewer 1.x
        unsigned int keyboardAccelerator(KeyboardAction action) const;
        Qt::Key keyFrameKey(unsigned int index) const;
        Qt::KeyboardModifiers playKeyFramePathStateKey() const;
        // QGLViewer 2.0 without Qt4 support
        Qt::KeyboardModifiers addKeyFrameStateKey() const;
        Qt::KeyboardModifiers playPathStateKey() const;
#endif
        Qt::Key pathKey(unsigned int index) const;
        Qt::KeyboardModifiers addKeyFrameKeyboardModifiers() const;
        Qt::KeyboardModifiers playPathKeyboardModifiers() const;

public Q_SLOTS:
        void setShortcut(KeyboardAction action, unsigned int key);
#ifndef DOXYGEN
        void setKeyboardAccelerator(KeyboardAction action, unsigned int key);
#endif
        void setKeyDescription(unsigned int key, QString description);
        void clearShortcuts();

        // Key Frames shortcut keys
#ifndef DOXYGEN
        // QGLViewer 1.x compatibility methods
        virtual void setKeyFrameKey(unsigned int index, int key);
        virtual void setPlayKeyFramePathStateKey(unsigned int buttonState);
        // QGLViewer 2.0 without Qt4 support
        virtual void setPlayPathStateKey(unsigned int buttonState);
        virtual void setAddKeyFrameStateKey(unsigned int buttonState);
#endif
        virtual void setPathKey(int key, unsigned int index = 0);
        virtual void setPlayPathKeyboardModifiers(Qt::KeyboardModifiers modifiers);
        virtual void setAddKeyFrameKeyboardModifiers(Qt::KeyboardModifiers modifiers);


public:
        enum MouseHandler { CAMERA, FRAME };

        enum ClickAction { NO_CLICK_ACTION, ZOOM_ON_PIXEL, ZOOM_TO_FIT, SELECT, RAP_FROM_PIXEL, RAP_IS_CENTER,
                                           CENTER_FRAME, CENTER_SCENE, SHOW_ENTIRE_SCENE, ALIGN_FRAME, ALIGN_CAMERA };


        enum MouseAction { NO_MOUSE_ACTION,
                                           ROTATE, ZOOM, TRANSLATE,
                                           MOVE_FORWARD, LOOK_AROUND, MOVE_BACKWARD,
                                           SCREEN_ROTATE, ROLL, DRIVE,
                                           SCREEN_TRANSLATE, ZOOM_ON_REGION };

#ifndef DOXYGEN
        MouseAction mouseAction(unsigned int state) const;
        int mouseHandler(unsigned int state) const;
        int mouseButtonState(MouseHandler handler, MouseAction action, bool withConstraint=true) const;
        ClickAction clickAction(unsigned int state, bool doubleClick, Qt::MouseButtons buttonsBefore) const;
        void getClickButtonState(ClickAction action, unsigned int & state, bool& doubleClick, Qt::MouseButtons& buttonsBefore) const;
        unsigned int wheelButtonState(MouseHandler handler, MouseAction action, bool withConstraint=true) const;
#endif

        MouseAction mouseAction(Qt::Key key, Qt::KeyboardModifiers modifiers, Qt::MouseButton button) const;
        int mouseHandler(Qt::Key key, Qt::KeyboardModifiers modifiers, Qt::MouseButton button) const;

        void getMouseActionBinding(MouseHandler handler, MouseAction action, bool withConstraint,
                                                           Qt::Key& key, Qt::KeyboardModifiers& modifiers, Qt::MouseButton& button) const;

        ClickAction clickAction(Qt::Key key, Qt::KeyboardModifiers modifiers, Qt::MouseButton button,
                                                        bool doubleClick=false, Qt::MouseButtons buttonsBefore=Qt::NoButton) const;

        void getClickActionBinding(ClickAction action, Qt::Key& key, Qt::KeyboardModifiers& modifiers,
                                                           Qt::MouseButton& button, bool& doubleClick, Qt::MouseButtons& buttonsBefore) const;

        MouseAction wheelAction(Qt::Key key, Qt::KeyboardModifiers modifiers) const;
        int wheelHandler(Qt::Key key, Qt::KeyboardModifiers modifiers) const;

        void getWheelActionBinding(MouseHandler handler, MouseAction action, bool withConstraint,
                                                           Qt::Key& key, Qt::KeyboardModifiers& modifiers) const;

public Q_SLOTS:
#ifndef DOXYGEN
        void setMouseBinding(unsigned int state, MouseHandler handler, MouseAction action, bool withConstraint=true);
        void setMouseBinding(unsigned int state, ClickAction action, bool doubleClick=false, Qt::MouseButtons buttonsBefore=Qt::NoButton);
        void setMouseBindingDescription(unsigned int state, QString description, bool doubleClick=false, Qt::MouseButtons buttonsBefore=Qt::NoButton);
#endif

        void setMouseBinding(Qt::KeyboardModifiers modifiers, Qt::MouseButton buttons, MouseHandler handler, MouseAction action, bool withConstraint=true);
        void setMouseBinding(Qt::KeyboardModifiers modifiers, Qt::MouseButton button, ClickAction action, bool doubleClick=false, Qt::MouseButtons buttonsBefore=Qt::NoButton);
        void setWheelBinding(Qt::KeyboardModifiers modifiers, MouseHandler handler, MouseAction action, bool withConstraint=true);
        void setMouseBindingDescription(Qt::KeyboardModifiers modifiers, Qt::MouseButton button, QString description, bool doubleClick=false, Qt::MouseButtons buttonsBefore=Qt::NoButton);

        void setMouseBinding(Qt::Key key, Qt::KeyboardModifiers modifiers, Qt::MouseButton buttons, MouseHandler handler, MouseAction action, bool withConstraint=true);
        void setMouseBinding(Qt::Key key, Qt::KeyboardModifiers modifiers, Qt::MouseButton button, ClickAction action, bool doubleClick=false, Qt::MouseButtons buttonsBefore=Qt::NoButton);
        void setWheelBinding(Qt::Key key, Qt::KeyboardModifiers modifiers, MouseHandler handler, MouseAction action, bool withConstraint=true);
        void setMouseBindingDescription(Qt::Key key, Qt::KeyboardModifiers modifiers, Qt::MouseButton button, QString description, bool doubleClick=false, Qt::MouseButtons buttonsBefore=Qt::NoButton);

        void clearMouseBindings();

#ifndef DOXYGEN
        MouseAction wheelAction(Qt::KeyboardModifiers modifiers) const;
        int wheelHandler(Qt::KeyboardModifiers modifiers) const;

        void setHandlerKeyboardModifiers(MouseHandler handler, Qt::KeyboardModifiers modifiers);
        void setHandlerStateKey(MouseHandler handler, unsigned int buttonState);
        void setMouseStateKey(MouseHandler handler, unsigned int buttonState);
#endif

private:
        static QString mouseActionString(QGLViewer::MouseAction ma);
        static QString clickActionString(QGLViewer::ClickAction ca);


public:
        QString stateFileName() const;
        virtual QDomElement domElement(const QString& name, QDomDocument& document) const;

public Q_SLOTS:
        virtual void initFromDOMElement(const QDomElement& element);
        virtual void saveStateToFile(); // cannot be const because of QMessageBox
        virtual bool restoreStateFromFile();

        void setStateFileName(const QString& name) { stateFileName_ = name; }

#ifndef DOXYGEN
        void saveToFile(const QString& fileName=QString::null);
        bool restoreFromFile(const QString& fileName=QString::null);
#endif

private:
        static void saveStateToFileForAllViewers();


public:
        static const QList<QGLViewer*>& QGLViewerPool() { return QGLViewer::QGLViewerPool_; }


        static int QGLViewerIndex(const QGLViewer* const viewer) { return QGLViewer::QGLViewerPool_.indexOf(const_cast<QGLViewer*>(viewer)); }

#ifndef DOXYGEN

public:
        virtual void setVisualHintsMask(int mask, int delay = 2000);
        virtual void drawVisualHints();

public Q_SLOTS:
        virtual void resetVisualHints();
#endif

private Q_SLOTS:
        // Patch for a Qt bug with fullScreen on startup
        void delayedFullScreen() { move(prevPos_); setFullScreen(); }
        void hideMessage();

private:
        // Copy constructor and operator= are declared private and undefined
        // Prevents everyone from trying to use them
        QGLViewer(const QGLViewer& v);
        QGLViewer& operator=(const QGLViewer& v);

        // Set parameters to their default values. Called by the constructors.
        void defaultConstructor();

        void handleKeyboardAction(KeyboardAction id);

        // C a m e r a
        qglviewer::Camera* camera_;
        bool cameraIsEdited_;
        qreal previousCameraZClippingCoefficient_;
        unsigned int previousPathId_; // double key press recognition
        void connectAllCameraKFIInterpolatedSignals(bool connection=true);

        // C o l o r s
        QColor backgroundColor_, foregroundColor_;

        // D i s p l a y    f l a g s
        bool axisIsDrawn_;      // world axis
        bool gridIsDrawn_;      // world XY grid
        bool FPSIsDisplayed_;   // Frame Per Seconds
        bool textIsEnabled_;    // drawText() actually draws text or not
        bool stereo_;           // stereo display
        bool fullScreen_;       // full screen mode
        QPoint prevPos_;        // Previous window position, used for full screen mode

        // A n i m a t i o n
        bool animationStarted_; // animation mode started
        int animationPeriod_;   // period in msecs
        int animationTimerId_;

        // F P S    d i s p l a y
        QTime fpsTime_;
        unsigned int fpsCounter_;
        QString fpsString_;
        qreal f_p_s_;

        // M e s s a g e s
        QString message_;
        bool displayMessage_;
        QTimer messageTimer_;

        // M a n i p u l a t e d    f r a m e
        qglviewer::ManipulatedFrame* manipulatedFrame_;
        bool manipulatedFrameIsACamera_;

        // M o u s e   G r a b b e r
        qglviewer::MouseGrabber* mouseGrabber_;
        bool mouseGrabberIsAManipulatedFrame_;
        bool mouseGrabberIsAManipulatedCameraFrame_;
        QMap<size_t, bool> disabledMouseGrabbers_;

        // S e l e c t i o n
        int selectRegionWidth_, selectRegionHeight_;
        int selectBufferSize_;
        GLuint* selectBuffer_;
        int selectedObjectId_;

        // V i s u a l   h i n t s
        int visualHint_;

        // S h o r t c u t   k e y s
        void setDefaultShortcuts();
        QString cameraPathKeysString() const;
        QMap<KeyboardAction, QString> keyboardActionDescription_;
        QMap<KeyboardAction, unsigned int> keyboardBinding_;
        QMap<unsigned int, QString> keyDescription_;

        // K e y   F r a m e s   s h o r t c u t s
        QMap<Qt::Key, unsigned int> pathIndex_;
        Qt::KeyboardModifiers addKeyFrameKeyboardModifiers_, playPathKeyboardModifiers_;

        // B u f f e r   T e x t u r e
        GLuint bufferTextureId_;
        qreal bufferTextureMaxU_, bufferTextureMaxV_;
        int bufferTextureWidth_, bufferTextureHeight_;
        unsigned int previousBufferTextureFormat_;
        int previousBufferTextureInternalFormat_;

#ifndef DOXYGEN
        // M o u s e   a c t i o n s
        struct MouseActionPrivate {
                MouseHandler handler;
                MouseAction action;
                bool withConstraint;
        };

        // M o u s e   b i n d i n g s
        struct MouseBindingPrivate {
                const Qt::KeyboardModifiers modifiers;
                const Qt::MouseButton button;
                const Qt::Key key;

                MouseBindingPrivate(Qt::KeyboardModifiers m, Qt::MouseButton b, Qt::Key k)
                        : modifiers(m), button(b), key(k) {}

                // This sort order is used in mouseString() to display sorted mouse bindings
                bool operator<(const MouseBindingPrivate& mbp) const
                {
                        if (key != mbp.key)
                                return key < mbp.key;
                        if (modifiers != mbp.modifiers)
                                return modifiers < mbp.modifiers;
                        return button < mbp.button;
                }
        };

        // W h e e l   b i n d i n g s
        struct WheelBindingPrivate {
                const Qt::KeyboardModifiers modifiers;
                const Qt::Key key;

                WheelBindingPrivate(Qt::KeyboardModifiers m, Qt::Key k)
                        : modifiers(m), key(k) {}

                // This sort order is used in mouseString() to display sorted wheel bindings
                bool operator<(const WheelBindingPrivate& wbp) const
                {
                        if (key != wbp.key)
                                return key < wbp.key;
                        return modifiers < wbp.modifiers;
                }
        };

        // C l i c k   b i n d i n g s
        struct ClickBindingPrivate {
                const Qt::KeyboardModifiers modifiers;
                const Qt::MouseButton button;
                const bool doubleClick;
                const Qt::MouseButtons buttonsBefore; // only defined when doubleClick is true
                const Qt::Key key;

                ClickBindingPrivate(Qt::KeyboardModifiers m, Qt::MouseButton b, bool dc, Qt::MouseButtons bb, Qt::Key k)
                        : modifiers(m), button(b), doubleClick(dc), buttonsBefore(bb), key(k) {}

                // This sort order is used in mouseString() to display sorted mouse bindings
                bool operator<(const ClickBindingPrivate& cbp) const
                {
                        if (key != cbp.key)
                                return key < cbp.key;
                        if (buttonsBefore != cbp.buttonsBefore)
                                return buttonsBefore < cbp.buttonsBefore;
                        if (modifiers != cbp.modifiers)
                                return modifiers < cbp.modifiers;
                        if (button != cbp.button)
                                return button < cbp.button;
                        return doubleClick != cbp.doubleClick;
                }
        };
#endif
        static QString formatClickActionPrivate(ClickBindingPrivate cbp);
        static bool isValidShortcutKey(int key);

        QMap<ClickBindingPrivate, QString> mouseDescription_;

        void setDefaultMouseBindings();
        void performClickAction(ClickAction ca, const QMouseEvent* const e);
        QMap<MouseBindingPrivate, MouseActionPrivate> mouseBinding_;
        QMap<WheelBindingPrivate, MouseActionPrivate> wheelBinding_;
        QMap<ClickBindingPrivate, ClickAction> clickBinding_;
        Qt::Key currentlyPressedKey_;

        // S n a p s h o t s
        void initializeSnapshotFormats();
        QImage frameBufferSnapshot();
        QString snapshotFileName_, snapshotFormat_;
        int snapshotCounter_, snapshotQuality_;
        TileRegion* tileRegion_;

        // Q G L V i e w e r   p o o l
        static QList<QGLViewer*> QGLViewerPool_;

        // S t a t e   F i l e
        QString stateFileName_;

        // H e l p   w i n d o w
        QTabWidget* helpWidget_;
};

#endif // QGLVIEWER_QGLVIEWER_H