qglviewer.h

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

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

 This file is part of the QGLViewer library version 2.3.10.

 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
// Qt::ButtonState was split into Qt::KeyboardModifiers and Qt::MouseButtons in Qt 4.
# define QtKeyboardModifiers Qt::KeyboardModifiers
# define QtMouseButtons Qt::MouseButtons
#else
# define QtKeyboardModifiers Qt::ButtonState
# define QtMouseButtons Qt::ButtonState
#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::WFlags 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::WFlags flags=0)
        : QGLWidget(format, parent, name, shareWidget, flags)
    { defaultConstructor(); }

    QGLViewer(QGLContext* context, QWidget* parent, const char* name=0, const QGLWidget* shareWidget=0, Qt::WFlags 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::WFlags flags=0);
    explicit QGLViewer(QGLContext *context, QWidget* parent=0, const QGLWidget* shareWidget=0, Qt::WFlags flags=0);
    explicit QGLViewer(const QGLFormat& format, QWidget* parent=0, const QGLWidget* shareWidget=0, Qt::WFlags 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:
    int shortcut(KeyboardAction action) const;
#ifndef DOXYGEN
    // QGLViewer 1.x
    int keyboardAccelerator(KeyboardAction action) const;
    Qt::Key keyFrameKey(int index) const;
    QtKeyboardModifiers playKeyFramePathStateKey() const;
    // QGLViewer 2.0 without Qt4 support
    QtKeyboardModifiers addKeyFrameStateKey() const;
    QtKeyboardModifiers playPathStateKey() const;
#endif
    Qt::Key pathKey(int index) const;
    QtKeyboardModifiers addKeyFrameKeyboardModifiers() const;
    QtKeyboardModifiers playPathKeyboardModifiers() const;

    public Q_SLOTS:
        void setShortcut(KeyboardAction action, 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(QtKeyboardModifiers modifiers);
        virtual void setAddKeyFrameKeyboardModifiers(QtKeyboardModifiers 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, QtMouseButtons buttonsBefore) const;
    void getClickButtonState(ClickAction action, int& state, bool& doubleClick, QtMouseButtons& buttonsBefore) const;

    MouseAction wheelAction(QtKeyboardModifiers modifiers) const;
    int wheelHandler(QtKeyboardModifiers 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, QtMouseButtons buttonsBefore=Qt::NoButton);
    void setMouseBindingDescription(int state, QString description, bool doubleClick=false, QtMouseButtons buttonsBefore=Qt::NoButton);
#if QT_VERSION < 0x030000
    public Q_SLOTS:
#endif
        void setWheelBinding(QtKeyboardModifiers modifiers, MouseHandler handler, MouseAction action, bool withConstraint=true);
        void setHandlerKeyboardModifiers(MouseHandler handler, QtKeyboardModifiers 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, 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_;
    QtKeyboardModifiers 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 {
        QtKeyboardModifiers modifiers;
        QtMouseButtons button;
        bool doubleClick;
        QtMouseButtons 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<QtKeyboardModifiers, 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