manipulatedFrame.h

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

 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.

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

#ifndef QGLVIEWER_MANIPULATED_FRAME_H
#define QGLVIEWER_MANIPULATED_FRAME_H

#include "frame.h"
#include "mouseGrabber.h"
#include "qglviewer.h"

#include <QString>
#include <QTimer>
#include <QDateTime>

namespace qglviewer {
class QGLVIEWER_EXPORT ManipulatedFrame : public Frame, public MouseGrabber
{
#ifndef DOXYGEN
    friend class Camera;
    friend class ::QGLViewer;
#endif

    Q_OBJECT

public:
    ManipulatedFrame();
    virtual ~ManipulatedFrame() {}

    ManipulatedFrame(const ManipulatedFrame& mf);
    ManipulatedFrame& operator=(const ManipulatedFrame& mf);

Q_SIGNALS:
    void manipulated();

    void spun();

public Q_SLOTS:
    void setRotationSensitivity(float sensitivity) { rotationSensitivity_ = sensitivity; }
    void setTranslationSensitivity(float sensitivity) { translationSensitivity_ = sensitivity; }
    void setSpinningSensitivity(float sensitivity) { spinningSensitivity_ = sensitivity; }
    void setWheelSensitivity(float sensitivity) { wheelSensitivity_ = sensitivity; }
    void setZoomSensitivity(float sensitivity) { zoomSensitivity_ = sensitivity; }

public:
    float rotationSensitivity() const { return rotationSensitivity_; }
    float translationSensitivity() const { return translationSensitivity_; }
    float spinningSensitivity() const { return spinningSensitivity_; }

    float zoomSensitivity() const { return zoomSensitivity_; }
    float wheelSensitivity() const { return wheelSensitivity_; }


public:
    bool isSpinning() const { return isSpinning_; }
    Quaternion spinningQuaternion() const { return spinningQuaternion_; }
public Q_SLOTS:
    void setSpinningQuaternion(const Quaternion& spinningQuaternion) { spinningQuaternion_ = spinningQuaternion; }
    virtual void startSpinning(int updateInterval);
    virtual void stopSpinning() { spinningTimer_.stop(); isSpinning_ = false; }
protected Q_SLOTS:
    virtual void spin();
private Q_SLOTS:
    void spinUpdate();

protected:
    virtual void mousePressEvent      (QMouseEvent* const event, Camera* const camera);
    virtual void mouseMoveEvent       (QMouseEvent* const event, Camera* const camera);
    virtual void mouseReleaseEvent    (QMouseEvent* const event, Camera* const camera);
    virtual void mouseDoubleClickEvent(QMouseEvent* const event, Camera* const camera);
    virtual void wheelEvent           (QWheelEvent* const event, Camera* const camera);

public:
    bool isManipulated() const;
    QGLViewer::MouseAction currentMouseAction() const { return action_; }

public:
    virtual void checkIfGrabsMouse(int x, int y, const Camera* const camera);

public:
    virtual QDomElement domElement(const QString& name, QDomDocument& document) const;
public Q_SLOTS:
    virtual void initFromDOMElement(const QDomElement& element);

#ifndef DOXYGEN
protected:
    Quaternion deformedBallQuaternion(int x, int y, float cx, float cy, const Camera* const camera);

    QGLViewer::MouseAction action_;
    Constraint* previousConstraint_; // When manipulation is without Contraint.

    virtual void startAction(int ma, bool withConstraint=true); // int is really a QGLViewer::MouseAction
    void computeMouseSpeed(const QMouseEvent* const e);
    int mouseOriginalDirection(const QMouseEvent* const e);

    float deltaWithPrevPos(QMouseEvent* const event, Camera* const camera) const;
    float wheelDelta(const QWheelEvent* event) const;

    // Previous mouse position (used for incremental updates) and mouse press position.
    QPoint prevPos_, pressPos_;

private:
    void zoom(float delta, const Camera * const camera);

#endif // DOXYGEN

private:
    // Sensitivity
    float rotationSensitivity_;
    float translationSensitivity_;
    float spinningSensitivity_;
    float wheelSensitivity_;
    float zoomSensitivity_;

    // Mouse speed and spinning
    QTime last_move_time;
    float mouseSpeed_;
    int delay_;
    bool isSpinning_;
    QTimer spinningTimer_;
    Quaternion spinningQuaternion_;

    // Whether the SCREEN_TRANS direction (horizontal or vertical) is fixed or not.
    bool dirIsFixed_;

    // MouseGrabber
    bool keepsGrabbingMouse_;
};

} // namespace qglviewer

#endif // QGLVIEWER_MANIPULATED_FRAME_H