qglviewer.cpp

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

 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.

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

#include "domUtils.h"
#include "qglviewer.h"
#include "camera.h"
#include "keyFrameInterpolator.h"

#if QT_VERSION >= 0x040000
# include <QtAlgorithms>
# include <QTextEdit>
# include <QApplication>
# include <QFileInfo>
# include <QDateTime>
# include <QMessageBox>
# include <QPushButton>
# include <QTabWidget>
# include <QTextStream>
# include <QMouseEvent>
# include <QTimer>
# include <QImage>
# include <QDir>
# include <QUrl>
#else
# include <qapplication.h>
# include <qfileinfo.h>
# include <qdatetime.h>
# include <qmessagebox.h>
# include <qpushbutton.h>
# include <qtabwidget.h>
# include <qtextstream.h>
# include <qtimer.h>
# include <qimage.h>
# include <qtextedit.h>
# include <qkeysequence.h>
# include <qdir.h>
  // Patch for enums names change
# define KeyboardModifierMask KeyButtonMask
  // Patch for QMap API change
# define value data
#endif

using namespace std;
using namespace qglviewer;

// Static private variable
#if QT_VERSION >= 0x040000
QList<QGLViewer*> QGLViewer::QGLViewerPool_;
#else
QPtrList<QGLViewer> QGLViewer::QGLViewerPool_;
#endif


void QGLViewer::defaultConstructor()
{
    //      - - -  W A R N I N G  - - -
    // This method should not call initializeGL(). Otherwise, as we are in the
    // base class constructor, the user-defined init() would never be called.
    // The different QGLViewer::setXXX are hence protected, so that updateGL is not called.
    // The different constructor code should then be EMPTY.
    updateGLOK_ = false;

    // Test OpenGL context
    // if (glGetString(GL_VERSION) == 0)
    // qWarning("Unable to get OpenGL version, context may not be available - Check your configuration");

#if QT_VERSION >= 0x040000
    int poolIndex = QGLViewer::QGLViewerPool_.indexOf(NULL);
    setFocusPolicy(Qt::StrongFocus);
#else
    int poolIndex = QGLViewer::QGLViewerPool_.findRef(NULL);
    setFocusPolicy(QWidget::StrongFocus);
#endif

        if (poolIndex >= 0)
          QGLViewer::QGLViewerPool_.replace(poolIndex, this);
        else
      QGLViewer::QGLViewerPool_.append(this);

    camera_ = new Camera();
    setCamera(camera());

    setDefaultShortcuts();
    setDefaultMouseBindings();

    setSnapshotFileName(tr("snapshot", "Default snapshot file name"));
    initializeSnapshotFormats();
    setSnapshotCounter(0);
    setSnapshotQuality(95);

    fpsTime_.start();
    fpsCounter_     = 0;
    f_p_s_          = 0.0;
    fpsString_      = tr("%1Hz", "Frames per seconds, in Hertz").arg("?");
    visualHint_     = 0;
    previousPathId_ = 0;
    // prevPos_ is not initialized since pos() is not meaningful here. It will be set by setFullScreen().

    // #CONNECTION# default values in initFromDOMElement()
    manipulatedFrame_ = NULL;
    manipulatedFrameIsACamera_ = false;
    mouseGrabberIsAManipulatedFrame_ = false;
    mouseGrabberIsAManipulatedCameraFrame_ = false;
    displayMessage_ = false;
    connect(&messageTimer_, SIGNAL(timeout()), SLOT(hideMessage()));
#if QT_VERSION >= 0x040000
    messageTimer_.setSingleShot(true);
#endif
    helpWidget_ = NULL;
    setMouseGrabber(NULL);

    setSceneRadius(1.0);
    showEntireScene();
    setStateFileName(".qglviewer.xml");

    // #CONNECTION# default values in initFromDOMElement()
    setAxisIsDrawn(false);
    setGridIsDrawn(false);
    setFPSIsDisplayed(false);
    setCameraIsEdited(false);
    setTextIsEnabled(true);
    setStereoDisplay(false);
    setFullScreen(false);

    animationTimerId_ = 0;
    stopAnimation();
    setAnimationPeriod(40); // 25Hz

    selectBuffer_ = NULL;
    setSelectBufferSize(4*1000);
    setSelectRegionWidth(3);
    setSelectRegionHeight(3);
    setSelectedName(-1);

    bufferTextureId_ = 0;
    bufferTextureMaxU_ = 0.0;
    bufferTextureMaxV_ = 0.0;
    bufferTextureWidth_ = 0;
    bufferTextureHeight_ = 0;
    previousBufferTextureFormat_ = 0;
    previousBufferTextureInternalFormat_ = 0;

#if QT_VERSION >= 0x040000
    setAttribute(Qt::WA_NoSystemBackground);
#endif

    tileRegion_ = NULL;
}

#if QT_VERSION >= 0x040000

QGLViewer::QGLViewer(QWidget* parent, const QGLWidget* shareWidget, Qt::WFlags flags)
: QGLWidget(parent, shareWidget, flags)
{ defaultConstructor(); }

QGLViewer::QGLViewer(QGLContext *context, QWidget* parent, const QGLWidget* shareWidget, Qt::WFlags flags)
: QGLWidget(context, parent, shareWidget, flags)
{ defaultConstructor(); }

QGLViewer::QGLViewer(const QGLFormat& format, QWidget* parent, const QGLWidget* shareWidget, Qt::WFlags flags)
: QGLWidget(format, parent, shareWidget, flags)
{ defaultConstructor(); }
#endif

QGLViewer::~QGLViewer()
{
    // See closeEvent comment. Destructor is called (and not closeEvent) only when the widget is embedded.
    // Hence we saveToFile here. It is however a bad idea if virtual domElement() has been overloaded !
    // if (parent())
    // saveStateToFileForAllViewers();

#if QT_VERSION >= 0x040000
    QGLViewer::QGLViewerPool_.replace(QGLViewer::QGLViewerPool_.indexOf(this), NULL);
#else
    QGLViewer::QGLViewerPool_.replace(QGLViewer::QGLViewerPool_.findRef(this), NULL);
#endif

    delete camera();
    delete[] selectBuffer_;
    if (helpWidget())
    {
        // Needed for Qt 4 which has no main widget.
        helpWidget()->close();
        delete helpWidget_;
    }
}


static QString QGLViewerVersionString()
{
    return QString::number((QGLVIEWER_VERSION & 0xff0000) >> 16) + "." +
        QString::number((QGLVIEWER_VERSION & 0x00ff00) >> 8) + "." +
        QString::number(QGLVIEWER_VERSION & 0x0000ff);
}

static int convertToKeyboardModifiers(int state)
{
#if QT_VERSION < 0x040000
    // Qt 2 & 3 have different values for ButtonState and Modifiers.
    // Converts CTRL,SHIFT... to ControlButton, ShiftButton...
    if (state & Qt::MODIFIER_MASK)
    {
        if (state & Qt::CTRL)  { state &= ~Qt::CTRL;    state |= Qt::ControlButton; }
        if (state & Qt::SHIFT) { state &= ~Qt::SHIFT;   state |= Qt::ShiftButton; }
        if (state & Qt::ALT)   { state &= ~Qt::ALT;     state |= Qt::AltButton; }
# if QT_VERSION >= 0x030100
        if (state & Qt::META)  { state &= ~Qt::META;    state |= Qt::MetaButton; }
# endif
    }
#endif
    return state;
}

static QtKeyboardModifiers convertKeyboardModifiers(QtKeyboardModifiers modifiers)
{
#if QT_VERSION < 0x040000
    return QtKeyboardModifiers(convertToKeyboardModifiers(modifiers));
#else
    return modifiers;
#endif
}

static int convertToShortModifier(int state)
{
    // Converts ControlButton, ShiftButton... to CTRL,SHIFT...
    // convertToKeyboardModifiers does the opposite
#if QT_VERSION < 0x040000
    if (state & Qt::KeyButtonMask)
    {
        if (state & Qt::ControlButton) { state &= ~Qt::ControlButton;   state |= Qt::CTRL; }
        if (state & Qt::ShiftButton)   { state &= ~Qt::ShiftButton; state |= Qt::SHIFT; }
        if (state & Qt::AltButton)     { state &= ~Qt::AltButton;       state |= Qt::ALT; }
# if QT_VERSION >= 0x030100
        if (state & Qt::MetaButton)    { state &= ~Qt::MetaButton;  state |= Qt::META; }
# endif
    }
#endif
    return state;
}

void QGLViewer::initializeGL()
{
    if (updateGLOK_)
        qWarning("Internal debug: initializeGL() is called in QGLViewer constructor.");

    glEnable(GL_LIGHT0);
    glEnable(GL_LIGHTING);
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_COLOR_MATERIAL);

    // Default colors
    setForegroundColor(QColor(180, 180, 180));
    setBackgroundColor(QColor(51, 51, 51));

    // Clear the buffer where we're going to draw
    if (format().stereo())
    {
        glDrawBuffer(GL_BACK_RIGHT);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glDrawBuffer(GL_BACK_LEFT);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    }
    else
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    // Calls user defined method. Default emits a signal.
    init();

    // Give time to glInit to finish and then call setFullScreen().
    if (isFullScreen())
        QTimer::singleShot( 100, this, SLOT(delayedFullScreen()) );

    updateGLOK_ = true;
}

void QGLViewer::paintGL()
{
    updateGLOK_ = false;
    if (displaysInStereo())
    {
        for (int view=1; view>=0; --view)
        {
            // Clears screen, set model view matrix with shifted matrix for ith buffer
            preDrawStereo(view);
            // Used defined method. Default is empty
            if (camera()->frame()->isManipulated())
                fastDraw();
            else
                draw();
            postDraw();
        }
    }
    else
    {
        // Clears screen, set model view matrix...
        preDraw();
        // Used defined method. Default calls draw()
        if (camera()->frame()->isManipulated())
            fastDraw();
        else
            draw();
        // Add visual hints: axis, camera, grid...
        postDraw();
    }
    updateGLOK_ = true;
    Q_EMIT drawFinished(true);
}

void QGLViewer::preDraw()
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    // GL_PROJECTION matrix
    camera()->loadProjectionMatrix();
    // GL_MODELVIEW matrix
    camera()->loadModelViewMatrix();

    Q_EMIT drawNeeded();
}

void QGLViewer::postDraw()
{
    // Reset model view matrix to world coordinates origin
    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    camera()->loadModelViewMatrix();
    // TODO restore model loadProjectionMatrixStereo

    // Save OpenGL state
    glPushAttrib(GL_ALL_ATTRIB_BITS);

    // Set neutral GL state
    glDisable(GL_TEXTURE_1D);
    glDisable(GL_TEXTURE_2D);
#ifdef GL_TEXTURE_3D  // OpenGL 1.2 Only...
    glDisable(GL_TEXTURE_3D);
#endif

    glDisable(GL_TEXTURE_GEN_Q);
    glDisable(GL_TEXTURE_GEN_R);
    glDisable(GL_TEXTURE_GEN_S);
    glDisable(GL_TEXTURE_GEN_T);

#ifdef GL_RESCALE_NORMAL  // OpenGL 1.2 Only...
    glEnable(GL_RESCALE_NORMAL);
#endif

    glDisable(GL_COLOR_MATERIAL);
    qglColor(foregroundColor());

    if (cameraIsEdited())
        camera()->drawAllPaths();

    // Revolve Around Point, line when camera rolls, zoom region
    drawVisualHints();

    if (gridIsDrawn()) { glLineWidth(1.0); drawGrid(camera()->sceneRadius()); }
    if (axisIsDrawn()) { glLineWidth(2.0); drawAxis(camera()->sceneRadius()); }

    // FPS computation
    const unsigned int maxCounter = 20;
    if (++fpsCounter_ == maxCounter)
    {
        f_p_s_ = 1000.0 * maxCounter / fpsTime_.restart();
        fpsString_ = tr("%1Hz", "Frames per seconds, in Hertz").arg(f_p_s_, 0, 'f', ((f_p_s_ < 10.0)?1:0));
        fpsCounter_ = 0;
    }

    // Restore foregroundColor
    float color[4];
    color[0] = foregroundColor().red()   / 255.0;
    color[1] = foregroundColor().green() / 255.0;
    color[2] = foregroundColor().blue()  / 255.0;
    color[3] = 1.0;
    glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color);
    glDisable(GL_LIGHTING);
    glDisable(GL_DEPTH_TEST);

    if (FPSIsDisplayed()) displayFPS();
    if (displayMessage_) drawText(10, height()-10,  message_);

    // Restore GL state
    glPopAttrib();
    glPopMatrix();
}

void QGLViewer::preDrawStereo(bool leftBuffer)
{
    // Set buffer to draw in
    // Seems that SGI and Crystal Eyes are not synchronized correctly !
    // That's why we don't draw in the appropriate buffer...
    if (!leftBuffer)
        glDrawBuffer(GL_BACK_LEFT);
    else
        glDrawBuffer(GL_BACK_RIGHT);

    // Clear the buffer where we're going to draw
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    // GL_PROJECTION matrix
    camera()->loadProjectionMatrixStereo(leftBuffer);
    // GL_MODELVIEW matrix
    camera()->loadModelViewMatrixStereo(leftBuffer);

    Q_EMIT drawNeeded();
}

void QGLViewer::fastDraw()
{
    draw();
}

void QGLViewer::setCameraIsEdited(bool edit)
{
    cameraIsEdited_ = edit;
    if (edit)
    {
        previousCameraZClippingCoefficient_ = camera()->zClippingCoefficient();
        // #CONNECTION# 5.0 also used in domElement() and in initFromDOMElement().
        camera()->setZClippingCoefficient(5.0);
    }
    else
        camera()->setZClippingCoefficient(previousCameraZClippingCoefficient_);

    Q_EMIT cameraIsEditedChanged(edit);

    if (updateGLOK_)
        updateGL();
}

// Key bindings. 0 means not defined
void QGLViewer::setDefaultShortcuts()
{
    // D e f a u l t   a c c e l e r a t o r s
    setShortcut(DRAW_AXIS,  Qt::Key_A);
    setShortcut(DRAW_GRID,  Qt::Key_G);
    setShortcut(DISPLAY_FPS,    Qt::Key_F);
    setShortcut(ENABLE_TEXT,    Qt::SHIFT+Qt::Key_Question);
    setShortcut(EXIT_VIEWER,    Qt::Key_Escape);
    setShortcut(SAVE_SCREENSHOT,    Qt::CTRL+Qt::Key_S);
    setShortcut(CAMERA_MODE,    Qt::Key_Space);
    setShortcut(FULL_SCREEN,    Qt::ALT+Qt::Key_Return);
    setShortcut(STEREO,     Qt::Key_S);
    setShortcut(ANIMATION,  Qt::Key_Return);
    setShortcut(HELP,       Qt::Key_H);
    setShortcut(EDIT_CAMERA,    Qt::Key_C);
    setShortcut(MOVE_CAMERA_LEFT,   Qt::Key_Left);
    setShortcut(MOVE_CAMERA_RIGHT,Qt::Key_Right);
    setShortcut(MOVE_CAMERA_UP, Qt::Key_Up);
    setShortcut(MOVE_CAMERA_DOWN,   Qt::Key_Down);
    setShortcut(INCREASE_FLYSPEED,Qt::Key_Plus);
    setShortcut(DECREASE_FLYSPEED,Qt::Key_Minus);
    setShortcut(SNAPSHOT_TO_CLIPBOARD,Qt::CTRL+Qt::Key_C);

    keyboardActionDescription_[DISPLAY_FPS] = tr("Toggles the display of the FPS", "DISPLAY_FPS action description");
    keyboardActionDescription_[SAVE_SCREENSHOT] = tr("Saves a screenshot", "SAVE_SCREENSHOT action description");
    keyboardActionDescription_[FULL_SCREEN] = tr("Toggles full screen display", "FULL_SCREEN action description");
    keyboardActionDescription_[DRAW_AXIS] = tr("Toggles the display of the world axis", "DRAW_AXIS action description");
    keyboardActionDescription_[DRAW_GRID] = tr("Toggles the display of the XY grid", "DRAW_GRID action description");
    keyboardActionDescription_[CAMERA_MODE] = tr("Changes camera mode (revolve or fly)", "CAMERA_MODE action description");
    keyboardActionDescription_[STEREO] = tr("Toggles stereo display", "STEREO action description");
    keyboardActionDescription_[HELP] = tr("Opens this help window", "HELP action description");
    keyboardActionDescription_[ANIMATION] = tr("Starts/stops the animation", "ANIMATION action description");
    keyboardActionDescription_[EDIT_CAMERA] = tr("Toggles camera paths display", "EDIT_CAMERA action description"); // TODO change
    keyboardActionDescription_[ENABLE_TEXT] = tr("Toggles the display of the text", "ENABLE_TEXT action description");
    keyboardActionDescription_[EXIT_VIEWER] = tr("Exits program", "EXIT_VIEWER action description");
    keyboardActionDescription_[MOVE_CAMERA_LEFT] = tr("Moves camera left", "MOVE_CAMERA_LEFT action description");
    keyboardActionDescription_[MOVE_CAMERA_RIGHT] = tr("Moves camera right", "MOVE_CAMERA_RIGHT action description");
    keyboardActionDescription_[MOVE_CAMERA_UP] = tr("Moves camera up", "MOVE_CAMERA_UP action description");
    keyboardActionDescription_[MOVE_CAMERA_DOWN] = tr("Moves camera down", "MOVE_CAMERA_DOWN action description");
    keyboardActionDescription_[INCREASE_FLYSPEED] = tr("Increases fly speed", "INCREASE_FLYSPEED action description");
    keyboardActionDescription_[DECREASE_FLYSPEED] = tr("Decreases fly speed", "DECREASE_FLYSPEED action description");
    keyboardActionDescription_[SNAPSHOT_TO_CLIPBOARD] = tr("Copies a snapshot to clipboard", "SNAPSHOT_TO_CLIPBOARD action description");

    // K e y f r a m e s   s h o r t c u t   k e y s
    setPathKey(Qt::Key_F1,   1);
    setPathKey(Qt::Key_F2,   2);
    setPathKey(Qt::Key_F3,   3);
    setPathKey(Qt::Key_F4,   4);
    setPathKey(Qt::Key_F5,   5);
    setPathKey(Qt::Key_F6,   6);
    setPathKey(Qt::Key_F7,   7);
    setPathKey(Qt::Key_F8,   8);
    setPathKey(Qt::Key_F9,   9);
    setPathKey(Qt::Key_F10, 10);
    setPathKey(Qt::Key_F11, 11);
    setPathKey(Qt::Key_F12, 12);

#if QT_VERSION >= 0x040000
    setAddKeyFrameKeyboardModifiers(Qt::AltModifier);
    setPlayPathKeyboardModifiers(Qt::NoModifier);
#else
    setAddKeyFrameKeyboardModifiers(Qt::AltButton);
    setPlayPathKeyboardModifiers(Qt::NoButton);
#endif
}

// M o u s e   b e h a v i o r
void QGLViewer::setDefaultMouseBindings()
{
#if QT_VERSION >= 0x040000
    const QtKeyboardModifiers cameraKeyboardModifiers = Qt::NoModifier;
    const QtKeyboardModifiers frameKeyboardModifiers = Qt::ControlModifier;
#else
    const QtKeyboardModifiers cameraKeyboardModifiers = Qt::NoButton;
    const QtKeyboardModifiers frameKeyboardModifiers = Qt::ControlButton;
#endif
    //#CONNECTION# toggleCameraMode()
    for (int handler=0; handler<2; ++handler)
    {
        MouseHandler mh = (MouseHandler)(handler);
        QtKeyboardModifiers modifiers = (mh == FRAME) ? frameKeyboardModifiers : cameraKeyboardModifiers;
        
        setMouseBinding(modifiers | Qt::LeftButton,  mh, ROTATE);
        setMouseBinding(modifiers | Qt::MidButton,   mh, ZOOM);
        setMouseBinding(modifiers | Qt::RightButton, mh, TRANSLATE);

        setMouseBinding(modifiers | Qt::LeftButton  | Qt::MidButton,  mh, SCREEN_ROTATE);
        // 2.2.4 setMouseBinding(modifiers | Qt::RightButton | Qt::MidButton,  mh, SCREEN_TRANSLATE);

        setWheelBinding(modifiers, mh, ZOOM);
    }

#if QT_VERSION >= 0x040000
    // Z o o m   o n   r e g i o n
    setMouseBinding(Qt::ShiftModifier | Qt::MidButton, CAMERA, ZOOM_ON_REGION);
    // S e l e c t
    setMouseBinding(Qt::ShiftModifier | Qt::LeftButton, SELECT);
#else
    setMouseBinding(Qt::ShiftButton | Qt::MidButton, CAMERA, ZOOM_ON_REGION);
    setMouseBinding(Qt::ShiftButton | Qt::LeftButton, SELECT);
#endif

    // D o u b l e   c l i c k
    setMouseBinding(Qt::LeftButton,  ALIGN_CAMERA,      true);
    setMouseBinding(Qt::MidButton,   SHOW_ENTIRE_SCENE, true);
    setMouseBinding(Qt::RightButton, CENTER_SCENE,      true);

    setMouseBinding(frameKeyboardModifiers | Qt::LeftButton,  ALIGN_FRAME,  true);
    setMouseBinding(frameKeyboardModifiers | Qt::RightButton, CENTER_FRAME, true);

    // S p e c i f i c   d o u b l e   c l i c k s
    setMouseBinding(Qt::LeftButton,  RAP_FROM_PIXEL, true, Qt::RightButton);
    setMouseBinding(Qt::RightButton, RAP_IS_CENTER,  true, Qt::LeftButton);
    setMouseBinding(Qt::LeftButton,  ZOOM_ON_PIXEL,  true, Qt::MidButton);
    setMouseBinding(Qt::RightButton, ZOOM_TO_FIT,    true, Qt::MidButton);

#ifdef Q_OS_MAC
    // Specific Mac bindings. Double finger emulates a wheelEvent which zooms.
    // Make Option + left emulate the right button. Other bindings should be changed accordingly.
    // Done at the end to override previous settings.
# if QT_VERSION >= 0x040000
    const QtKeyboardModifiers macKeyboardModifiers = Qt::AltModifier;
# else
    const QtKeyboardModifiers macKeyboardModifiers = Qt::AltButton;
# endif

    setMouseBinding(macKeyboardModifiers | Qt::LeftButton, CAMERA, TRANSLATE);
    setMouseBinding(macKeyboardModifiers | Qt::LeftButton, CENTER_SCENE, true);
    setMouseBinding(frameKeyboardModifiers | macKeyboardModifiers | Qt::LeftButton, CENTER_FRAME, true);
    setMouseBinding(frameKeyboardModifiers | macKeyboardModifiers | Qt::LeftButton, FRAME, TRANSLATE);
    
    // S p e c i f i c   d o u b l e   c l i c k s
    // A single tap is actually seen as a left followed by a right button click.
    setMouseBinding(Qt::MetaModifier | Qt::RightButton,  RAP_FROM_PIXEL, true, Qt::LeftButton);
    setMouseBinding(Qt::ShiftModifier | Qt::MetaModifier | Qt::RightButton, RAP_IS_CENTER,  true, Qt::LeftButton);
    // A tap with two fingers is actually considered a rightButton.
    setMouseBinding(Qt::MetaModifier | Qt::RightButton,  ZOOM_ON_PIXEL, false);
    setMouseBinding(Qt::ShiftModifier | Qt::MetaModifier | Qt::RightButton, ZOOM_TO_FIT, false);
#endif
}

void QGLViewer::setCamera(Camera* const camera)
{
    if (!camera)
        return;

    camera->setSceneRadius(sceneRadius());
    camera->setSceneCenter(sceneCenter());
    camera->setScreenWidthAndHeight(width(),height());

    // Disconnect current camera to this viewer.
    disconnect(this->camera()->frame(), SIGNAL(manipulated()), this, SLOT(updateGL()));
    disconnect(this->camera()->frame(), SIGNAL(spun()), this, SLOT(updateGL()));

    // Connect camera frame to this viewer.
    connect(camera->frame(), SIGNAL(manipulated()), SLOT(updateGL()));
    connect(camera->frame(), SIGNAL(spun()), SLOT(updateGL()));

    connectAllCameraKFIInterpolatedSignals(false);
    camera_ = camera;
    connectAllCameraKFIInterpolatedSignals();

    previousCameraZClippingCoefficient_ = this->camera()->zClippingCoefficient();
}

void QGLViewer::connectAllCameraKFIInterpolatedSignals(bool connection)
{
    for (QMap<int, KeyFrameInterpolator*>::ConstIterator it = camera()->kfi_.begin(), end=camera()->kfi_.end(); it != end; ++it)
    {
        if (connection)
            connect(camera()->keyFrameInterpolator(it.key()), SIGNAL(interpolated()), SLOT(updateGL()));
        else
            disconnect(camera()->keyFrameInterpolator(it.key()), SIGNAL(interpolated()), this, SLOT(updateGL()));
    }

    if (connection)
        connect(camera()->interpolationKfi_, SIGNAL(interpolated()), SLOT(updateGL()));
    else
        disconnect(camera()->interpolationKfi_, SIGNAL(interpolated()), this, SLOT(updateGL()));
}

void QGLViewer::drawLight(GLenum light, float scale) const
{
    static GLUquadric* quadric = gluNewQuadric();

    const float length = sceneRadius() / 5.0 * scale;

    GLboolean lightIsOn;
    glGetBooleanv(light, &lightIsOn);

    if (lightIsOn)
    {
        // All light values are given in eye coordinates
        glPushMatrix();
        glLoadIdentity();

        float color[4];
        glGetLightfv(light, GL_DIFFUSE, color);
        glColor4fv(color);

        float pos[4];
        glGetLightfv(light, GL_POSITION, pos);

        if (pos[3] != 0.0)
        {
            glTranslatef(pos[0]/pos[3], pos[1]/pos[3], pos[2]/pos[3]);

            GLfloat cutOff;
            glGetLightfv(light, GL_SPOT_CUTOFF, &cutOff);
            if (cutOff != 180.0)
            {
                GLfloat dir[4];
                glGetLightfv(light, GL_SPOT_DIRECTION, dir);
                glMultMatrixd(Quaternion(Vec(0,0,1), Vec(dir)).matrix());
                QGLViewer::drawArrow(length);
                gluCylinder(quadric, 0.0, 0.7 * length * sin(cutOff * M_PI / 180.0), 0.7 * length * cos(cutOff * M_PI / 180.0), 12, 1);
            }
            else
                gluSphere(quadric, 0.2*length, 10, 10);
        }
        else
        {
            // Directional light.
            Vec dir(pos[0], pos[1], pos[2]);
            dir.normalize();
            Frame fr=Frame(camera()->cameraCoordinatesOf(4.0 * length * camera()->frame()->inverseTransformOf(dir)),
                Quaternion(Vec(0,0,-1), dir));
            glMultMatrixd(fr.matrix());
            drawArrow(length);
        }

        glPopMatrix();
    }
}


void QGLViewer::drawText(int x, int y, const QString& text, const QFont& fnt)
{
    if (!textIsEnabled())
        return;

#if QT_VERSION < QGLVIEWER_QT_VERSION_WITHOUT_GLUT
    const GLfloat font_scale = 119.05f - 33.33f; // see glutStrokeCharacter man page

    startScreenCoordinatesSystem();

    // Anti-aliased characters
    glPushAttrib(GL_ALL_ATTRIB_BITS);
    glDisable(GL_LIGHTING);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glEnable(GL_BLEND);
    glDisable(GL_DEPTH_TEST);
    glEnable(GL_LINE_SMOOTH);
    glLineWidth(1.0);

    glTranslatef((GLfloat)x, (GLfloat)y, 0.0);
    const GLfloat scale = ((fnt.pixelSize()>0)?fnt.pixelSize():fnt.pointSize()) / font_scale;
    glScalef(scale, -scale, scale);

    for (uint i=0; i<text.length(); ++i)
        glutStrokeCharacter(GLUT_STROKE_ROMAN, text.at(i));

    glPopAttrib();

    stopScreenCoordinatesSystem();
#else

# if QT_VERSION < 0x030300 && defined Q_OS_UNIX
    // Fix bug with anti-aliased fonts on nVidia driver
    QFont newFont(fnt);
    newFont.setFamily("fixed");
    newFont.setRawMode(true);
    newFont.setPixelSize(10);
    newFont.setFixedPitch(true);
#   if QT_VERSION >= 0x030200
    newFont.setStyleStrategy(QFont::OpenGLCompatible);
#   endif
    newFont.setStyleHint(QFont::AnyStyle, QFont::PreferBitmap);
    renderText(x, y, text, newFont);
# else
    if (tileRegion_ != NULL) {
      renderText((x-tileRegion_->xMin) * width() / (tileRegion_->xMax - tileRegion_->xMin), 
                     (y-tileRegion_->yMin) * height() / (tileRegion_->yMax - tileRegion_->yMin), text, scaledFont(fnt));
    } else
      renderText(x, y, text, fnt);
# endif

#endif
}

/* Similar to drawText(), but the text is handled as a classical 3D object of the scene.

Although useful, this method is deprecated with recent Qt versions. Indeed, Qt renders text as
pixmaps that cannot be oriented. However, when GLUT is used instead of Qt (when your Qt version is
lower than 3.1, see drawText() documentation) orientated characters are possible and this method will work.

\p pos and \p normal respectively represent the 3D coordinate of the text and the normal to the text
plane. They are expressed with respect to the \e current \c GL_MODELVIEW matrix.

If you want your text to always face the camera (normal parallel to camera()->viewDirection), use
QGLWidget::renderText(x,y,z).

See the <a href="../examples/draw3DText.html">draw3DText example</a> for an illustration. */
/*
void QGLViewer::draw3DText(const Vec& pos, const Vec& normal, const QString& text, GLfloat height)
{
#if QT_VERSION < QGLVIEWER_QT_VERSION_WITHOUT_GLUT
if (!textIsEnabled())
return;

glMatrixMode(GL_MODELVIEW) ;
glPushMatrix() ;

const GLfloat font_scale = (119.05f - 33.33f) / 8; // see glutStrokeCharacter man page
// const GLfloat font_scale = (119.05f - 33.33f) * 15.0f; // see glutStrokeCharacter man page

static GLfloat lineWidth;
glGetFloatv(GL_LINE_WIDTH, &lineWidth);

glTranslatef(pos.x, pos.y, pos.z);
glMultMatrixd(Quaternion(Vec(0.0, 0.0, 1.0), normal).matrix());

glLineWidth(2.0);

glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
glEnable(GL_LINE_SMOOTH);

const GLfloat scale = height / font_scale;
glScalef(scale, scale, scale);

for (uint i=0; i<text.length(); ++i)
glutStrokeCharacter(GLUT_STROKE_ROMAN, text.at(i));

glLineWidth(lineWidth);

glMatrixMode(GL_MODELVIEW);
glPopMatrix() ;
#else
static bool displayed = false;

if (!displayed)
{
qWarning("draw3DText is not supported with Qt >= 3.1.");
qWarning("Use QGLWidget::renderText() instead,");
qWarning("or use the glut glutStrokeCharacter() method.");
displayed = true;
}

Q_UNUSED(pos)
Q_UNUSED(normal)
Q_UNUSED(text)
Q_UNUSED(height)
#endif
}
*/

void QGLViewer::displayMessage(const QString& message, int delay)
{
    message_ = message;
    displayMessage_ = true;
#if QT_VERSION >= 0x040000
    // Was set to single shot in defaultConstructor.
    messageTimer_.start(delay);
#else
    if (messageTimer_.isActive())
        messageTimer_.changeInterval(delay);
    else
        messageTimer_.start(delay, true);
#endif
    if (textIsEnabled() && updateGLOK_)
        updateGL();
}

void QGLViewer::hideMessage()
{
    displayMessage_ = false;
    if (textIsEnabled())
        updateGL();
}


void QGLViewer::displayFPS()
{
    drawText(10, int(1.5*((QApplication::font().pixelSize()>0)?QApplication::font().pixelSize():QApplication::font().pointSize())), fpsString_);
}

void QGLViewer::startScreenCoordinatesSystem(bool upward) const
{
    glMatrixMode(GL_PROJECTION);
    glPushMatrix();
    glLoadIdentity();
    if (tileRegion_ != NULL)
      if (upward)
        glOrtho(tileRegion_->xMin, tileRegion_->xMax, tileRegion_->yMin, tileRegion_->yMax, 0.0, -1.0);
      else
        glOrtho(tileRegion_->xMin, tileRegion_->xMax, tileRegion_->yMax, tileRegion_->yMin, 0.0, -1.0);
    else
      if (upward)
        glOrtho(0, width(), 0, height(), 0.0, -1.0);
      else
        glOrtho(0, width(), height(), 0, 0.0, -1.0);

    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    glLoadIdentity();
}

void QGLViewer::stopScreenCoordinatesSystem() const
{
    glMatrixMode(GL_PROJECTION);
    glPopMatrix();

    glMatrixMode(GL_MODELVIEW);
    glPopMatrix();
}

void QGLViewer::timerEvent(QTimerEvent *)
{
    if (animationIsStarted())
    {
        animate();
        updateGL();
    }
}

void QGLViewer::startAnimation()
{
    animationTimerId_ = startTimer(animationPeriod());
    animationStarted_ = true;
}

void QGLViewer::stopAnimation()
{
    animationStarted_ = false;
    if (animationTimerId_ != 0)
        killTimer(animationTimerId_);
}

void QGLViewer::closeEvent(QCloseEvent *e)
{
    // When the user clicks on the window close (x) button:
    // - If the viewer is a top level window, closeEvent is called and then saves to file.
    // - Otherwise, nothing happen s:(
    // When the user press the EXIT_VIEWER keyboard shortcut:
    // - If the viewer is a top level window, saveStateToFile() is also called
    // - Otherwise, closeEvent is NOT called and keyPressEvent does the job.

    /* After tests:
    E : Embedded widget
    N : Widget created with new
    C : closeEvent called
    D : destructor called

    E   N   C   D
    y   y
    y   n       y
    n   y   y
    n   n   y   y

    closeEvent is called iif the widget is NOT embedded.

    Destructor is called iif the widget is created on the stack
    or if widget (resp. parent if embedded) is created with WDestructiveClose flag.

    closeEvent always before destructor.

    Close using qApp->closeAllWindows or (x) is identical.
    */

    // #CONNECTION# Also done for EXIT_VIEWER in keyPressEvent().
    saveStateToFile();
    QGLWidget::closeEvent(e);
}

void QGLViewer::select(const QMouseEvent* event)
{
    // For those who don't derive but rather rely on the signal-slot mechanism.
    Q_EMIT pointSelected(event);
    select(event->pos());
}

void QGLViewer::select(const QPoint& point)
{
    beginSelection(point);
    drawWithNames();
    endSelection(point);
    postSelection(point);
}

void QGLViewer::beginSelection(const QPoint& point)
{
    // Make OpenGL context current (may be needed with several viewers ?)
    makeCurrent();

    // Prepare the selection mode
    glSelectBuffer(selectBufferSize(), selectBuffer());
    glRenderMode(GL_SELECT);
    glInitNames();

    // Loads the matrices
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    static GLint viewport[4];
    camera()->getViewport(viewport);
    gluPickMatrix(point.x(), point.y(), selectRegionWidth(), selectRegionHeight(), viewport);

    // loadProjectionMatrix() first resets the GL_PROJECTION matrix with a glLoadIdentity().
    // The false parameter prevents this and hence multiplies the matrices.
    camera()->loadProjectionMatrix(false);
    // Reset the original (world coordinates) modelview matrix
    camera()->loadModelViewMatrix();
}

void QGLViewer::endSelection(const QPoint& point)
{
    Q_UNUSED(point);

    // Flush GL buffers
    glFlush();

    // Get the number of objects that were seen through the pick matrix frustum. Reset GL_RENDER mode.
    GLint nbHits = glRenderMode(GL_RENDER);

    if (nbHits <= 0)
        setSelectedName(-1);
    else
    {
        // Interpret results: each object created 4 values in the selectBuffer().
        // selectBuffer[4*i+1] is the object minimum depth value, while selectBuffer[4*i+3] is the id pushed on the stack.
        // Of all the objects that were projected in the pick region, we select the closest one (zMin comparison).
        // This code needs to be modified if you use several stack levels. See glSelectBuffer() man page.
        GLuint zMin = (selectBuffer())[1];
        setSelectedName((selectBuffer())[3]);
        for (int i=1; i<nbHits; ++i)
            if ((selectBuffer())[4*i+1] < zMin)
            {
                zMin = (selectBuffer())[4*i+1];
                setSelectedName((selectBuffer())[4*i+3]);
            }
    }
}

void QGLViewer::setSelectBufferSize(int size)
{
    if (selectBuffer_)
        delete[] selectBuffer_;
    selectBufferSize_ = size;
    selectBuffer_ = new GLuint[selectBufferSize()];
}

void QGLViewer::performClickAction(ClickAction ca, const QMouseEvent* const e)
{
    // Note: action that need it should updateGL().
    switch (ca)
    {
        // # CONNECTION setMouseBinding prevents adding NO_CLICK_ACTION in clickBinding_
        // This case should hence not be possible. Prevents unused case warning.
    case NO_CLICK_ACTION :
        break;
    case ZOOM_ON_PIXEL :
        camera()->interpolateToZoomOnPixel(e->pos());
        break;
    case ZOOM_TO_FIT :
        camera()->interpolateToFitScene();
        break;
    case SELECT :
        select(e);
        updateGL();
        break;
    case RAP_FROM_PIXEL :
        if (camera()->setRevolveAroundPointFromPixel(e->pos()))
        {
            setVisualHintsMask(1);
            updateGL();
        }
        break;
    case RAP_IS_CENTER :
        camera()->setRevolveAroundPoint(sceneCenter());
        setVisualHintsMask(1);
        updateGL();
        break;
    case CENTER_FRAME :
        if (manipulatedFrame())
            manipulatedFrame()->projectOnLine(camera()->position(), camera()->viewDirection());
        break;
    case CENTER_SCENE :
        camera()->centerScene();
        break;
    case SHOW_ENTIRE_SCENE :
        camera()->showEntireScene();
        break;
    case ALIGN_FRAME :
        if (manipulatedFrame())
            manipulatedFrame()->alignWithFrame(camera()->frame());
        break;
    case ALIGN_CAMERA :
        camera()->frame()->alignWithFrame(NULL, true);
        break;
    }
}

void QGLViewer::mousePressEvent(QMouseEvent* e)
{
    //#CONNECTION# mouseDoubleClickEvent has the same structure
    //#CONNECTION# mouseString() concatenates bindings description in inverse order.
    ClickActionPrivate cap;
    cap.doubleClick = false;
#if QT_VERSION >= 0x040000
    cap.modifiers = e->modifiers();
    cap.button = e->button();
    cap.buttonsBefore = (QtMouseButtons)(e->buttons() & ~(e->button()));
#else
    cap.modifiers = (QtKeyboardModifiers)(e->state() & Qt::KeyboardModifierMask);
    cap.button = (QtMouseButtons)((e->stateAfter() & Qt::MouseButtonMask) & (~(e->state() & Qt::MouseButtonMask)));
    cap.buttonsBefore = (QtMouseButtons)(e->state() & Qt::MouseButtonMask);
#endif

    if (clickBinding_.contains(cap))
        performClickAction(clickBinding_[cap], e);
    else
        if (mouseGrabber())
        {
            if (mouseGrabberIsAManipulatedFrame_)
            {
                for (QMap<int, MouseActionPrivate>::ConstIterator it=mouseBinding_.begin(), end=mouseBinding_.end(); it!=end; ++it)
#if QT_VERSION >= 0x040000
                    if ((it.value().handler == FRAME) && ((it.key() & Qt::MouseButtonMask) == e->buttons()))
#else
                    if ((it.data().handler == FRAME) && ((it.key() & Qt::MouseButtonMask) == (e->stateAfter() & Qt::MouseButtonMask)))
#endif
                    {
                        ManipulatedFrame* mf = dynamic_cast<ManipulatedFrame*>(mouseGrabber());
                        if (mouseGrabberIsAManipulatedCameraFrame_)
                        {
                            mf->ManipulatedFrame::startAction(it.value().action, it.value().withConstraint);
                            mf->ManipulatedFrame::mousePressEvent(e, camera());
                        }
                        else
                        {
                            mf->startAction(it.value().action, it.value().withConstraint);
                            mf->mousePressEvent(e, camera());
                        }
                        break;
                    }
            }
            else
                mouseGrabber()->mousePressEvent(e, camera());
            updateGL();
        }
        else
        {
            //#CONNECTION# wheelEvent has the same structure
#if QT_VERSION >= 0x040000
            const int state = e->modifiers() | e->buttons();
#else
            const int state = e->stateAfter();
#endif

            if (mouseBinding_.contains(state))
            {
                MouseActionPrivate map = mouseBinding_[state];
                switch (map.handler)
                {
                case CAMERA :
                    camera()->frame()->startAction(map.action, map.withConstraint);
                    camera()->frame()->mousePressEvent(e, camera());
                    break;
                case FRAME :
                    if (manipulatedFrame())
                    {
                        if (manipulatedFrameIsACamera_)
                        {
                            manipulatedFrame()->ManipulatedFrame::startAction(map.action, map.withConstraint);
                            manipulatedFrame()->ManipulatedFrame::mousePressEvent(e, camera());
                        }
                        else
                        {
                            manipulatedFrame()->startAction(map.action, map.withConstraint);
                            manipulatedFrame()->mousePressEvent(e, camera());
                        }
                    }
                    break;
                }
                if (map.action == SCREEN_ROTATE)
                    // Display visual hint line
                    updateGL();
            }
#if QT_VERSION >= 0x030000
            else
                e->ignore();
#endif
        }
}

void QGLViewer::mouseMoveEvent(QMouseEvent* e)
{
    if (mouseGrabber())
    {
        mouseGrabber()->checkIfGrabsMouse(e->x(), e->y(), camera());
        if (mouseGrabber()->grabsMouse())
            if (mouseGrabberIsAManipulatedCameraFrame_)
                (dynamic_cast<ManipulatedFrame*>(mouseGrabber()))->ManipulatedFrame::mouseMoveEvent(e, camera());
            else
                mouseGrabber()->mouseMoveEvent(e, camera());
        else
            setMouseGrabber(NULL);
        updateGL();
    }

    if (!mouseGrabber())
    {
        //#CONNECTION# mouseReleaseEvent has the same structure
        if (camera()->frame()->isManipulated())
        {
            camera()->frame()->mouseMoveEvent(e, camera());
            // #CONNECTION# manipulatedCameraFrame::mouseMoveEvent specific if at the beginning
            if (camera()->frame()->action_ == ZOOM_ON_REGION)
                updateGL();
        }
        else // !
            if ((manipulatedFrame()) && (manipulatedFrame()->isManipulated()))
                if (manipulatedFrameIsACamera_)
                    manipulatedFrame()->ManipulatedFrame::mouseMoveEvent(e, camera());
                else
                    manipulatedFrame()->mouseMoveEvent(e, camera());
            else
                if (hasMouseTracking())
                {
#if QT_VERSION >= 0x040000
                    Q_FOREACH (MouseGrabber* mg, MouseGrabber::MouseGrabberPool())
                    {
#else
                    QPtrListIterator<MouseGrabber> it(MouseGrabber::MouseGrabberPool());
                    for (MouseGrabber* mg; (mg = it.current()); ++it)
                    {
#endif
                        mg->checkIfGrabsMouse(e->x(), e->y(), camera());
                        if (mg->grabsMouse())
                        {
                            setMouseGrabber(mg);
                            // Check that MouseGrabber is not disabled
                            if (mouseGrabber() == mg)
                            {
                                updateGL();
                                break;
                            }
                        }
                    }
                }
    }
}

void QGLViewer::mouseReleaseEvent(QMouseEvent* e)
{
    if (mouseGrabber())
    {
        if (mouseGrabberIsAManipulatedCameraFrame_)
            (dynamic_cast<ManipulatedFrame*>(mouseGrabber()))->ManipulatedFrame::mouseReleaseEvent(e, camera());
        else
            mouseGrabber()->mouseReleaseEvent(e, camera());
        mouseGrabber()->checkIfGrabsMouse(e->x(), e->y(), camera());
        if (!(mouseGrabber()->grabsMouse()))
            setMouseGrabber(NULL);
        // updateGL();
    }
    else
        //#CONNECTION# mouseMoveEvent has the same structure
        if (camera()->frame()->isManipulated())
        {
            // bool updateGLNeeded = ((camera()->frame()->action_ == ZOOM_ON_REGION) ||
            // (camera()->frame()->action_ == SCREEN_ROTATE));
            camera()->frame()->mouseReleaseEvent(e, camera());
            // if (updateGLNeeded)
            // Needed in all cases because of fastDraw().
            // updateGL();
        }
        else
            if ((manipulatedFrame()) && (manipulatedFrame()->isManipulated()))
            {
                // bool updateGLNeeded = (manipulatedFrame()->action_ == SCREEN_ROTATE);
                if (manipulatedFrameIsACamera_)
                    manipulatedFrame()->ManipulatedFrame::mouseReleaseEvent(e, camera());
                else
                    manipulatedFrame()->mouseReleaseEvent(e, camera());
                // if (updateGLNeeded)
                // updateGL();
            }
#if QT_VERSION >= 0x030000
            else
                e->ignore();
#endif

    // Not absolutely needed (see above commented code for the optimal version), but may reveal
    // useful for specific applications.
    updateGL();
}

void QGLViewer::wheelEvent(QWheelEvent* e)
{
    if (mouseGrabber())
    {
        if (mouseGrabberIsAManipulatedFrame_)
        {
            for (QMap<QtKeyboardModifiers, MouseActionPrivate>::ConstIterator it=wheelBinding_.begin(), end=wheelBinding_.end(); it!=end; ++it)
                if (it.value().handler == FRAME)
                {
                    ManipulatedFrame* mf = dynamic_cast<ManipulatedFrame*>(mouseGrabber());
                    if (mouseGrabberIsAManipulatedCameraFrame_)
                    {
                        mf->ManipulatedFrame::startAction(it.value().action, it.value().withConstraint);
                        mf->ManipulatedFrame::wheelEvent(e, camera());
                    }
                    else
                    {
                        mf->startAction(it.value().action, it.value().withConstraint);
                        mf->wheelEvent(e, camera());
                    }
                    break;
                }
        }
        else
            mouseGrabber()->wheelEvent(e, camera());
        updateGL();
    }
    else
    {
        //#CONNECTION# mousePressEvent has the same structure
#if QT_VERSION >= 0x040000
        const QtKeyboardModifiers modifiers = e->modifiers();
#else
        const QtKeyboardModifiers modifiers = e->state();
#endif
        if (wheelBinding_.contains(modifiers))
        {
            MouseActionPrivate map = wheelBinding_[modifiers];
            switch (map.handler)
            {
            case CAMERA :
                camera()->frame()->startAction(map.action, map.withConstraint);
                camera()->frame()->wheelEvent(e, camera());
                break;
            case FRAME :
                if (manipulatedFrame()) {
                    if (manipulatedFrameIsACamera_)
                    {
                        manipulatedFrame()->ManipulatedFrame::startAction(map.action, map.withConstraint);
                        manipulatedFrame()->ManipulatedFrame::wheelEvent(e, camera());
                    }
                    else
                    {
                        manipulatedFrame()->startAction(map.action, map.withConstraint);
                        manipulatedFrame()->wheelEvent(e, camera());
                    }
                }
                break;
            }
        }
#if QT_VERSION >= 0x030000
        else
            e->ignore();
#endif
    }
}

void QGLViewer::mouseDoubleClickEvent(QMouseEvent* e)
{
    //#CONNECTION# mousePressEvent has the same structure
    ClickActionPrivate cap;
    cap.doubleClick = true;
#if QT_VERSION >= 0x040000
    cap.modifiers = e->modifiers();
    cap.button = e->button();
    cap.buttonsBefore = (QtMouseButtons)(e->buttons() & ~(e->button()));
#else
    cap.modifiers = (QtKeyboardModifiers)(e->state() & Qt::KeyboardModifierMask);
    cap.button = (QtMouseButtons)((e->stateAfter() & Qt::MouseButtonMask) & (~(e->state() & Qt::MouseButtonMask)));
    cap.buttonsBefore = (QtMouseButtons)(e->state() & Qt::MouseButtonMask);
#endif
    if (clickBinding_.contains(cap))
        performClickAction(clickBinding_[cap], e);
    else
        if (mouseGrabber())
            mouseGrabber()->mouseDoubleClickEvent(e, camera());
#if QT_VERSION >= 0x030000
        else
            e->ignore();
#endif
}

void QGLViewer::setStereoDisplay(bool stereo)
{
    if (format().stereo())
    {
        stereo_ = stereo;
        if (!displaysInStereo())
        {
            glDrawBuffer(GL_BACK_LEFT);
            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
            glDrawBuffer(GL_BACK_RIGHT);
            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        }

        Q_EMIT stereoChanged(stereo_);

        if (updateGLOK_)
            updateGL();
    }
    else
        if (stereo)
            QMessageBox::warning(this, tr("Stereo not supported", "Message box window title"), tr("Stereo is not supported on this display."));
        else
            stereo_ = false;
}

void QGLViewer::setFullScreen(bool fullScreen)
{
    fullScreen_ = fullScreen;

    // Tricky. A timer does it later if !updateGLOK_.
    if (!updateGLOK_)
        return;

    QWidget* tlw = topLevelWidget();

    if (isFullScreen())
    {
        prevPos_ = topLevelWidget()->pos();
        tlw->showFullScreen();
        tlw->move(0,0);
    }
    else
    {
        tlw->showNormal();
        tlw->move(prevPos_);
    }
}

void QGLViewer::setMouseGrabber(MouseGrabber* mouseGrabber)
{
    if (!mouseGrabberIsEnabled(mouseGrabber))
        return;

    mouseGrabber_ = mouseGrabber;

    mouseGrabberIsAManipulatedFrame_       = (dynamic_cast<ManipulatedFrame*>(mouseGrabber) != NULL);
    mouseGrabberIsAManipulatedCameraFrame_ = ((dynamic_cast<ManipulatedCameraFrame*>(mouseGrabber) != NULL) &&
        (mouseGrabber != camera()->frame()));
    Q_EMIT mouseGrabberChanged(mouseGrabber);
}

void QGLViewer::setMouseGrabberIsEnabled(const qglviewer::MouseGrabber* const mouseGrabber, bool enabled)
{
    if (enabled)
        disabledMouseGrabbers_.remove(reinterpret_cast<size_t>(mouseGrabber));
    else
        disabledMouseGrabbers_[reinterpret_cast<size_t>(mouseGrabber)];
}

static QString keyboardModifiersString(QtKeyboardModifiers m, bool noButton=false)
{
#if QT_VERSION >= 0x040000
    if (noButton && (m==Qt::NoModifier)) 
#else
    if (noButton && (m==Qt::NoButton))
#endif
        return QGLViewer::tr("(no button)");
    
    QString keySequence = "";

#if QT_VERSION >= 0x040000
    if (m & Qt::ControlModifier) keySequence += "Ctrl+";
    if (m & Qt::AltModifier) keySequence += "Alt+";
    if (m & Qt::ShiftModifier) keySequence += "Shift+";
    if (m & Qt::MetaModifier) keySequence += "Meta+";
#else
    if (m & Qt::ControlButton) keySequence += "Ctrl+";
    if (m & Qt::AltButton) keySequence += "Alt+";
    if (m & Qt::ShiftButton) keySequence += "Shift+";
# if QT_VERSION >= 0x030000
    if (m & Qt::MetaButton) keySequence += "Meta+";
# endif
#endif

    if (keySequence.length() > 0)
#if QT_VERSION >= 0x040000
        return QKeySequence(keySequence+"X").toString(QKeySequence::NativeText).replace("X", "");
#else
        return QString(QKeySequence(keySequence+"X")).replace("X", "");
#endif
    else
        return QString();
}

static QString mouseButtonsString(QtMouseButtons b)
{
    QString result("");
    bool addAmpersand = false;
    if (b & Qt::LeftButton)    { result += QGLViewer::tr("Left", "left mouse button"); addAmpersand=true; }
    if (b & Qt::MidButton)     { if (addAmpersand) result += " & "; result += QGLViewer::tr("Middle", "middle mouse button"); addAmpersand=true; }
    if (b & Qt::RightButton)   { if (addAmpersand) result += " & "; result += QGLViewer::tr("Right", "right mouse button"); }
    return result;
}

QString QGLViewer::mouseActionString(QGLViewer::MouseAction ma)
{
    switch (ma)
    {
    case QGLViewer::NO_MOUSE_ACTION : return QString::null;
    case QGLViewer::ROTATE : return QGLViewer::tr("Rotates", "ROTATE mouse action");
    case QGLViewer::ZOOM : return QGLViewer::tr("Zooms", "ZOOM mouse action");
    case QGLViewer::TRANSLATE : return QGLViewer::tr("Translates", "TRANSLATE mouse action");
    case QGLViewer::MOVE_FORWARD : return QGLViewer::tr("Moves forward", "MOVE_FORWARD mouse action");
    case QGLViewer::LOOK_AROUND : return QGLViewer::tr("Looks around", "LOOK_AROUND mouse action");
    case QGLViewer::MOVE_BACKWARD : return QGLViewer::tr("Moves backward", "MOVE_BACKWARD mouse action");
    case QGLViewer::SCREEN_ROTATE : return QGLViewer::tr("Rotates in screen plane", "SCREEN_ROTATE mouse action");
    case QGLViewer::ROLL : return QGLViewer::tr("Rolls", "ROLL mouse action");
    case QGLViewer::DRIVE : return QGLViewer::tr("Drives", "DRIVE mouse action");
    case QGLViewer::SCREEN_TRANSLATE : return QGLViewer::tr("Horizontally/Vertically translates", "SCREEN_TRANSLATE mouse action");
    case QGLViewer::ZOOM_ON_REGION : return QGLViewer::tr("Zooms on region for", "ZOOM_ON_REGION mouse action");
    }
    return QString::null;
}

QString QGLViewer::clickActionString(QGLViewer::ClickAction ca)
{
    switch (ca)
    {
    case QGLViewer::NO_CLICK_ACTION : return QString::null;
    case QGLViewer::ZOOM_ON_PIXEL : return QGLViewer::tr("Zooms on pixel", "ZOOM_ON_PIXEL click action");
    case QGLViewer::ZOOM_TO_FIT : return QGLViewer::tr("Zooms to fit scene", "ZOOM_TO_FIT click action");
    case QGLViewer::SELECT : return QGLViewer::tr("Selects", "SELECT click action");
    case QGLViewer::RAP_FROM_PIXEL : return QGLViewer::tr("Sets revolve around point", "RAP_FROM_PIXEL click action");
    case QGLViewer::RAP_IS_CENTER : return QGLViewer::tr("Resets revolve around point", "RAP_IS_CENTER click action");
    case QGLViewer::CENTER_FRAME : return QGLViewer::tr("Centers frame", "CENTER_FRAME click action");
    case QGLViewer::CENTER_SCENE : return QGLViewer::tr("Centers scene", "CENTER_SCENE click action");
    case QGLViewer::SHOW_ENTIRE_SCENE : return QGLViewer::tr("Shows entire scene", "SHOW_ENTIRE_SCENE click action");
    case QGLViewer::ALIGN_FRAME : return QGLViewer::tr("Aligns frame", "ALIGN_FRAME click action");
    case QGLViewer::ALIGN_CAMERA : return QGLViewer::tr("Aligns camera", "ALIGN_CAMERA click action");
    }
    return QString::null;
}

QString QGLViewer::formatClickActionPrivate(ClickActionPrivate cap)
{
    bool buttonsBefore = cap.buttonsBefore != Qt::NoButton;
    return tr("%1%2%3%4%5%6", "Modifier / button or wheel / double click / with / button / pressed")
        .arg(keyboardModifiersString(cap.modifiers))
        .arg(mouseButtonsString(cap.button)+(cap.button == Qt::NoButton ? tr("Wheel", "Mouse wheel") : ""))
        .arg(cap.doubleClick ? tr(" double click", "Suffix after mouse button") : "")
        .arg(buttonsBefore ? tr(" with ", "As in : Left button with Ctrl pressed") : "")
        .arg(buttonsBefore ? mouseButtonsString(cap.buttonsBefore) : "")
        .arg(buttonsBefore ? tr(" pressed", "As in : Left button with Ctrl pressed") : "");
}

void QGLViewer::setMouseBindingDescription(int state, QString description, bool doubleClick, QtMouseButtons buttonsBefore)
{
    ClickActionPrivate cap;
    cap.modifiers = QtKeyboardModifiers(convertToKeyboardModifiers(state) & Qt::KeyboardModifierMask);
    cap.button = QtMouseButtons(state & Qt::MouseButtonMask);
    cap.doubleClick = doubleClick;
    cap.buttonsBefore = buttonsBefore;

    if (description.isEmpty())
        mouseDescription_.remove(cap);
    else
        mouseDescription_[cap] = description;
}

static QString tableLine(const QString& left, const QString& right)
{
    static bool even = false;
    const QString tdtd("</b></td><td>");
    const QString tdtr("</td></tr>\n");

    QString res("<tr bgcolor=\"");

    if (even)
        res += "#eeeeff\">";
    else
        res += "#ffffff\">";
    res += "<td><b>" + left + tdtd + right + tdtr;
    even = !even;

    return res;
}

QString QGLViewer::mouseString() const
{
    QString text("<center><table border=\"1\" cellspacing=\"0\" cellpadding=\"4\">\n");
    const QString trtd("<tr><td>");
    const QString tdtr("</td></tr>\n");
    const QString tdtd("</td><td>");

    text += QString("<tr bgcolor=\"#aaaacc\"><th align=\"center\">%1</th><th align=\"center\">%2</th></tr>\n").
        arg(tr("Button(s)", "Buttons column header in help window mouse tab")).arg(tr("Description", "Description column header in help window mouse tab"));

    QMap<ClickActionPrivate, QString> mouseBinding;

    // User-defined mouse bindings come first.
    for (QMap<ClickActionPrivate, QString>::ConstIterator itm=mouseDescription_.begin(), endm=mouseDescription_.end(); itm!=endm; ++itm)
        mouseBinding[itm.key()] = itm.value();

    for (QMap<ClickActionPrivate, QString>::ConstIterator it=mouseBinding.begin(), end=mouseBinding.end(); it != end; ++it)
    {
        // Should not be needed (see setMouseBindingDescription())
        if (it.value().isNull())
            continue;

        text += tableLine(formatClickActionPrivate(it.key()), it.value());
    }

    // Optionnal separator line
    if (!mouseBinding.isEmpty())
    {
        mouseBinding.clear();
        text += QString("<tr bgcolor=\"#aaaacc\"><td colspan=2>%1</td></tr>\n").arg(tr("Standard mouse bindings", "In help window mouse tab"));
    }

    // Then concatenates the descriptions of wheelBinding_, mouseBinding_ and clickBinding_.
    // The order is significant and corresponds to the priorities set in mousePressEvent() (reverse priority order, last one overwrites previous)
    // #CONNECTION# mousePressEvent() order
    for (QMap<QtKeyboardModifiers, MouseActionPrivate>::ConstIterator itw=wheelBinding_.begin(), endw=wheelBinding_.end(); itw != endw; ++itw)
    {
        ClickActionPrivate cap;
        cap.doubleClick = false;
        cap.modifiers = itw.key();
        cap.button = Qt::NoButton;
        cap.buttonsBefore = Qt::NoButton;

        QString text = mouseActionString(itw.value().action);

        if (!text.isNull())
        {
            switch (itw.value().handler)
            {
            case CAMERA: text += " " + tr("camera", "Suffix after action"); break;
            case FRAME:  text += " " + tr("manipulated frame", "Suffix after action"); break;
            }
            if (!(itw.value().withConstraint))
                text += "*";
        }

        mouseBinding[cap] = text;
    }

    for (QMap<int, MouseActionPrivate>::ConstIterator itmb=mouseBinding_.begin(), endmb=mouseBinding_.end();
        itmb != endmb; ++itmb)
    {
        ClickActionPrivate cap;
        cap.doubleClick = false;
        cap.modifiers = QtKeyboardModifiers(itmb.key() & Qt::KeyboardModifierMask);
        cap.button = QtMouseButtons(itmb.key() & Qt::MouseButtonMask);
        cap.buttonsBefore = Qt::NoButton;

        QString text = mouseActionString(itmb.value().action);

        if (!text.isNull())
        {
            switch (itmb.value().handler)
            {
            case CAMERA: text += " " + tr("camera", "Suffix after action"); break;
            case FRAME:  text += " " + tr("manipulated frame", "Suffix after action"); break;
            }
            if (!(itmb.value().withConstraint))
                text += "*";
        }
        mouseBinding[cap] = text;
    }

    for (QMap<ClickActionPrivate, ClickAction>::ConstIterator itcb=clickBinding_.begin(), endcb=clickBinding_.end(); itcb!=endcb; ++itcb)
        mouseBinding[itcb.key()] = clickActionString(itcb.value());

    for (QMap<ClickActionPrivate, QString>::ConstIterator it2=mouseBinding.begin(), end2=mouseBinding.end(); it2 != end2; ++it2)
    {
        if (it2.value().isNull())
            continue;

        text += tableLine(formatClickActionPrivate(it2.key()), it2.value());
    }

    text += "</table></center>";

    return text;
}

void QGLViewer::setKeyDescription(int key, QString description)
{
#if QT_VERSION >= 0x030000
    // #CONNECTION# keyString. In Qt 2.3, longs modifier overlap with key codes.
    key = convertToKeyboardModifiers(key);
#endif
    if (description.isEmpty())
        keyDescription_.remove(key);
    else
        keyDescription_[key] = description;
}

static QString keyString(int key)
{
#if QT_VERSION >= 0x030000
    return QString(QKeySequence(convertToShortModifier(key)));
#else
    // #CONNECTION# setKeyDescription. In Qt 2.3, longs modifier overlap with key codes.
    return QString(QKeySequence(key));
#endif
}

QString QGLViewer::cameraPathKeysString() const
{
    if (pathIndex_.isEmpty())
        return QString::null;

#if QT_VERSION >= 0x040000 || QT_VERSION < 0x030000
    QVector<int> keys;
#else
    QValueVector<int> keys;
#endif
    keys.reserve(pathIndex_.count());
    for (QMap<Qt::Key, int>::ConstIterator i = pathIndex_.begin(), endi=pathIndex_.end(); i != endi; ++i)
        keys.push_back(i.key());
#if QT_VERSION >= 0x040000
    qSort(keys);
#else
# if QT_VERSION >= 0x030000
    qHeapSort(keys);
# else
    sort(keys.begin(), keys.end());
# endif
#endif

#if QT_VERSION >= 0x040000 || QT_VERSION < 0x030000
    QVector<int>::const_iterator it = keys.begin(), end = keys.end();
#else
    QValueVector<int>::const_iterator it = keys.begin(), end = keys.end();
#endif
    QString res = keyString(*it);

    const int maxDisplayedKeys = 6;
    int nbDisplayedKeys = 0;
    int previousKey = (*it);
    int state = 0;
    ++it;
    while ((it != end) && (nbDisplayedKeys < maxDisplayedKeys-1))
    {
        switch (state)
        {
        case 0 :
            if ((*it) == previousKey + 1)
                state++;
            else
            {
                res += ", " + keyString(*it);
                nbDisplayedKeys++;
            }
            break;
        case 1 :
            if ((*it) == previousKey + 1)
                state++;
            else
            {
                res += ", " + keyString(previousKey);
                res += ", " + keyString(*it);
                nbDisplayedKeys += 2;
                state = 0;
            }
            break;
        default :
            if ((*it) != previousKey + 1)
            {
                res += ".." + keyString(previousKey);
                res += ", " + keyString(*it);
                nbDisplayedKeys += 2;
                state = 0;
            }
            break;
        }
        previousKey = *it;
        ++it;
    }

    if (state == 1)
        res += ", " + keyString(previousKey);
    if (state == 2)
        res += ".." + keyString(previousKey);
    if (it != end)
        res += "...";

    return res;
}

QString QGLViewer::keyboardString() const
{
    QString text("<center><table border=\"1\" cellspacing=\"0\" cellpadding=\"4\">\n");
    text += QString("<tr bgcolor=\"#aaaacc\"><th align=\"center\">%1</th><th align=\"center\">%2</th></tr>\n").
        arg(QGLViewer::tr("Key(s)", "Keys column header in help window mouse tab")).arg(QGLViewer::tr("Description", "Description column header in help window mouse tab"));

    QMap<int, QString> keyDescription;

    // 1 - User defined key descriptions
    for (QMap<int, QString>::ConstIterator kd=keyDescription_.begin(), kdend=keyDescription_.end(); kd!=kdend; ++kd)
        keyDescription[kd.key()] = kd.value();

    // Add to text in sorted order
    for (QMap<int, QString>::ConstIterator kb=keyDescription.begin(), endb=keyDescription.end(); kb!=endb; ++kb)
        text += tableLine(keyString(kb.key()), kb.value());


    // 2 - Optional separator line
    if (!keyDescription.isEmpty())
    {
        keyDescription.clear();
        text += QString("<tr bgcolor=\"#aaaacc\"><td colspan=2>%1</td></tr>\n").arg(QGLViewer::tr("Standard viewer keys", "In help window keys tab"));
    }


    // 3 - KeyboardAction bindings description
    for (QMap<KeyboardAction, int>::ConstIterator it=keyboardBinding_.begin(), end=keyboardBinding_.end(); it != end; ++it)
        if ((it.value() != 0) && ((!cameraIsInRevolveMode()) || ((it.key() != INCREASE_FLYSPEED) && (it.key() != DECREASE_FLYSPEED))))
            keyDescription[it.value()] = keyboardActionDescription_[it.key()];

    // Add to text in sorted order
    for (QMap<int, QString>::ConstIterator kb2=keyDescription.begin(), endb2=keyDescription.end(); kb2!=endb2; ++kb2)
        text += tableLine(keyString(kb2.key()), kb2.value());


    // 4 - Camera paths keys description
    const QString cpks = cameraPathKeysString();
    if (!cpks.isNull())
    {
        text += "<tr bgcolor=\"#ccccff\"><td colspan=2>\n";
        text += QGLViewer::tr("Camera paths are controlled using %1 (noted <i>Fx</i> below):", "Help window key tab camera keys").arg(cpks) + "</td></tr>\n";
        text += tableLine(keyboardModifiersString(playPathKeyboardModifiers()) + "<i>" + QGLViewer::tr("Fx", "Generic function key (F1..F12)") + "</i>",
            QGLViewer::tr("Plays path (or resets saved position)"));
        text += tableLine(keyboardModifiersString(addKeyFrameKeyboardModifiers()) + "<i>" + QGLViewer::tr("Fx", "Generic function key (F1..F12)") + "</i>",
            QGLViewer::tr("Adds a key frame to path (or defines a position)"));
        text += tableLine(keyboardModifiersString(addKeyFrameKeyboardModifiers()) + "<i>" + QGLViewer::tr("Fx", "Generic function key (F1..F12)") + "</i>+<i>" + QGLViewer::tr("Fx", "Generic function key (F1..F12)") + "</i>",
            QGLViewer::tr("Deletes path (or saved position)"));
    }
    text += "</table></center>";

    return text;
}

void QGLViewer::aboutQGLViewer() {
    help();
#if QT_VERSION >= 0x040000
    helpWidget()->setCurrentIndex(3);
#else
    helpWidget()->setCurrentPage(3);
#endif
}

    
void QGLViewer::help()
{
    Q_EMIT helpRequired();

    bool resize = false;
    int width=600;
    int height=400;

    static QString label[] = {tr("&Help", "Help window tab title"), tr("&Keyboard", "Help window tab title"), tr("&Mouse", "Help window tab title"), tr("&About", "Help window about title")};

    if (!helpWidget())
    {
        // Qt4 requires a NULL parent...
        helpWidget_ = new QTabWidget(NULL);
#if QT_VERSION >= 0x040000
        helpWidget()->setWindowTitle(tr("Help", "Help window title"));
#else
        helpWidget()->setCaption(tr("Help", "Help window title"));
#endif

        resize = true;
        for (int i=0; i<4; ++i)
        {
            QTextEdit* tab = new QTextEdit(NULL);
#if QT_VERSION >= 0x030000
            tab->setReadOnly(true);
#endif

#if QT_VERSION >= 0x040000
            helpWidget()->insertTab(i, tab, label[i]);
            if (i==3) {
#               include "qglviewer-icon.xpm"
                QPixmap pixmap(qglviewer_icon);
                tab->document()->addResource(QTextDocument::ImageResource,
                                             QUrl("mydata://qglviewer-icon.xpm"), QVariant(pixmap));
            }
#else
            tab->setTextFormat(Qt::RichText);
            helpWidget()->insertTab(tab, label[i]);
#endif
        }
    }
    
    
#if QT_VERSION < 0x030000
    const int currentPageIndex = helpWidget()->currentPageIndex();
#endif

    for (int i=0; i<4; ++i)
    {
        QString text;
        switch (i)
        {
        case 0 : text = helpString();     break;
        case 1 : text = keyboardString(); break;
        case 2 : text = mouseString();    break;
        case 3 : text = QString("<center><br><img src=\"mydata://qglviewer-icon.xpm\">") + tr(
                           "<h1>libQGLViewer</h1>"
                           "<h3>Version %1</h3><br>"                                                                      
                           "A versatile 3D viewer based on OpenGL and Qt<br>"
                           "Copyright 2002-%2 Gilles Debunne<br>"
                           "<code>%3</code>").arg(QGLViewerVersionString()).arg("2010").arg("http://www.libqglviewer.com") +
                           QString("</center>");
                break;
        default : break;
        }

#if QT_VERSION >= 0x040000
        QTextEdit* textEdit = (QTextEdit*)(helpWidget()->widget(i));
        textEdit->setHtml(text);
#else
# if QT_VERSION < 0x030000
        helpWidget()->setCurrentPage(i);
        QTextEdit* textEdit = (QTextEdit*)(helpWidget()->currentPage());
# else
        QTextEdit* textEdit = (QTextEdit*)(helpWidget()->page(i));
# endif
        textEdit->setText(text);
#endif

#if QT_VERSION < 0x040000
        if (resize && (textEdit->heightForWidth(width) > height))
            height = textEdit->heightForWidth(width);
#else
        if (resize && (textEdit->height() > height))
            height = textEdit->height();
#endif
    }

#if QT_VERSION < 0x030000
    helpWidget()->setCurrentPage(currentPageIndex);
#endif

    if (resize)
        helpWidget()->resize(width, height+40); // 40 pixels is ~ tabs' height
    helpWidget()->show();
    helpWidget()->raise();
}

void QGLViewer::keyPressEvent(QKeyEvent *e)
{
    if (e->key() == 0)
    {
        e->ignore();
        return;
    }

    const Qt::Key key = Qt::Key(e->key());
#if QT_VERSION >= 0x040000
    const QtKeyboardModifiers modifiers = e->modifiers();
#else
    const QtKeyboardModifiers modifiers = (QtKeyboardModifiers)(e->state() & Qt::KeyboardModifierMask);
#endif

    QMap<KeyboardAction, int>::ConstIterator it=keyboardBinding_.begin(), end=keyboardBinding_.end();
    while ((it != end) && (it.value() != (key | modifiers)))
        ++it;

    if (it != end)
        handleKeyboardAction(it.key());
    else
        if (pathIndex_.contains(Qt::Key(key)))
        {
            // Camera paths
            int index = pathIndex_[Qt::Key(key)];

            static QTime doublePress; // try to double press on two viewers at the same time !

            if (modifiers == playPathKeyboardModifiers())
            {
                int elapsed = doublePress.restart();
                if ((elapsed < 250) && (index==previousPathId_))
                    camera()->resetPath(index);
                else
                {
                    // Stop previous interpolation before starting a new one.
                    if (index != previousPathId_)
                    {
                        KeyFrameInterpolator* previous = camera()->keyFrameInterpolator(previousPathId_);
                        if ((previous) && (previous->interpolationIsStarted()))
                            previous->resetInterpolation();
                    }
                    camera()->playPath(index);
                }
                previousPathId_ = index;
            }
            else if (modifiers == addKeyFrameKeyboardModifiers())
            {
                int elapsed = doublePress.restart();
                if ((elapsed < 250) && (index==previousPathId_))
                {
                    if (camera()->keyFrameInterpolator(index))
                    {
                        disconnect(camera()->keyFrameInterpolator(index), SIGNAL(interpolated()), this, SLOT(updateGL()));
                        if (camera()->keyFrameInterpolator(index)->numberOfKeyFrames() > 1)
                            displayMessage(tr("Path %1 deleted", "Feedback message").arg(index));
                        else
                            displayMessage(tr("Position %1 deleted", "Feedback message").arg(index));
                        camera()->deletePath(index);
                    }
                }
                else
                {
                    bool nullBefore = (camera()->keyFrameInterpolator(index) == NULL);
                    camera()->addKeyFrameToPath(index);
                    if (nullBefore)
                        connect(camera()->keyFrameInterpolator(index), SIGNAL(interpolated()), SLOT(updateGL()));
                    int nbKF = camera()->keyFrameInterpolator(index)->numberOfKeyFrames();
                    if (nbKF > 1)
                        displayMessage(tr("Path %1, position %2 added", "Feedback message").arg(index).arg(nbKF));
                    else
                        displayMessage(tr("Position %1 saved", "Feedback message").arg(index));
                }
                previousPathId_ = index;
            }
            updateGL();
        }
        else
            e->ignore();
}

void QGLViewer::handleKeyboardAction(KeyboardAction id)
{
    switch (id)
    {
    case DRAW_AXIS :        toggleAxisIsDrawn(); break;
    case DRAW_GRID :        toggleGridIsDrawn(); break;
    case DISPLAY_FPS :      toggleFPSIsDisplayed(); break;
    case ENABLE_TEXT :      toggleTextIsEnabled(); break;
    case EXIT_VIEWER :      saveStateToFileForAllViewers(); qApp->closeAllWindows(); break;
    case SAVE_SCREENSHOT :      saveSnapshot(false, false); break;
    case FULL_SCREEN :      toggleFullScreen(); break;
    case STEREO :           toggleStereoDisplay(); break;
    case ANIMATION :        toggleAnimation(); break;
    case HELP :         help(); break;
    case EDIT_CAMERA :      toggleCameraIsEdited(); break;
    case SNAPSHOT_TO_CLIPBOARD :    snapshotToClipboard(); break;
    case CAMERA_MODE :
        toggleCameraMode();
        displayMessage(cameraIsInRevolveMode()?tr("Camera in revolve around mode", "Feedback message"):tr("Camera in fly mode", "Feedback message"));
        break;

    case MOVE_CAMERA_LEFT :
        camera()->frame()->translate(camera()->frame()->inverseTransformOf(Vec(-10.0*camera()->flySpeed(), 0.0, 0.0)));
        updateGL();
        break;
    case MOVE_CAMERA_RIGHT :
        camera()->frame()->translate(camera()->frame()->inverseTransformOf(Vec( 10.0*camera()->flySpeed(), 0.0, 0.0)));
        updateGL();
        break;
    case MOVE_CAMERA_UP :
        camera()->frame()->translate(camera()->frame()->inverseTransformOf(Vec(0.0,  10.0*camera()->flySpeed(), 0.0)));
        updateGL();
        break;
    case MOVE_CAMERA_DOWN :
        camera()->frame()->translate(camera()->frame()->inverseTransformOf(Vec(0.0, -10.0*camera()->flySpeed(), 0.0)));
        updateGL();
        break;

    case INCREASE_FLYSPEED : camera()->setFlySpeed(camera()->flySpeed() * 1.5); break;
    case DECREASE_FLYSPEED : camera()->setFlySpeed(camera()->flySpeed() / 1.5); break;
    }
}

void QGLViewer::resizeGL(int width, int height)
{
    QGLWidget::resizeGL(width, height);
    glViewport( 0, 0, GLint(width), GLint(height) );
    camera()->setScreenWidthAndHeight(this->width(), this->height());
}

//              K e y b o a r d   s h o r t c u t s                     //

void QGLViewer::setShortcut(KeyboardAction action, int key)
{
    keyboardBinding_[action] = convertToKeyboardModifiers(key);
}

int QGLViewer::shortcut(KeyboardAction action) const
{
    if (keyboardBinding_.contains(action))
        return convertToShortModifier(keyboardBinding_[action]);
    else
        return 0;
}

#ifndef DOXYGEN
void QGLViewer::setKeyboardAccelerator(KeyboardAction action, int key)
{
    qWarning("setKeyboardAccelerator is deprecated. Use setShortcut instead.");
    setShortcut(action, key);
}

int QGLViewer::keyboardAccelerator(KeyboardAction action) const
{
    qWarning("keyboardAccelerator is deprecated. Use shortcut instead.");
    return shortcut(action);
}
#endif


Qt::Key QGLViewer::pathKey(int index) const
{
    for (QMap<Qt::Key, int>::ConstIterator it = pathIndex_.begin(), end=pathIndex_.end(); it != end; ++it)
        if (it.value() == index)
            return it.key();
    return Qt::Key(0);
}

void QGLViewer::setPathKey(int key, int index)
{
    if (key < 0)
        pathIndex_.remove(Qt::Key(-key));
    else
        pathIndex_[Qt::Key(key)] = index;
}

void QGLViewer::setPlayPathKeyboardModifiers(QtKeyboardModifiers modifiers)
{
    playPathKeyboardModifiers_ = convertKeyboardModifiers(modifiers);
}

void QGLViewer::setAddKeyFrameKeyboardModifiers(QtKeyboardModifiers modifiers)
{
    addKeyFrameKeyboardModifiers_ = convertKeyboardModifiers(modifiers);
}

QtKeyboardModifiers QGLViewer::addKeyFrameKeyboardModifiers() const
{
    return addKeyFrameKeyboardModifiers_;
}

QtKeyboardModifiers QGLViewer::playPathKeyboardModifiers() const
{
    return playPathKeyboardModifiers_;
}

#ifndef DOXYGEN
// Deprecated methods
QtKeyboardModifiers QGLViewer::addKeyFrameStateKey() const
{
    qWarning("addKeyFrameStateKey has been renamed addKeyFrameKeyboardModifiers");
    return addKeyFrameKeyboardModifiers(); }

QtKeyboardModifiers QGLViewer::playPathStateKey() const
{
    qWarning("playPathStateKey has been renamed playPathKeyboardModifiers");
    return playPathKeyboardModifiers();
}

void QGLViewer::setAddKeyFrameStateKey(int buttonState)
{
    qWarning("setAddKeyFrameStateKey has been renamed setAddKeyFrameKeyboardModifiers");
    setAddKeyFrameKeyboardModifiers(QtKeyboardModifiers(buttonState & Qt::KeyboardModifierMask));
}

void QGLViewer::setPlayPathStateKey(int buttonState)
{
    qWarning("setPlayPathStateKey has been renamed setPlayPathKeyboardModifiers");
    setPlayPathKeyboardModifiers(QtKeyboardModifiers(buttonState & Qt::KeyboardModifierMask));
}

Qt::Key QGLViewer::keyFrameKey(int index) const
{
    qWarning("keyFrameKey has been renamed pathKey.");
    return pathKey(index);
}

QtKeyboardModifiers QGLViewer::playKeyFramePathStateKey() const
{
    qWarning("playKeyFramePathStateKey has been renamed playPathKeyboardModifiers.");
    return playPathKeyboardModifiers();
}

void QGLViewer::setKeyFrameKey(int index, int key)
{
    qWarning("setKeyFrameKey is deprecated, use setPathKey instead, with swapped parameters.");
    setPathKey(key, index);
}

void QGLViewer::setPlayKeyFramePathStateKey(int buttonState)
{
    qWarning("setPlayKeyFramePathStateKey has been renamed setPlayPathKeyboardModifiers.");
    setPlayPathKeyboardModifiers(QtKeyboardModifiers(buttonState & Qt::KeyboardModifierMask));
}
#endif

//              M o u s e   b e h a v i o r   s t a t e   k e y s             //

void QGLViewer::setHandlerKeyboardModifiers(MouseHandler handler, QtKeyboardModifiers modifiers)
{
    QMap<int, MouseActionPrivate> newMouseBinding;
    QMap<QtKeyboardModifiers, MouseActionPrivate> newWheelBinding;
    QMap<ClickActionPrivate, ClickAction> newClickBinding_;

    QMap<int, MouseActionPrivate>::Iterator mit;
    QMap<QtKeyboardModifiers, MouseActionPrivate>::Iterator wit;

    // First copy unchanged bindings.
    for (mit = mouseBinding_.begin(); mit != mouseBinding_.end(); ++mit)
        if ((mit.value().handler != handler) || (mit.value().action == ZOOM_ON_REGION))
            newMouseBinding[mit.key()] = mit.value();

    for (wit = wheelBinding_.begin(); wit != wheelBinding_.end(); ++wit)
        if (wit.value().handler != handler)
            newWheelBinding[wit.key()] = wit.value();

    // Then, add modified bindings, that can overwrite the previous ones.
    modifiers = convertKeyboardModifiers(modifiers);
    for (mit = mouseBinding_.begin(); mit != mouseBinding_.end(); ++mit)
        if ((mit.value().handler == handler) && (mit.value().action != ZOOM_ON_REGION))
        {
            int newState = modifiers | (mit.key() & Qt::MouseButtonMask);
            newMouseBinding[newState] = mit.value();
        }

        for (wit = wheelBinding_.begin(); wit != wheelBinding_.end(); ++wit)
            if (wit.value().handler == handler)
            {
                QtKeyboardModifiers newState = modifiers;
                newWheelBinding[newState] = wit.value();
            }

            // Same for button bindings
            for (QMap<ClickActionPrivate, ClickAction>::ConstIterator cb=clickBinding_.begin(), end=clickBinding_.end(); cb != end; ++cb)
                if (((handler==CAMERA) && ((cb.value() == CENTER_SCENE) || (cb.value() == ALIGN_CAMERA))) ||
                    ((handler==FRAME)  && ((cb.value() == CENTER_FRAME) || (cb.value() == ALIGN_FRAME))))
                {
                    ClickActionPrivate cap;
                    cap.modifiers = modifiers;
                    cap.button = cb.key().button;
                    cap.doubleClick = cb.key().doubleClick;
                    cap.buttonsBefore = cb.key().buttonsBefore;
                    newClickBinding_[cap] = cb.value();
                }
                else
                    newClickBinding_[cb.key()] = cb.value();

            mouseBinding_ = newMouseBinding;
            wheelBinding_ = newWheelBinding;
            clickBinding_ = newClickBinding_;
}


#ifndef DOXYGEN
void QGLViewer::setHandlerStateKey(MouseHandler handler, int buttonState)
{
    qWarning("setHandlerStateKey has been renamed setHandlerKeyboardModifiers");
    setHandlerKeyboardModifiers(handler, QtKeyboardModifiers(buttonState & Qt::KeyboardModifierMask));
}

void QGLViewer::setMouseStateKey(MouseHandler handler, int buttonState)
{
    qWarning("setMouseStateKey has been renamed setHandlerKeyboardModifiers.");
    setHandlerKeyboardModifiers(handler, QtKeyboardModifiers(buttonState & Qt::KeyboardModifierMask));
}
#endif

void QGLViewer::setMouseBinding(int state, MouseHandler handler, MouseAction action, bool withConstraint)
{
    if ((handler == FRAME) && ((action == MOVE_FORWARD) || (action == MOVE_BACKWARD) ||
        (action == ROLL) || (action == LOOK_AROUND) ||
        (action == ZOOM_ON_REGION)))
    {
#if QT_VERSION >= 0x040000
        qWarning("Cannot bind %s to FRAME", mouseActionString(action).toLatin1().constData());
#else
        qWarning("Cannot bind %s to FRAME", mouseActionString(action).latin1());
#endif
    }
    else
        if ((state & Qt::MouseButtonMask) == 0)
            qWarning("No mouse button specified in setMouseBinding");
        else
        {
            MouseActionPrivate map;
            map.handler = handler;
            map.action = action;
            map.withConstraint = withConstraint;
            state = convertToKeyboardModifiers(state);

            mouseBinding_.remove(state);

            if (action != NO_MOUSE_ACTION)
                mouseBinding_.insert(state, map);

            ClickActionPrivate cap;
            cap.modifiers = QtKeyboardModifiers(state & Qt::KeyboardModifierMask);
            cap.button = QtMouseButtons(state & Qt::MouseButtonMask);
            cap.doubleClick = false;
            cap.buttonsBefore = Qt::NoButton;
            clickBinding_.remove(cap);
        }
}

void QGLViewer::setMouseBinding(int state, ClickAction action, bool doubleClick, QtMouseButtons buttonsBefore)
{
    if ((buttonsBefore != Qt::NoButton) && !doubleClick)
        qWarning("Buttons before is only meaningful when doubleClick is true in setMouseBinding().");
    else
        if ((state & Qt::MouseButtonMask) == 0)
            qWarning("No mouse button specified in setMouseBinding");
        else
        {
            ClickActionPrivate cap;
            state = convertToKeyboardModifiers(state);
            cap.modifiers = QtKeyboardModifiers(state & Qt::KeyboardModifierMask);
            cap.button = QtMouseButtons(state & Qt::MouseButtonMask);
            cap.doubleClick = doubleClick;
            cap.buttonsBefore = buttonsBefore;
            clickBinding_.remove(cap);

            // #CONNECTION performClickAction comment on NO_CLICK_ACTION
            if (action != NO_CLICK_ACTION)
                clickBinding_.insert(cap, action);

            if ((!doubleClick) && (buttonsBefore == Qt::NoButton))
                mouseBinding_.remove(state);
        }
}

void QGLViewer::setWheelBinding(QtKeyboardModifiers modifiers, MouseHandler handler, MouseAction action, bool withConstraint)
{
    //#CONNECTION# ManipulatedFrame::wheelEvent and ManipulatedCameraFrame::wheelEvent switches
    if ((action != ZOOM) && (action != MOVE_FORWARD) && (action != MOVE_BACKWARD) && (action != NO_MOUSE_ACTION))
#if QT_VERSION >= 0x040000
        qWarning("Cannot bind %s to wheel", mouseActionString(action).toLatin1().constData());
#else
        qWarning("Cannot bind %s to wheel",  + mouseActionString(action).latin1());
#endif
    else
        if ((handler == FRAME) && (action != ZOOM) && (action != NO_MOUSE_ACTION))
#if QT_VERSION >= 0x040000
            qWarning("Cannot bind %s to FRAME wheel", mouseActionString(action).toLatin1().constData());
#else
            qWarning("Cannot bind %s to FRAME wheel", mouseActionString(action).latin1());
#endif
        else
        {
            MouseActionPrivate map;
            map.handler = handler;
            map.action  = action;
            map.withConstraint = withConstraint;
            modifiers = convertKeyboardModifiers(modifiers);
            wheelBinding_.remove(modifiers);

            if (action != NO_MOUSE_ACTION)
                wheelBinding_.insert(modifiers, map);
        }
}

QGLViewer::MouseAction QGLViewer::mouseAction(int state) const
{
    state = convertToKeyboardModifiers(state);
    if (mouseBinding_.contains(state))
        return mouseBinding_[state].action;
    else
        return NO_MOUSE_ACTION;
}

int QGLViewer::mouseHandler(int state) const
{
    state = convertToKeyboardModifiers(state);
    if (mouseBinding_.contains(state))
        return mouseBinding_[state].handler;
    else
        return -1;
}

int QGLViewer::mouseButtonState(MouseHandler handler, MouseAction action, bool withConstraint) const
{
    for (QMap<int, MouseActionPrivate>::ConstIterator it=mouseBinding_.begin(), end=mouseBinding_.end(); it != end; ++it)
        if ( (it.value().handler == handler) && (it.value().action == action) && (it.value().withConstraint == withConstraint) )
            return it.key();

    return Qt::NoButton;
}

QGLViewer::MouseAction QGLViewer::wheelAction(QtKeyboardModifiers modifiers) const
{
    modifiers = convertKeyboardModifiers(modifiers);
    if (wheelBinding_.contains(modifiers))
        return wheelBinding_[modifiers].action;
    else
        return NO_MOUSE_ACTION;
}

int QGLViewer::wheelHandler(QtKeyboardModifiers modifiers) const
{
    modifiers = convertKeyboardModifiers(modifiers);
    if (wheelBinding_.contains(modifiers))
        return wheelBinding_[modifiers].handler;
    else
        return -1;
}

int QGLViewer::wheelButtonState(MouseHandler handler, MouseAction action, bool withConstraint) const
{
    for (QMap<QtKeyboardModifiers, MouseActionPrivate>::ConstIterator it=wheelBinding_.begin(), end=wheelBinding_.end(); it!=end; ++it)
        if ( (it.value().handler == handler) && (it.value().action == action) && (it.value().withConstraint == withConstraint) )
            return it.key();

    return -1;
}

QGLViewer::ClickAction QGLViewer::clickAction(int state, bool doubleClick, QtMouseButtons buttonsBefore) const
{
    ClickActionPrivate cap;
    cap.modifiers = QtKeyboardModifiers(convertToKeyboardModifiers(state) & Qt::KeyboardModifierMask);
    cap.button = QtMouseButtons(state & Qt::MouseButtonMask);
    cap.doubleClick = doubleClick;
    cap.buttonsBefore = buttonsBefore;
    if (clickBinding_.contains(cap))
        return clickBinding_[cap];
    else
        return NO_CLICK_ACTION;
}

void QGLViewer::getClickButtonState(ClickAction ca, int& state, bool& doubleClick, QtMouseButtons& buttonsBefore) const
{
    for (QMap<ClickActionPrivate, ClickAction>::ConstIterator it=clickBinding_.begin(), end=clickBinding_.end(); it != end; ++it)
        if (it.value() == ca)
        {
            state = it.key().modifiers | it.key().button;
            doubleClick = it.key().doubleClick;
            buttonsBefore = it.key().buttonsBefore;
            return;
        }

        state = Qt::NoButton;
}

bool QGLViewer::cameraIsInRevolveMode() const
{
    //#CONNECTION# used in toggleCameraMode() and keyboardString()
    return mouseButtonState(CAMERA, ROTATE) != Qt::NoButton;
}

void QGLViewer::toggleCameraMode()
{
    bool revolveMode = cameraIsInRevolveMode();
    int bs;
    if (revolveMode)
        bs = mouseButtonState(CAMERA, ROTATE);
    else
        bs = mouseButtonState(CAMERA, MOVE_FORWARD);
    QtKeyboardModifiers modifiers = QtKeyboardModifiers(bs & Qt::KeyboardModifierMask);

    //#CONNECTION# setDefaultMouseBindings()
    if (revolveMode)
    {
        camera()->frame()->updateFlyUpVector();
        camera()->frame()->stopSpinning();

        setMouseBinding(modifiers | Qt::LeftButton,  CAMERA, MOVE_FORWARD);
        setMouseBinding(modifiers | Qt::MidButton,   CAMERA, LOOK_AROUND);
        setMouseBinding(modifiers | Qt::RightButton, CAMERA, MOVE_BACKWARD);

        setMouseBinding(modifiers | Qt::LeftButton  | Qt::MidButton,  CAMERA, ROLL);
        // 2.2.4 setMouseBinding(modifiers | Qt::RightButton | Qt::MidButton,  CAMERA, SCREEN_TRANSLATE);

        setMouseBinding(Qt::LeftButton,  NO_CLICK_ACTION, true);
        setMouseBinding(Qt::MidButton,   NO_CLICK_ACTION, true);
        setMouseBinding(Qt::RightButton, NO_CLICK_ACTION, true);

        setWheelBinding(modifiers, CAMERA, MOVE_FORWARD);
    }
    else
    {
        // Should stop flyTimer. But unlikely and not easy.
        setMouseBinding(modifiers | Qt::LeftButton,  CAMERA, ROTATE);
        setMouseBinding(modifiers | Qt::MidButton,   CAMERA, ZOOM);
        setMouseBinding(modifiers | Qt::RightButton, CAMERA, TRANSLATE);

        setMouseBinding(modifiers | Qt::LeftButton  | Qt::MidButton,  CAMERA, SCREEN_ROTATE);
        // 2.2.4 setMouseBinding(modifiers | Qt::RightButton | Qt::MidButton,  CAMERA, SCREEN_TRANSLATE);

        setMouseBinding(Qt::LeftButton,  ALIGN_CAMERA,      true);
        setMouseBinding(Qt::MidButton,   SHOW_ENTIRE_SCENE, true);
        setMouseBinding(Qt::RightButton, CENTER_SCENE,      true);

        setWheelBinding(modifiers, CAMERA, ZOOM);
    }
}

//              M a n i p u l a t e d   f r a m e s                           //

void QGLViewer::setManipulatedFrame(ManipulatedFrame* frame)
{
    if (manipulatedFrame())
    {
        manipulatedFrame()->stopSpinning();

        if (manipulatedFrame() != camera()->frame())
        {
            disconnect(manipulatedFrame(), SIGNAL(manipulated()), this, SLOT(updateGL()));
            disconnect(manipulatedFrame(), SIGNAL(spun()), this, SLOT(updateGL()));
        }
    }

    manipulatedFrame_ = frame;

    manipulatedFrameIsACamera_ = ((manipulatedFrame() != camera()->frame()) &&
        (dynamic_cast<ManipulatedCameraFrame*>(manipulatedFrame()) != NULL));

    if (manipulatedFrame())
    {
        // Prevent multiple connections, that would result in useless display updates
        if (manipulatedFrame() != camera()->frame())
        {
            connect(manipulatedFrame(), SIGNAL(manipulated()), SLOT(updateGL()));
            connect(manipulatedFrame(), SIGNAL(spun()), SLOT(updateGL()));
        }
    }
}

#ifndef DOXYGEN

//                          V i s u a l   H i n t s                           //

void QGLViewer::drawVisualHints()
{
    // Revolve Around point cross
    if (visualHint_ & 1)
    {
        const float size = 15.0;
        Vec proj = camera()->projectedCoordinatesOf(camera()->revolveAroundPoint());
        startScreenCoordinatesSystem();
        glDisable(GL_LIGHTING);
        glDisable(GL_DEPTH_TEST);
        glLineWidth(3.0);
        glBegin(GL_LINES);
        glVertex2f(proj.x - size, proj.y);
        glVertex2f(proj.x + size, proj.y);
        glVertex2f(proj.x, proj.y - size);
        glVertex2f(proj.x, proj.y + size);
        glEnd();
        glEnable(GL_DEPTH_TEST);
        stopScreenCoordinatesSystem();
    }

    // if (visualHint_ & 2)
    // drawText(80, 10, "Play");

    // Screen rotate line
    ManipulatedFrame* mf = NULL;
    Vec pnt;
    if (camera()->frame()->action_ == SCREEN_ROTATE)
    {
        mf = camera()->frame();
        pnt = camera()->revolveAroundPoint();
    }
    if (manipulatedFrame() && (manipulatedFrame()->action_ == SCREEN_ROTATE))
    {
        mf = manipulatedFrame();
        // Maybe useful if the mf is a manipCameraFrame...
        // pnt = manipulatedFrame()->revolveAroundPoint();
        pnt = manipulatedFrame()->position();
    }

    if (mf)
    {
        pnt = camera()->projectedCoordinatesOf(pnt);
        startScreenCoordinatesSystem();
        glDisable(GL_LIGHTING);
        glDisable(GL_DEPTH_TEST);
        glLineWidth(3.0);
        glBegin(GL_LINES);
        glVertex2f(pnt.x, pnt.y);
        glVertex2f(mf->prevPos_.x(), mf->prevPos_.y());
        glEnd();
        glEnable(GL_DEPTH_TEST);
        stopScreenCoordinatesSystem();
    }

    // Zoom on region: draw a rectangle
    if (camera()->frame()->action_ == ZOOM_ON_REGION)
    {
        startScreenCoordinatesSystem();
        glDisable(GL_LIGHTING);
        glDisable(GL_DEPTH_TEST);
        glLineWidth(2.0);
        glBegin(GL_LINE_LOOP);
        glVertex2i(camera()->frame()->pressPos_.x(), camera()->frame()->pressPos_.y());
        glVertex2i(camera()->frame()->prevPos_.x(),  camera()->frame()->pressPos_.y());
        glVertex2i(camera()->frame()->prevPos_.x(),  camera()->frame()->prevPos_.y());
        glVertex2i(camera()->frame()->pressPos_.x(), camera()->frame()->prevPos_.y());
        glEnd();
        glEnable(GL_DEPTH_TEST);
        stopScreenCoordinatesSystem();
    }
}

void QGLViewer::setVisualHintsMask(int mask, int delay)
{
    visualHint_ = visualHint_ | mask;
    QTimer::singleShot(delay, this, SLOT(resetVisualHints()));
}

void QGLViewer::resetVisualHints()
{
    visualHint_ = 0;
}
#endif

//       A x i s   a n d   G r i d   d i s p l a y   l i s t s                //

void QGLViewer::drawArrow(float length, float radius, int nbSubdivisions)
{
    static GLUquadric* quadric = gluNewQuadric();

    if (radius < 0.0)
        radius = 0.05 * length;

    const float head = 2.5*(radius / length) + 0.1;
    const float coneRadiusCoef = 4.0 - 5.0 * head;

    gluCylinder(quadric, radius, radius, length * (1.0 - head/coneRadiusCoef), nbSubdivisions, 1);
    glTranslatef(0.0, 0.0, length * (1.0 - head));
    gluCylinder(quadric, coneRadiusCoef * radius, 0.0, head * length, nbSubdivisions, 1);
    glTranslatef(0.0, 0.0, -length * (1.0 - head));
}

void QGLViewer::drawArrow(const Vec& from, const Vec& to, float radius, int nbSubdivisions)
{
    glPushMatrix();
    glTranslatef(from[0],from[1],from[2]);
    const Vec dir = to-from;
    glMultMatrixd(Quaternion(Vec(0,0,1), dir).matrix());
    QGLViewer::drawArrow(dir.norm(), radius, nbSubdivisions);
    glPopMatrix();
}

void QGLViewer::drawAxis(float length)
{
    const float charWidth = length / 40.0;
    const float charHeight = length / 30.0;
    const float charShift = 1.04 * length;

    GLboolean lighting, colorMaterial;
    glGetBooleanv(GL_LIGHTING, &lighting);
    glGetBooleanv(GL_COLOR_MATERIAL, &colorMaterial);

    glDisable(GL_LIGHTING);

    glBegin(GL_LINES);
    // The X
    glVertex3f(charShift,  charWidth, -charHeight);
    glVertex3f(charShift, -charWidth,  charHeight);
    glVertex3f(charShift, -charWidth, -charHeight);
    glVertex3f(charShift,  charWidth,  charHeight);
    // The Y
    glVertex3f( charWidth, charShift, charHeight);
    glVertex3f(0.0,        charShift, 0.0);
    glVertex3f(-charWidth, charShift, charHeight);
    glVertex3f(0.0,        charShift, 0.0);
    glVertex3f(0.0,        charShift, 0.0);
    glVertex3f(0.0,        charShift, -charHeight);
    // The Z
    glVertex3f(-charWidth,  charHeight, charShift);
    glVertex3f( charWidth,  charHeight, charShift);
    glVertex3f( charWidth,  charHeight, charShift);
    glVertex3f(-charWidth, -charHeight, charShift);
    glVertex3f(-charWidth, -charHeight, charShift);
    glVertex3f( charWidth, -charHeight, charShift);
    glEnd();

    glEnable(GL_LIGHTING);
    glDisable(GL_COLOR_MATERIAL);

    float color[4];
    color[0] = 0.7f;  color[1] = 0.7f;  color[2] = 1.0f;  color[3] = 1.0f;
    glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color);
    QGLViewer::drawArrow(length, 0.01*length);

    color[0] = 1.0f;  color[1] = 0.7f;  color[2] = 0.7f;  color[3] = 1.0f;
    glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color);
    glPushMatrix();
    glRotatef(90.0, 0.0, 1.0, 0.0);
    QGLViewer::drawArrow(length, 0.01*length);
    glPopMatrix();

    color[0] = 0.7f;  color[1] = 1.0f;  color[2] = 0.7f;  color[3] = 1.0f;
    glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color);
    glPushMatrix();
    glRotatef(-90.0, 1.0, 0.0, 0.0);
    QGLViewer::drawArrow(length, 0.01*length);
    glPopMatrix();

    if (colorMaterial)
        glEnable(GL_COLOR_MATERIAL);
    if (!lighting)
        glDisable(GL_LIGHTING);
}

void QGLViewer::drawGrid(float size, int nbSubdivisions)
{
    GLboolean lighting;
    glGetBooleanv(GL_LIGHTING, &lighting);

    glDisable(GL_LIGHTING);

    glBegin(GL_LINES);
    for (int i=0; i<=nbSubdivisions; ++i)
    {
        const float pos = size*(2.0*i/nbSubdivisions-1.0);
        glVertex2f(pos, -size);
        glVertex2f(pos, +size);
        glVertex2f(-size, pos);
        glVertex2f( size, pos);
    }
    glEnd();

    if (lighting)
        glEnable(GL_LIGHTING);
}

//       S t a t i c    m e t h o d s   :  Q G L V i e w e r   P o o l        //

void QGLViewer::saveStateToFileForAllViewers()
{
#if QT_VERSION >= 0x040000
    Q_FOREACH (QGLViewer* viewer, QGLViewer::QGLViewerPool())
    {
#else
    QPtrListIterator<QGLViewer> it(QGLViewer::QGLViewerPool());
    for (QGLViewer* viewer; (viewer = it.current()) != 0; ++it)
    {
#endif
        if (viewer)
            viewer->saveStateToFile();
    }
}

//       S a v e   s t a t e   b e t w e e n    s e s s i o n s         //

QString QGLViewer::stateFileName() const
{
    QString name = stateFileName_;

    if (!name.isEmpty() && QGLViewer::QGLViewerIndex(this) > 0)
    {
        QFileInfo fi(name);
#if QT_VERSION >= 0x040000
        if (fi.suffix().isEmpty())
#else
        if (fi.extension(false).isEmpty())
#endif
            name += QString::number(QGLViewer::QGLViewerIndex(this));
        else
#if QT_VERSION >= 0x040000
            name = fi.absolutePath() + '/' + fi.completeBaseName() + QString::number(QGLViewer::QGLViewerIndex(this)) + "." + fi.suffix();
#else
# if QT_VERSION >= 0x030000
            name = fi.dirPath() + '/' + fi.baseName(true) + QString::number(QGLViewer::QGLViewerIndex(this)) + "." + fi.extension(false);
# else
            name = fi.dirPath() + '/' + fi.baseName() + QString::number(QGLViewer::QGLViewerIndex(this)) + "." + fi.extension();
# endif
#endif
    }

    return name;
}

void QGLViewer::saveStateToFile()
{
    QString name = stateFileName();

    if (name.isEmpty())
        return;

    QFileInfo fileInfo(name);

    if (fileInfo.isDir())
    {
        QMessageBox::warning(this, tr("Save to file error", "Message box window title"), tr("State file name (%1) references a directory instead of a file.").arg(name));
        return;
    }

#if QT_VERSION >= 0x040000
    const QString dirName = fileInfo.absolutePath();
#else
    const QString dirName = fileInfo.dirPath();
#endif
    if (!QFileInfo(dirName).exists())
    {
        QDir dir;
#if QT_VERSION >= 0x040000
        if (!(dir.mkdir(dirName)))
#else
        if (!(dir.mkdir(dirName, true)))
#endif
        {
            QMessageBox::warning(this, tr("Save to file error", "Message box window title"), tr("Unable to create directory %1").arg(dirName));
            return;
        }
    }

    // Write the DOM tree to file
    QFile f(name);
#if QT_VERSION >= 0x040000
    if (f.open(QIODevice::WriteOnly))
#else
    if (f.open(IO_WriteOnly))
#endif
    {
        QTextStream out(&f);
        QDomDocument doc("QGLVIEWER");
        doc.appendChild(domElement("QGLViewer", doc));
        doc.save(out, 2);
        f.flush();
        f.close();
    }
    else
#if QT_VERSION < 0x030200
        QMessageBox::warning(this, tr("Save to file error", "Message box window title"), tr("Unable to save to file %1").arg(name));
#else
        QMessageBox::warning(this, tr("Save to file error", "Message box window title"), tr("Unable to save to file %1").arg(name) + ":\n" + f.errorString());
#endif
}

bool QGLViewer::restoreStateFromFile()
{
    QString name = stateFileName();

    if (name.isEmpty())
        return false;

    QFileInfo fileInfo(name);

    if (!fileInfo.isFile())
        // No warning since it would be displayed at first start.
        return false;

    if (!fileInfo.isReadable())
    {
        QMessageBox::warning(this, tr("Problem in state restoration", "Message box window title"), tr("File %1 is not readable.").arg(name));
        return false;
    }

    // Read the DOM tree form file
    QFile f(name);
#if QT_VERSION >= 0x040000
    if (f.open(QIODevice::ReadOnly) == true)
#else
    if (f.open(IO_ReadOnly) == true)
#endif
    {
        QDomDocument doc;
        doc.setContent(&f);
        f.close();
        QDomElement main = doc.documentElement();
        initFromDOMElement(main);
    }
    else
    {
#if QT_VERSION < 0x030200
        QMessageBox::warning(this, tr("Open file error", "Message box window title"), tr("Unable to open file %1").arg(name));
#else
        QMessageBox::warning(this, tr("Open file error", "Message box window title"), tr("Unable to open file %1").arg(name) + ":\n" + f.errorString());
#endif
        return false;
    }

    return true;
}

QDomElement QGLViewer::domElement(const QString& name, QDomDocument& document) const
{
    QDomElement de = document.createElement(name);
    de.setAttribute("version", QGLViewerVersionString());

    QDomElement stateNode = document.createElement("State");
    // stateNode.setAttribute("mouseTracking", (hasMouseTracking()?"true":"false"));
    stateNode.appendChild(DomUtils::QColorDomElement(foregroundColor(), "foregroundColor", document));
    stateNode.appendChild(DomUtils::QColorDomElement(backgroundColor(), "backgroundColor", document));
    stateNode.setAttribute("stereo", (displaysInStereo()?"true":"false"));
    stateNode.setAttribute("cameraMode", (cameraIsInRevolveMode()?"revolve":"fly"));
    de.appendChild(stateNode);

    QDomElement displayNode = document.createElement("Display");
    displayNode.setAttribute("axisIsDrawn",       (axisIsDrawn()?"true":"false"));
    displayNode.setAttribute("gridIsDrawn",       (gridIsDrawn()?"true":"false"));
    displayNode.setAttribute("FPSIsDisplayed",    (FPSIsDisplayed()?"true":"false"));
    displayNode.setAttribute("cameraIsEdited",    (cameraIsEdited()?"true":"false"));
    // displayNode.setAttribute("textIsEnabled",  (textIsEnabled()?"true":"false"));
    de.appendChild(displayNode);

    QDomElement geometryNode = document.createElement("Geometry");
    geometryNode.setAttribute("fullScreen", (isFullScreen()?"true":"false"));
    if (isFullScreen())
    {
        geometryNode.setAttribute("prevPosX", QString::number(prevPos_.x()));
        geometryNode.setAttribute("prevPosY", QString::number(prevPos_.y()));
    }
    else
    {
        QWidget* tlw = topLevelWidget();
        geometryNode.setAttribute("width",  QString::number(tlw->width()));
        geometryNode.setAttribute("height", QString::number(tlw->height()));
        geometryNode.setAttribute("posX",   QString::number(tlw->pos().x()));
        geometryNode.setAttribute("posY",   QString::number(tlw->pos().y()));
    }
    de.appendChild(geometryNode);

    // Restore original Camera zClippingCoefficient before saving.
    if (cameraIsEdited())
        camera()->setZClippingCoefficient(previousCameraZClippingCoefficient_);
    de.appendChild(camera()->domElement("Camera", document));
    if (cameraIsEdited())
        // #CONNECTION# 5.0 from setCameraIsEdited()
        camera()->setZClippingCoefficient(5.0);

    if (manipulatedFrame())
        de.appendChild(manipulatedFrame()->domElement("ManipulatedFrame", document));

    return de;
}

void QGLViewer::initFromDOMElement(const QDomElement& element)
{
    const QString version = element.attribute("version");
    // if (version != QGLViewerVersionString())
    if (version[0] != '2')
        // Patches for previous versions should go here when the state file syntax is modified.
#if QT_VERSION >= 0x040000
        qWarning("State file created using QGLViewer version %s may not be correctly read.", version.toLatin1().constData());
#else
        qWarning("State file created using QGLViewer version %s may not be correctly read.", version.latin1());
#endif

    QDomElement child=element.firstChild().toElement();
    bool tmpCameraIsEdited = cameraIsEdited();
    while (!child.isNull())
    {
        if (child.tagName() == "State")
        {
            // #CONNECTION# default values from defaultConstructor()
            // setMouseTracking(DomUtils::boolFromDom(child, "mouseTracking", false));
            setStereoDisplay(DomUtils::boolFromDom(child, "stereo", false));
            if ((child.attribute("cameraMode", "revolve") == "fly") && (cameraIsInRevolveMode()))
                toggleCameraMode();

            QDomElement ch=child.firstChild().toElement();
            while (!ch.isNull())
            {
                if (ch.tagName() == "foregroundColor")
                    setForegroundColor(DomUtils::QColorFromDom(ch));
                if (ch.tagName() == "backgroundColor")
                    setBackgroundColor(DomUtils::QColorFromDom(ch));
                ch = ch.nextSibling().toElement();
            }
        }

        if (child.tagName() == "Display")
        {
            // #CONNECTION# default values from defaultConstructor()
            setAxisIsDrawn(DomUtils::boolFromDom(child, "axisIsDrawn", false));
            setGridIsDrawn(DomUtils::boolFromDom(child, "gridIsDrawn", false));
            setFPSIsDisplayed(DomUtils::boolFromDom(child, "FPSIsDisplayed", false));
            // See comment below.
            tmpCameraIsEdited = DomUtils::boolFromDom(child, "cameraIsEdited", false);
            // setTextIsEnabled(DomUtils::boolFromDom(child, "textIsEnabled", true));
        }

        if (child.tagName() == "Geometry")
        {
            setFullScreen(DomUtils::boolFromDom(child, "fullScreen", false));

            if (isFullScreen())
            {
                prevPos_.setX(DomUtils::intFromDom(child, "prevPosX", 0));
                prevPos_.setY(DomUtils::intFromDom(child, "prevPosY", 0));
            }
            else
            {
                int width  = DomUtils::intFromDom(child, "width",  600);
                int height = DomUtils::intFromDom(child, "height", 400);
                topLevelWidget()->resize(width, height);
                camera()->setScreenWidthAndHeight(this->width(), this->height());

                QPoint pos;
                pos.setX(DomUtils::intFromDom(child, "posX", 0));
                pos.setY(DomUtils::intFromDom(child, "posY", 0));
                topLevelWidget()->move(pos);
            }
        }

        if (child.tagName() == "Camera")
        {
            connectAllCameraKFIInterpolatedSignals(false);
            camera()->initFromDOMElement(child);
            connectAllCameraKFIInterpolatedSignals();
        }

        if ((child.tagName() == "ManipulatedFrame") && (manipulatedFrame()))
            manipulatedFrame()->initFromDOMElement(child);

        child = child.nextSibling().toElement();
    }

    // The Camera always stores its "real" zClippingCoef in domElement(). If it is edited,
    // its "real" coef must be saved and the coef set to 5.0, as is done in setCameraIsEdited().
    // BUT : Camera and Display are read in an arbitrary order. We must initialize Camera's
    // "real" coef BEFORE calling setCameraIsEdited. Hence this temp cameraIsEdited and delayed call
    cameraIsEdited_ = tmpCameraIsEdited;
    if (cameraIsEdited_)
    {
        previousCameraZClippingCoefficient_ = camera()->zClippingCoefficient();
        // #CONNECTION# 5.0 from setCameraIsEdited.
        camera()->setZClippingCoefficient(5.0);
    }
}

#ifndef DOXYGEN

void QGLViewer::saveToFile(const QString& fileName)
{
    if (!fileName.isEmpty())
        setStateFileName(fileName);

    qWarning("saveToFile() is deprecated, use saveStateToFile() instead.");
    saveStateToFile();
}

bool QGLViewer::restoreFromFile(const QString& fileName)
{
    if (!fileName.isEmpty())
        setStateFileName(fileName);

    qWarning("restoreFromFile() is deprecated, use restoreStateFromFile() instead.");
    return restoreStateFromFile();
}
#endif

void QGLViewer::copyBufferToTexture(GLint internalFormat, GLenum format)
{
    int h = 16;
    int w = 16;
    // Todo compare performance with qt code.
    while (w < width())
        w <<= 1;
    while (h < height())
        h <<= 1;

    bool init = false;

    if ((w != bufferTextureWidth_) || (h != bufferTextureHeight_))
    {
        bufferTextureWidth_ = w;
        bufferTextureHeight_ = h;
        bufferTextureMaxU_ = width()  / float(bufferTextureWidth_);
        bufferTextureMaxV_ = height() / float(bufferTextureHeight_);
        init = true;
    }

    if (bufferTextureId() == 0)
    {
        glGenTextures(1, &bufferTextureId_);
        glBindTexture(GL_TEXTURE_2D, bufferTextureId_);
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        init = true;
    }
    else
        glBindTexture(GL_TEXTURE_2D, bufferTextureId_);

    if ((format != previousBufferTextureFormat_) ||
        (internalFormat != previousBufferTextureInternalFormat_))
    {
        previousBufferTextureFormat_ = format;
        previousBufferTextureInternalFormat_ = internalFormat;
        init = true;
    }

    if (init)
    {
        if (format == GL_NONE)
            format = internalFormat;

        glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, bufferTextureWidth_, bufferTextureHeight_, 0, format, GL_UNSIGNED_BYTE, NULL);
    }

    glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, width(), height());
}

GLuint QGLViewer::bufferTextureId() const
{
    if (glIsTexture(bufferTextureId_))
        return bufferTextureId_;
    else
        return 0;
}