qglviewer.cpp

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

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

 This file is part of the QGLViewer library version 2.5.2.

 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"
#include "manipulatedCameraFrame.h"

# 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>

using namespace std;
using namespace qglviewer;

// Static private variable
QList<QGLViewer*> QGLViewer::QGLViewerPool_;


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

    int poolIndex = QGLViewer::QGLViewerPool_.indexOf(NULL);
    setFocusPolicy(Qt::StrongFocus);

    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 when setFullScreen(false) is called after setFullScreen(true)

    // #CONNECTION# default values in initFromDOMElement()
    manipulatedFrame_ = NULL;
    manipulatedFrameIsACamera_ = false;
    mouseGrabberIsAManipulatedFrame_ = false;
    mouseGrabberIsAManipulatedCameraFrame_ = false;
    displayMessage_ = false;
    connect(&messageTimer_, SIGNAL(timeout()), SLOT(hideMessage()));
    messageTimer_.setSingleShot(true);
    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);
    // Make sure move() is not called, which would call initializeGL()
    fullScreen_ = 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;
    currentlyPressedKey_ = Qt::Key(0);

    setAttribute(Qt::WA_NoSystemBackground);

    tileRegion_ = NULL;
}

#if !defined QT3_SUPPORT

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

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

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

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();

    QGLViewer::QGLViewerPool_.replace(QGLViewer::QGLViewerPool_.indexOf(this), NULL);

    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 Qt::KeyboardModifiers keyboardModifiersFromState(int state) {
    // Convertion of keyboard modifiers and mouse buttons as an int is no longer supported : emulate
    return Qt::KeyboardModifiers(state & 0xFF000000);
}


static Qt::MouseButton mouseButtonFromState(int state) {
    // Convertion of keyboard modifiers and mouse buttons as an int is no longer supported : emulate
    return Qt::MouseButton(state & 0xFFFF);
}

void QGLViewer::initializeGL()
{
    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()) );
}

void QGLViewer::paintGL()
{
    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();
    }
    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();

    // Pivot 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);

    update();
}

// 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 (observe 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);

    setAddKeyFrameKeyboardModifiers(Qt::AltModifier);
    setPlayPathKeyboardModifiers(Qt::NoModifier);
}

// M o u s e   b e h a v i o r
void QGLViewer::setDefaultMouseBindings()
{
    const Qt::KeyboardModifiers cameraKeyboardModifiers = Qt::NoModifier;
    const Qt::KeyboardModifiers frameKeyboardModifiers = Qt::ControlModifier;

    //#CONNECTION# toggleCameraMode()
    for (int handler=0; handler<2; ++handler)
    {
        MouseHandler mh = (MouseHandler)(handler);
        Qt::KeyboardModifiers modifiers = (mh == FRAME) ? frameKeyboardModifiers : cameraKeyboardModifiers;

        setMouseBinding(modifiers, Qt::LeftButton,  mh, ROTATE);
        setMouseBinding(modifiers, Qt::MidButton,   mh, ZOOM);
        setMouseBinding(modifiers, Qt::RightButton, mh, TRANSLATE);

        setMouseBinding(Qt::Key_R, modifiers, Qt::LeftButton, mh, SCREEN_ROTATE);

        setWheelBinding(modifiers, mh, ZOOM);
    }

    // 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);

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

    setMouseBinding(frameKeyboardModifiers, Qt::LeftButton, ALIGN_FRAME, true);
    // middle double click makes no sense for manipulated frame
    setMouseBinding(frameKeyboardModifiers, Qt::RightButton, CENTER_FRAME, true);

    // A c t i o n s   w i t h   k e y   m o d i f i e r s
    setMouseBinding(Qt::Key_Z, Qt::NoModifier, Qt::LeftButton, ZOOM_ON_PIXEL);
    setMouseBinding(Qt::Key_Z, Qt::NoModifier, Qt::RightButton, ZOOM_TO_FIT);

#ifdef Q_OS_MAC
    // Specific Mac bindings for touchpads. Double finger emulates a wheelEvent which zooms.
    // There is no right button available : make Option key + left emulate the right button.
    // A Control+Left indeed emulates a right click (OS X system configuration), but it does
    // no seem to support dragging.
    // Done at the end to override previous settings.
    const Qt::KeyboardModifiers macKeyboardModifiers = Qt::AltModifier;

    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);
#endif
}

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

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

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

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

    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(update()));
        else
            disconnect(camera()->keyFrameInterpolator(it.key()), SIGNAL(interpolated()), this, SLOT(update()));
    }

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

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 (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);
}

void QGLViewer::displayMessage(const QString& message, int delay)
{
    message_ = message;
    displayMessage_ = true;
    // Was set to single shot in defaultConstructor.
    messageTimer_.start(delay);
    if (textIsEnabled())
        update();
}

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


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();
        update();
    }
}

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()];
}

static QString mouseButtonsString(Qt::MouseButtons 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;
}

void QGLViewer::performClickAction(ClickAction ca, const QMouseEvent* const e)
{
    // Note: action that need it should call update().
    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);
            update();
            break;
        case RAP_FROM_PIXEL :
            if (! camera()->setPivotPointFromPixel(e->pos()))
                camera()->setPivotPoint(sceneCenter());
            setVisualHintsMask(1);
            update();
            break;
        case RAP_IS_CENTER :
            camera()->setPivotPoint(sceneCenter());
            setVisualHintsMask(1);
            update();
            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 :
            Frame * frame = new Frame();
            frame->setTranslation(camera()->pivotPoint());
            camera()->frame()->alignWithFrame(frame, true);
            delete frame;
            break;
    }
}

void QGLViewer::mousePressEvent(QMouseEvent* e)
{
    //#CONNECTION# mouseDoubleClickEvent has the same structure
    //#CONNECTION# mouseString() concatenates bindings description in inverse order.
    ClickBindingPrivate cbp(e->modifiers(), e->button(), false, (Qt::MouseButtons)(e->buttons() & ~(e->button())), currentlyPressedKey_);

    if (clickBinding_.contains(cbp)) {
        performClickAction(clickBinding_[cbp], e);
    } else
        if (mouseGrabber())
        {
            if (mouseGrabberIsAManipulatedFrame_)
            {
                for (QMap<MouseBindingPrivate, MouseActionPrivate>::ConstIterator it=mouseBinding_.begin(), end=mouseBinding_.end(); it!=end; ++it)
                    if ((it.value().handler == FRAME) && (it.key().button == e->button()))
                    {
                        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());
            update();
        }
        else
        {
            //#CONNECTION# wheelEvent has the same structure
            const MouseBindingPrivate mbp(e->modifiers(), e->button(), currentlyPressedKey_);

            if (mouseBinding_.contains(mbp))
            {
                MouseActionPrivate map = mouseBinding_[mbp];
                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
                    update();
            }
            else
                e->ignore();
        }
}

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);
        update();
    }

    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)
                update();
        }
        else // !
            if ((manipulatedFrame()) && (manipulatedFrame()->isManipulated()))
                if (manipulatedFrameIsACamera_)
                    manipulatedFrame()->ManipulatedFrame::mouseMoveEvent(e, camera());
                else
                    manipulatedFrame()->mouseMoveEvent(e, camera());
            else
                if (hasMouseTracking())
                {
                    Q_FOREACH (MouseGrabber* mg, MouseGrabber::MouseGrabberPool())
                    {
                        mg->checkIfGrabsMouse(e->x(), e->y(), camera());
                        if (mg->grabsMouse())
                        {
                            setMouseGrabber(mg);
                            // Check that MouseGrabber is not disabled
                            if (mouseGrabber() == mg)
                            {
                                update();
                                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);
        // update();
    }
    else
        //#CONNECTION# mouseMoveEvent has the same structure
        if (camera()->frame()->isManipulated())
        {
            camera()->frame()->mouseReleaseEvent(e, camera());
        }
        else
            if ((manipulatedFrame()) && (manipulatedFrame()->isManipulated()))
            {
                if (manipulatedFrameIsACamera_)
                    manipulatedFrame()->ManipulatedFrame::mouseReleaseEvent(e, camera());
                else
                    manipulatedFrame()->mouseReleaseEvent(e, camera());
            }
            else
                e->ignore();

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

void QGLViewer::wheelEvent(QWheelEvent* e)
{
    if (mouseGrabber())
    {
        if (mouseGrabberIsAManipulatedFrame_)
        {
            for (QMap<WheelBindingPrivate, 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());
        update();
    }
    else
    {
        //#CONNECTION# mousePressEvent has the same structure
        WheelBindingPrivate wbp(e->modifiers(), currentlyPressedKey_);

        if (wheelBinding_.contains(wbp))
        {
            MouseActionPrivate map = wheelBinding_[wbp];
            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;
            }
        }
        else
            e->ignore();
    }
}

void QGLViewer::mouseDoubleClickEvent(QMouseEvent* e)
{
    //#CONNECTION# mousePressEvent has the same structure
    ClickBindingPrivate cbp(e->modifiers(), e->button(), true, (Qt::MouseButtons)(e->buttons() & ~(e->button())), currentlyPressedKey_);
    if (clickBinding_.contains(cbp))
        performClickAction(clickBinding_[cbp], e);
    else
        if (mouseGrabber())
            mouseGrabber()->mouseDoubleClickEvent(e, camera());
        else
            e->ignore();
}

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_);

        update();
    }
    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)
{
    if (fullScreen_ == fullScreen) return;

    fullScreen_ = fullScreen;

    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)];
}

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 pivot point", "RAP_FROM_PIXEL click action");
        case QGLViewer::RAP_IS_CENTER : return QGLViewer::tr("Resets pivot point", "RAP_IS_CENTER click action");
        case QGLViewer::CENTER_FRAME : return QGLViewer::tr("Centers manipulated 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 manipulated frame", "ALIGN_FRAME click action");
        case QGLViewer::ALIGN_CAMERA : return QGLViewer::tr("Aligns camera", "ALIGN_CAMERA click action");
    }
    return QString::null;
}

static QString keyString(int key)
{
# if QT_VERSION >= 0x040100
    return QKeySequence(key).toString(QKeySequence::NativeText);
# else
    return QString(QKeySequence(key));
# endif
}

QString QGLViewer::formatClickActionPrivate(ClickBindingPrivate cbp)
{
    bool buttonsBefore = cbp.buttonsBefore != Qt::NoButton;
    QString keyModifierString = keyString(cbp.modifiers + cbp.key);
    if (!keyModifierString.isEmpty()) {
#ifdef Q_OS_MAC
        // modifiers never has a '+' sign. Add one space to clearly separate modifiers (and possible key) from button
        keyModifierString += " ";
#else
        // modifiers might be of the form : 'S' or 'Ctrl+S' or 'Ctrl+'. For consistency, add an other '+' if needed, no spaces
        if (!keyModifierString.endsWith('+'))
            keyModifierString += "+";
#endif
    }

    return tr("%1%2%3%4%5%6", "Modifier / button or wheel / double click / with / button / pressed")
            .arg(keyModifierString)
            .arg(mouseButtonsString(cbp.button)+(cbp.button == Qt::NoButton ? tr("Wheel", "Mouse wheel") : ""))
            .arg(cbp.doubleClick ? tr(" double click", "Suffix after mouse button") : "")
            .arg(buttonsBefore ? tr(" with ", "As in : Left button with Ctrl pressed") : "")
            .arg(buttonsBefore ? mouseButtonsString(cbp.buttonsBefore) : "")
            .arg(buttonsBefore ? tr(" pressed", "As in : Left button with Ctrl pressed") : "");
}

bool QGLViewer::isValidShortcutKey(int key) {
    return (key >= Qt::Key_Any && key < Qt::Key_Escape) || (key >= Qt::Key_F1 && key <= Qt::Key_F35);
}

#ifndef DOXYGEN

void QGLViewer::setMouseBindingDescription(int state, QString description, bool doubleClick, Qt::MouseButtons buttonsBefore) {
    qWarning("setMouseBindingDescription(int state,...) is deprecated. Use the modifier/button equivalent");
    setMouseBindingDescription(keyboardModifiersFromState(state),
                               mouseButtonFromState(state),
                               description,
                               doubleClick,
                               buttonsBefore);
}
#endif

void QGLViewer::setMouseBindingDescription(Qt::KeyboardModifiers modifiers, Qt::MouseButton button, QString description, bool doubleClick, Qt::MouseButtons buttonsBefore)
{
    setMouseBindingDescription(Qt::Key(0), modifiers, button, description, doubleClick, buttonsBefore);
}

void QGLViewer::setMouseBindingDescription(Qt::Key key, Qt::KeyboardModifiers modifiers, Qt::MouseButton button, QString description, bool doubleClick, Qt::MouseButtons buttonsBefore)
{
    ClickBindingPrivate cbp(modifiers, button, doubleClick, buttonsBefore, key);

    if (description.isEmpty())
        mouseDescription_.remove(cbp);
    else
        mouseDescription_[cbp] = 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<ClickBindingPrivate, QString> mouseBinding;

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

    for (QMap<ClickBindingPrivate, 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());
    }

    // Optional 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<MouseBindingPrivate, MouseActionPrivate>::ConstIterator itmb=mouseBinding_.begin(), endmb=mouseBinding_.end();
         itmb != endmb; ++itmb)
    {
        ClickBindingPrivate cbp(itmb.key().modifiers, itmb.key().button, false, Qt::NoButton, itmb.key().key);

        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[cbp] = text;
    }

    for (QMap<WheelBindingPrivate, MouseActionPrivate>::ConstIterator itw=wheelBinding_.begin(), endw=wheelBinding_.end(); itw != endw; ++itw)
    {
        ClickBindingPrivate cbp(itw.key().modifiers, Qt::NoButton, false, Qt::NoButton, itw.key().key);

        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[cbp] = text;
    }

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

    for (QMap<ClickBindingPrivate, 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 (description.isEmpty())
        keyDescription_.remove(key);
    else
        keyDescription_[key] = description;
}

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

    QVector<int> keys;
    keys.reserve(pathIndex_.count());
    for (QMap<Qt::Key, int>::ConstIterator i = pathIndex_.begin(), endi=pathIndex_.end(); i != endi; ++i)
        keys.push_back(i.key());
    qSort(keys);

    QVector<int>::const_iterator it = keys.begin(), end = keys.end();
    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, unsigned int>::ConstIterator it=keyboardBinding_.begin(), end=keyboardBinding_.end(); it != end; ++it)
        if ((it.value() != 0) && ((!cameraIsInRotateMode()) || ((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 the %1 keys (noted <i>Fx</i> below):", "Help window key tab camera keys").arg(cpks) + "</td></tr>\n";
        text += tableLine(keyString(playPathKeyboardModifiers()) + "<i>" + QGLViewer::tr("Fx", "Generic function key (F1..F12)") + "</i>",
                          QGLViewer::tr("Plays path (or resets saved position)"));
        text += tableLine(keyString(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(keyString(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();
    helpWidget()->setCurrentIndex(3);
}


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);
        helpWidget()->setWindowTitle(tr("Help", "Help window title"));

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

            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));
            }
        }
    }

    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("2014").arg("http://www.libqglviewer.com") +
                        QString("</center>");
                break;
            default : break;
        }

        QTextEdit* textEdit = (QTextEdit*)(helpWidget()->widget(i));
        textEdit->setHtml(text);
        textEdit->setText(text);

        if (resize && (textEdit->height() > height))
            height = textEdit->height();
    }

    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());

    const Qt::KeyboardModifiers modifiers = e->modifiers();

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

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

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

            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(update()));
                        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(update()));
                    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;
            }
            update();
        } else {
            if (isValidShortcutKey(key)) currentlyPressedKey_ = key;
            e->ignore();
        }
}

void QGLViewer::keyReleaseEvent(QKeyEvent * e) {
    if (isValidShortcutKey(e->key())) currentlyPressedKey_ = Qt::Key(0);
}

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(cameraIsInRotateMode()?tr("Camera in observer 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)));
            update();
            break;
        case MOVE_CAMERA_RIGHT :
            camera()->frame()->translate(camera()->frame()->inverseTransformOf(Vec( 10.0*camera()->flySpeed(), 0.0, 0.0)));
            update();
            break;
        case MOVE_CAMERA_UP :
            camera()->frame()->translate(camera()->frame()->inverseTransformOf(Vec(0.0, 10.0*camera()->flySpeed(), 0.0)));
            update();
            break;
        case MOVE_CAMERA_DOWN :
            camera()->frame()->translate(camera()->frame()->inverseTransformOf(Vec(0.0, -10.0*camera()->flySpeed(), 0.0)));
            update();
            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, unsigned int key)
{
    keyboardBinding_[action] = key;
}

unsigned int QGLViewer::shortcut(KeyboardAction action) const
{
    if (keyboardBinding_.contains(action))
        return 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(Qt::KeyboardModifiers modifiers)
{
    playPathKeyboardModifiers_ = modifiers;
}

void QGLViewer::setAddKeyFrameKeyboardModifiers(Qt::KeyboardModifiers modifiers)
{
    addKeyFrameKeyboardModifiers_ = modifiers;
}

Qt::KeyboardModifiers QGLViewer::addKeyFrameKeyboardModifiers() const
{
    return addKeyFrameKeyboardModifiers_;
}

Qt::KeyboardModifiers QGLViewer::playPathKeyboardModifiers() const
{
    return playPathKeyboardModifiers_;
}

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

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

void QGLViewer::setAddKeyFrameStateKey(int buttonState)
{
    qWarning("setAddKeyFrameStateKey has been renamed setAddKeyFrameKeyboardModifiers");
    setAddKeyFrameKeyboardModifiers(keyboardModifiersFromState(buttonState));
}

void QGLViewer::setPlayPathStateKey(int buttonState)
{
    qWarning("setPlayPathStateKey has been renamed setPlayPathKeyboardModifiers");
    setPlayPathKeyboardModifiers(keyboardModifiersFromState(buttonState));
}

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

Qt::KeyboardModifiers 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(keyboardModifiersFromState(buttonState));
}
#endif

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

void QGLViewer::setHandlerKeyboardModifiers(MouseHandler handler, Qt::KeyboardModifiers modifiers)
{
    qWarning("setHandlerKeyboardModifiers is deprecated, call setMouseBinding() instead");

    QMap<MouseBindingPrivate, MouseActionPrivate> newMouseBinding;
    QMap<WheelBindingPrivate, MouseActionPrivate> newWheelBinding;
    QMap<ClickBindingPrivate, ClickAction> newClickBinding_;

    QMap<MouseBindingPrivate, MouseActionPrivate>::Iterator mit;
    QMap<WheelBindingPrivate, 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.
    for (mit = mouseBinding_.begin(); mit != mouseBinding_.end(); ++mit)
        if ((mit.value().handler == handler) && (mit.value().action != ZOOM_ON_REGION))
        {
            MouseBindingPrivate mbp(modifiers, mit.key().button, mit.key().key);
            newMouseBinding[mbp] = mit.value();
        }

    for (wit = wheelBinding_.begin(); wit != wheelBinding_.end(); ++wit)
        if (wit.value().handler == handler)
        {
            WheelBindingPrivate wbp(modifiers, wit.key().key);
            newWheelBinding[wbp] = wit.value();
        }

    // Same for button bindings
    for (QMap<ClickBindingPrivate, 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))))
        {
            ClickBindingPrivate cbp(modifiers, cb.key().button, cb.key().doubleClick, cb.key().buttonsBefore, cb.key().key);
            newClickBinding_[cbp] = cb.value();
        }
        else
            newClickBinding_[cb.key()] = cb.value();

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

void QGLViewer::setHandlerStateKey(MouseHandler handler, int buttonState)
{
    qWarning("setHandlerStateKey has been renamed setHandlerKeyboardModifiers");
    setHandlerKeyboardModifiers(handler, keyboardModifiersFromState(buttonState));
}

void QGLViewer::setMouseStateKey(MouseHandler handler, int buttonState)
{
    qWarning("setMouseStateKey has been renamed setHandlerKeyboardModifiers.");
    setHandlerKeyboardModifiers(handler, keyboardModifiersFromState(buttonState));
}

void QGLViewer::setMouseBinding(int state, MouseHandler handler, MouseAction action, bool withConstraint)
{
    qWarning("setMouseBinding(int state, MouseHandler...) is deprecated. Use the modifier/button equivalent");
    setMouseBinding(keyboardModifiersFromState(state),
                    mouseButtonFromState(state),
                    handler,
                    action,
                    withConstraint);
}
#endif

void QGLViewer::setMouseBinding(Qt::KeyboardModifiers modifiers, Qt::MouseButton button, MouseHandler handler, MouseAction action, bool withConstraint) {
    setMouseBinding(Qt::Key(0), modifiers, button, handler, action, withConstraint);
}

void QGLViewer::setMouseBinding(Qt::Key key, Qt::KeyboardModifiers modifiers, Qt::MouseButton button, MouseHandler handler, MouseAction action, bool withConstraint)
{
    if ((handler == FRAME) && ((action == MOVE_FORWARD) || (action == MOVE_BACKWARD) ||
                               (action == ROLL) || (action == LOOK_AROUND) ||
                               (action == ZOOM_ON_REGION))) {
        qWarning("Cannot bind %s to FRAME", mouseActionString(action).toLatin1().constData());
        return;
    }

    if (button == Qt::NoButton) {
        qWarning("No mouse button specified in setMouseBinding");
        return;
    }

    MouseActionPrivate map;
    map.handler = handler;
    map.action = action;
    map.withConstraint = withConstraint;

    MouseBindingPrivate mbp(modifiers, button, key);
    if (action == NO_MOUSE_ACTION)
        mouseBinding_.remove(mbp);
    else
        mouseBinding_.insert(mbp, map);

    ClickBindingPrivate cbp(modifiers, button, false, Qt::NoButton, key);
    clickBinding_.remove(cbp);
}

#ifndef DOXYGEN

void QGLViewer::setMouseBinding(int state, ClickAction action, bool doubleClick, Qt::MouseButtons buttonsBefore) {
    qWarning("setMouseBinding(int state, ClickAction...) is deprecated. Use the modifier/button equivalent");
    setMouseBinding(keyboardModifiersFromState(state),
                    mouseButtonFromState(state),
                    action,
                    doubleClick,
                    buttonsBefore);
}
#endif

void QGLViewer::setMouseBinding(Qt::KeyboardModifiers modifiers, Qt::MouseButton button, ClickAction action, bool doubleClick, Qt::MouseButtons buttonsBefore)
{
    setMouseBinding(Qt::Key(0), modifiers, button, action, doubleClick, buttonsBefore);
}

void QGLViewer::setMouseBinding(Qt::Key key, Qt::KeyboardModifiers modifiers, Qt::MouseButton button, ClickAction action, bool doubleClick, Qt::MouseButtons buttonsBefore)
{
    if ((buttonsBefore != Qt::NoButton) && !doubleClick) {
        qWarning("Buttons before is only meaningful when doubleClick is true in setMouseBinding().");
        return;
    }

    if (button == Qt::NoButton) {
        qWarning("No mouse button specified in setMouseBinding");
        return;
    }

    ClickBindingPrivate cbp(modifiers, button, doubleClick, buttonsBefore, key);

    // #CONNECTION performClickAction comment on NO_CLICK_ACTION
    if (action == NO_CLICK_ACTION)
        clickBinding_.remove(cbp);
    else
        clickBinding_.insert(cbp, action);

    if ((!doubleClick) && (buttonsBefore == Qt::NoButton)) {
        MouseBindingPrivate mbp(modifiers, button, key);
        mouseBinding_.remove(mbp);
    }
}

void QGLViewer::setWheelBinding(Qt::KeyboardModifiers modifiers, MouseHandler handler, MouseAction action, bool withConstraint) {
    setWheelBinding(Qt::Key(0), modifiers, handler, action, withConstraint);
}

void QGLViewer::setWheelBinding(Qt::Key key, Qt::KeyboardModifiers 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)) {
        qWarning("Cannot bind %s to wheel", mouseActionString(action).toLatin1().constData());
        return;
    }

    if ((handler == FRAME) && (action != ZOOM) && (action != NO_MOUSE_ACTION)) {
        qWarning("Cannot bind %s to FRAME wheel", mouseActionString(action).toLatin1().constData());
        return;
    }

    MouseActionPrivate map;
    map.handler = handler;
    map.action  = action;
    map.withConstraint = withConstraint;

    WheelBindingPrivate wbp(modifiers, key);
    if (action == NO_MOUSE_ACTION)
        wheelBinding_.remove(wbp);
    else
        wheelBinding_[wbp] = map;
}

void QGLViewer::clearMouseBindings() {
    mouseBinding_.clear();
    clickBinding_.clear();
    wheelBinding_.clear();
}

void QGLViewer::clearShortcuts() {
    keyboardBinding_.clear();
    pathIndex_.clear();
}

QGLViewer::MouseAction QGLViewer::mouseAction(int state) const {
    qWarning("mouseAction(int state,...) is deprecated. Use the modifier/button equivalent");
    return mouseAction(Qt::Key(0), keyboardModifiersFromState(state), mouseButtonFromState(state));
}

QGLViewer::MouseAction QGLViewer::mouseAction(Qt::Key key, Qt::KeyboardModifiers modifiers, Qt::MouseButton button) const
{
    MouseBindingPrivate mbp(modifiers, button, key);
    if (mouseBinding_.contains(mbp))
        return mouseBinding_[mbp].action;
    else
        return NO_MOUSE_ACTION;
}

int QGLViewer::mouseHandler(int state) const {
    qWarning("mouseHandler(int state,...) is deprecated. Use the modifier/button equivalent");
    return mouseHandler(Qt::Key(0), keyboardModifiersFromState(state), mouseButtonFromState(state));
}

int QGLViewer::mouseHandler(Qt::Key key, Qt::KeyboardModifiers modifiers, Qt::MouseButton button) const
{
    MouseBindingPrivate mbp(modifiers, button, key);
    if (mouseBinding_.contains(mbp))
        return mouseBinding_[mbp].handler;
    else
        return -1;
}


#ifndef DOXYGEN

int QGLViewer::mouseButtonState(MouseHandler handler, MouseAction action, bool withConstraint) const {
    qWarning("mouseButtonState() is deprecated. Use mouseButtons() and keyboardModifiers() instead");
    for (QMap<MouseBindingPrivate, 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 (int) it.key().modifiers | (int) it.key().button;

    return Qt::NoButton;
}
#endif

void QGLViewer::getWheelActionBinding(MouseHandler handler, MouseAction action, bool withConstraint,
                                      Qt::Key& key, Qt::KeyboardModifiers& modifiers) const
{
    for (QMap<WheelBindingPrivate, MouseActionPrivate>::ConstIterator it=wheelBinding_.begin(), end=wheelBinding_.end(); it != end; ++it)
        if ( (it.value().handler == handler) && (it.value().action == action) && (it.value().withConstraint == withConstraint) ) {
            key = it.key().key;
            modifiers = it.key().modifiers;
            return;
        }

    key = Qt::Key(-1);
    modifiers = Qt::NoModifier;
}

void QGLViewer::getMouseActionBinding(MouseHandler handler, MouseAction action, bool withConstraint,
                                      Qt::Key& key, Qt::KeyboardModifiers& modifiers, Qt::MouseButton& button) const
{
    for (QMap<MouseBindingPrivate, MouseActionPrivate>::ConstIterator it=mouseBinding_.begin(), end=mouseBinding_.end(); it != end; ++it)
        if ( (it.value().handler == handler) && (it.value().action == action) && (it.value().withConstraint == withConstraint) ) {
            key = it.key().key;
            modifiers = it.key().modifiers;
            button = it.key().button;
            return;
        }

    key = Qt::Key(0);
    modifiers = Qt::NoModifier;
    button = Qt::NoButton;
}

QGLViewer::MouseAction QGLViewer::wheelAction(Qt::Key key, Qt::KeyboardModifiers modifiers) const
{
    WheelBindingPrivate wbp(modifiers, key);
    if (wheelBinding_.contains(wbp))
        return wheelBinding_[wbp].action;
    else
        return NO_MOUSE_ACTION;
}

int QGLViewer::wheelHandler(Qt::Key key, Qt::KeyboardModifiers modifiers) const
{
    WheelBindingPrivate wbp(modifiers, key);
    if (wheelBinding_.contains(wbp))
        return wheelBinding_[wbp].handler;
    else
        return -1;
}

QGLViewer::ClickAction QGLViewer::clickAction(Qt::Key key, Qt::KeyboardModifiers modifiers, Qt::MouseButton button,
                                              bool doubleClick, Qt::MouseButtons buttonsBefore) const {
    ClickBindingPrivate cbp(modifiers, button, doubleClick, buttonsBefore, key);
    if (clickBinding_.contains(cbp))
        return clickBinding_[cbp];
    else
        return NO_CLICK_ACTION;
}

#ifndef DOXYGEN

QGLViewer::MouseAction QGLViewer::wheelAction(Qt::KeyboardModifiers modifiers) const {
    qWarning("wheelAction() is deprecated. Use the new wheelAction() method with a key parameter instead");
    return wheelAction(Qt::Key(0), modifiers);
}

int QGLViewer::wheelHandler(Qt::KeyboardModifiers modifiers) const {
    qWarning("wheelHandler() is deprecated. Use the new wheelHandler() method with a key parameter instead");
    return wheelHandler(Qt::Key(0), modifiers);
}

int QGLViewer::wheelButtonState(MouseHandler handler, MouseAction action, bool withConstraint) const
{
    qWarning("wheelButtonState() is deprecated. Use the wheelAction() and wheelHandler() instead");
    for (QMap<WheelBindingPrivate, 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().key + it.key().modifiers;

    return -1;
}

QGLViewer::ClickAction QGLViewer::clickAction(int state, bool doubleClick, Qt::MouseButtons buttonsBefore) const {
    qWarning("clickAction(int state,...) is deprecated. Use the modifier/button equivalent");
    return clickAction(Qt::Key(0),
                       keyboardModifiersFromState(state),
                       mouseButtonFromState(state),
                       doubleClick,
                       buttonsBefore);
}

void QGLViewer::getClickButtonState(ClickAction action, int& state, bool& doubleClick, Qt::MouseButtons& buttonsBefore) const {
    qWarning("getClickButtonState(int state,...) is deprecated. Use the modifier/button equivalent");
    Qt::KeyboardModifiers modifiers;
    Qt::MouseButton button;
    Qt::Key key;
    getClickActionBinding(action, key, modifiers, button, doubleClick, buttonsBefore);
    state = (int) modifiers | (int) button | (int) key;
}
#endif

void QGLViewer::getClickActionBinding(ClickAction action, Qt::Key& key, Qt::KeyboardModifiers& modifiers, Qt::MouseButton &button, bool& doubleClick, Qt::MouseButtons& buttonsBefore) const
{
    for (QMap<ClickBindingPrivate, ClickAction>::ConstIterator it=clickBinding_.begin(), end=clickBinding_.end(); it != end; ++it)
        if (it.value() == action) {
            modifiers = it.key().modifiers;
            button = it.key().button;
            doubleClick = it.key().doubleClick;
            buttonsBefore = it.key().buttonsBefore;
            key = it.key().key;
            return;
        }

    modifiers = Qt::NoModifier;
    button = Qt::NoButton;
    doubleClick = false;
    buttonsBefore = Qt::NoButton;
    key = Qt::Key(0);
}

bool QGLViewer::cameraIsInRotateMode() const
{
    //#CONNECTION# used in toggleCameraMode() and keyboardString()
    Qt::Key key;
    Qt::KeyboardModifiers modifiers;
    Qt::MouseButton button;
    getMouseActionBinding(CAMERA, ROTATE, false /*constraint*/, key, modifiers, button);
    return button != Qt::NoButton;
}

void QGLViewer::toggleCameraMode()
{
    Qt::Key key;
    Qt::KeyboardModifiers modifiers;
    Qt::MouseButton button;
    getMouseActionBinding(CAMERA, ROTATE, false /*constraint*/, key, modifiers, button);
    bool rotateMode = button != Qt::NoButton;

    if (!rotateMode) {
        getMouseActionBinding(CAMERA, MOVE_FORWARD, false /*constraint*/, key, modifiers, button);
    }

    //#CONNECTION# setDefaultMouseBindings()
    if (rotateMode)
    {
        camera()->frame()->updateSceneUpVector();
        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(Qt::Key_R, modifiers, Qt::LeftButton, CAMERA, ROLL);

        setMouseBinding(Qt::NoModifier, Qt::LeftButton,  NO_CLICK_ACTION, true);
        setMouseBinding(Qt::NoModifier, Qt::MidButton,   NO_CLICK_ACTION, true);
        setMouseBinding(Qt::NoModifier, 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(Qt::Key_R, modifiers, Qt::LeftButton, CAMERA, SCREEN_ROTATE);

        setMouseBinding(Qt::NoModifier, Qt::LeftButton,  ALIGN_CAMERA,      true);
        setMouseBinding(Qt::NoModifier, Qt::MidButton,   SHOW_ENTIRE_SCENE, true);
        setMouseBinding(Qt::NoModifier, 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(update()));
            disconnect(manipulatedFrame(), SIGNAL(spun()), this, SLOT(update()));
        }
    }

    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(update()));
            connect(manipulatedFrame(), SIGNAL(spun()), SLOT(update()));
        }
    }
}

#ifndef DOXYGEN
//                          V i s u a l   H i n t s                           //

void QGLViewer::drawVisualHints()
{
    // Pivot point cross
    if (visualHint_ & 1)
    {
        const float size = 15.0;
        Vec proj = camera()->projectedCoordinatesOf(camera()->pivotPoint());
        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()->pivotPoint();
    }
    if (manipulatedFrame() && (manipulatedFrame()->action_ == SCREEN_ROTATE))
    {
        mf = manipulatedFrame();
        // Maybe useful if the mf is a manipCameraFrame...
        // pnt = manipulatedFrame()->pivotPoint();
        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()
{
    Q_FOREACH (QGLViewer* viewer, QGLViewer::QGLViewerPool())
    {
        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 (fi.suffix().isEmpty())
            name += QString::number(QGLViewer::QGLViewerIndex(this));
        else
            name = fi.absolutePath() + '/' + fi.completeBaseName() + QString::number(QGLViewer::QGLViewerIndex(this)) + "." + fi.suffix();
    }

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

    const QString dirName = fileInfo.absolutePath();
    if (!QFileInfo(dirName).exists())
    {
        QDir dir;
        if (!(dir.mkdir(dirName)))
        {
            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 (f.open(QIODevice::WriteOnly))
    {
        QTextStream out(&f);
        QDomDocument doc("QGLVIEWER");
        doc.appendChild(domElement("QGLViewer", doc));
        doc.save(out, 2);
        f.flush();
        f.close();
    }
    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());
}

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 (f.open(QIODevice::ReadOnly))
    {
        QDomDocument doc;
        doc.setContent(&f);
        f.close();
        QDomElement main = doc.documentElement();
        initFromDOMElement(main);
    }
    else
    {
        QMessageBox::warning(this, tr("Open file error", "Message box window title"), tr("Unable to open file %1").arg(name) + ":\n" + f.errorString());
        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");
    // hasMouseTracking() is not saved
    stateNode.appendChild(DomUtils::QColorDomElement(foregroundColor(), "foregroundColor", document));
    stateNode.appendChild(DomUtils::QColorDomElement(backgroundColor(), "backgroundColor", document));
    DomUtils::setBoolAttribute(stateNode, "stereo", displaysInStereo());
    // Revolve or fly camera mode is not saved
    de.appendChild(stateNode);

    QDomElement displayNode = document.createElement("Display");
    DomUtils::setBoolAttribute(displayNode, "axisIsDrawn", axisIsDrawn());
    DomUtils::setBoolAttribute(displayNode, "gridIsDrawn", gridIsDrawn());
    DomUtils::setBoolAttribute(displayNode, "FPSIsDisplayed", FPSIsDisplayed());
    DomUtils::setBoolAttribute(displayNode, "cameraIsEdited", cameraIsEdited());
    // textIsEnabled() is not saved
    de.appendChild(displayNode);

    QDomElement geometryNode = document.createElement("Geometry");
    DomUtils::setBoolAttribute(geometryNode, "fullScreen", isFullScreen());
    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.
        qWarning("State file created using QGLViewer version %s may not be correctly read.", version.toLatin1().constData());

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