qglviewer.h

Go to the documentation of this file.

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

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

 This file is part of the QGLViewer library version 2.4.0.

 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"

#if QT_VERSION >= 0x040000
# include <QMap>
# include <QClipboard>
#else
# include <qmap.h>
# include <qclipboard.h>
#endif

class QTabWidget;

namespace qglviewer {
        class MouseGrabber;
}

#if QT_VERSION < 0x040000
# define Qt::KeyboardModifiers Qt::ButtonState
# define Qt::MouseButtons Qt::ButtonState
# define Qt::WindowFlags Qt::WFlags
#endif

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).
#if QT_VERSION < 0x040000 || defined 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)
# if QT_VERSION >= 0x030200
                : QGLWidget(context, parent, name, shareWidget, flags) {
# else
                // MOC_SKIP_BEGIN
                : QGLWidget(parent, name, shareWidget, flags) {
                        Q_UNUSED(context);
                        // MOC_SKIP_END
# endif
                        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); if (updateGLOK_) updateGL(); };
                void setGridIsDrawn(bool draw=true) { gridIsDrawn_ = draw; Q_EMIT gridIsDrawnChanged(draw); if (updateGLOK_) updateGL(); };
                void setFPSIsDisplayed(bool display=true) { FPSIsDisplayed_ = display; Q_EMIT FPSIsDisplayedChanged(display); if (updateGLOK_) updateGL(); };
                void setTextIsEnabled(bool enable=true) { textIsEnabled_ = enable; Q_EMIT textIsEnabledChanged(enable); if (updateGLOK_) updateGL(); };
                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:
        float sceneRadius() const { return camera()->sceneRadius(); }
        qglviewer::Vec sceneCenter() const { return camera()->sceneCenter(); }

        public Q_SLOTS:
                virtual void setSceneRadius(float 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(); if (updateGLOK_) updateGL(); }


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:
        float aspectRatio() const { return static_cast<float>(width())/static_cast<float>(height()); };
        float 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 cameraIsInRevolveMode() const;


public:
        static void drawArrow(float length=1.0f, float radius=-1.0f, int nbSubdivisions=12);
        static void drawArrow(const qglviewer::Vec& from, const qglviewer::Vec& to, float radius=-1.0f, int nbSubdivisions=12);
        static void drawAxis(float length=1.0f);
        static void drawGrid(float size=1.0f, 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.1f);

protected:
        virtual void drawLight(GLenum light, float scale = 1.0f) 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:
#if QT_VERSION < 0x030000
        virtual QImage grabFrameBuffer(bool withAlpha=false);
#endif

        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 double 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 : double 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)
#if QT_VERSION >= 0x040000
              f.setPointSizeF(f.pointSizeF() * tileRegion_->textScale);
#else
              f.setPointSizeFloat(f.pointSizeFloat() * tileRegion_->textScale);
#endif
            else
              f.setPixelSize(f.pixelSize() * tileRegion_->textScale);
            return f;
          }
        }


public:
        GLuint bufferTextureId() const;
        float bufferTextureMaxU() const { return bufferTextureMaxU_; };
        float 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 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); };


protected:
        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 };
public:
    unsigned int shortcut(KeyboardAction action) const;
#ifndef DOXYGEN
        // QGLViewer 1.x
        int keyboardAccelerator(KeyboardAction action) const;
        Qt::Key keyFrameKey(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(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, int key);
#endif
                void setKeyDescription(int key, QString description);

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


protected:
        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 };

#ifndef DOXYGEN
        // So that it can be used in ManipulatedFrame and ManipulatedCameraFrame.
public:
#endif

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

#ifdef DOXYGEN
public:
#endif

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

    MouseAction wheelAction(Qt::KeyboardModifiers modifiers) const;
    int wheelHandler(Qt::KeyboardModifiers modifiers) const;
        int wheelButtonState(MouseHandler handler, MouseAction action, bool withConstraint=true) const;

public Q_SLOTS:
    void setMouseBinding(int state, MouseHandler handler, MouseAction action, bool withConstraint=true);
#if QT_VERSION < 0x030000
    // Two slots cannot have the same name or two default parameters with Qt 2.3.
public:
#endif
    void setMouseBinding(int state, ClickAction action, bool doubleClick=false, Qt::MouseButtons buttonsBefore=Qt::NoButton);
#if QT_VERSION < 0x030000
public Q_SLOTS:
#endif
    void setMouseBindingDescription(int state, QString description, bool doubleClick=false, Qt::MouseButtons buttonsBefore=Qt::NoButton);
    void setWheelBinding(Qt::KeyboardModifiers modifiers, MouseHandler handler, MouseAction action, bool withConstraint=true);
    void setHandlerKeyboardModifiers(MouseHandler handler, Qt::KeyboardModifiers modifiers);
#ifndef DOXYGEN
    void setHandlerStateKey(MouseHandler handler, int buttonState);
    void setMouseStateKey(MouseHandler handler, 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:
#if QT_VERSION >= 0x040000
        static const QList<QGLViewer*>& QGLViewerPool() { return QGLViewer::QGLViewerPool_; };
#else
        static const QPtrList<QGLViewer>& QGLViewerPool() { return QGLViewer::QGLViewerPool_; };
#endif


#if QT_VERSION >= 0x040000
        static int QGLViewerIndex(const QGLViewer* const viewer) { return QGLViewer::QGLViewerPool_.indexOf(const_cast<QGLViewer*>(viewer)); };
#else
        static int QGLViewerIndex(const QGLViewer* const viewer) { return QGLViewer::QGLViewerPool_.findRef(viewer); };
#endif


#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_;
        float previousCameraZClippingCoefficient_;
        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_;
        float 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<int, QString> keyDescription_;

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

        // B u f f e r   T e x t u r e
        GLuint bufferTextureId_;
        float 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;
        };

        // C l i c k   a c t i o n s
        struct ClickActionPrivate {
        Qt::KeyboardModifiers modifiers;
        Qt::MouseButtons button;
                bool doubleClick;
        Qt::MouseButtons buttonsBefore; // only defined when doubleClick is true

                // This sort order in used in mouseString() to displays sorted mouse bindings
                bool operator<(const ClickActionPrivate& cap) const
                {
                        if (buttonsBefore != cap.buttonsBefore)
                                return buttonsBefore < cap.buttonsBefore;
                        else
                                if (modifiers != cap.modifiers)
                                        return modifiers < cap.modifiers;
                                else
                                        if (button != cap.button)
                                                return button < cap.button;
                                        else
                                                return !doubleClick && cap.doubleClick;
                }
        };
#endif
    static QString formatClickActionPrivate(ClickActionPrivate cap);

        QMap<ClickActionPrivate, QString> mouseDescription_;

        void setDefaultMouseBindings();
        void performClickAction(ClickAction ca, const QMouseEvent* const e);
        QMap<int, MouseActionPrivate> mouseBinding_;
    QMap<Qt::KeyboardModifiers, MouseActionPrivate> wheelBinding_;
        QMap<ClickActionPrivate, ClickAction> clickBinding_;

        // 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
#if QT_VERSION >= 0x040000
        static QList<QGLViewer*> QGLViewerPool_;
#else
        static QPtrList<QGLViewer> QGLViewerPool_;
#endif

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

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

        // I n t e r n a l   d e b u g
        bool updateGLOK_;
};

#endif // QGLVIEWER_QGLVIEWER_H