manipulatedFrame.h

Go to the documentation of this file.

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

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

 This file is part of the QGLViewer library version 2.6.3.

 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(qreal sensitivity) { rotationSensitivity_ = sensitivity; }
        void setTranslationSensitivity(qreal sensitivity) { translationSensitivity_ = sensitivity; }
        void setSpinningSensitivity(qreal sensitivity) { spinningSensitivity_ = sensitivity; }
        void setWheelSensitivity(qreal sensitivity) { wheelSensitivity_ = sensitivity; }
        void setZoomSensitivity(qreal sensitivity) { zoomSensitivity_ = sensitivity; }

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

        qreal zoomSensitivity() const { return zoomSensitivity_; }
        qreal 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, qreal cx, qreal 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);

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

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

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

#endif // DOXYGEN

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

        // Mouse speed and spinning
        QTime last_move_time;
        qreal 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