manipulatedFrame.h

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

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

 This file is part of the QGLViewer library version 2.3.10.

 http://www.libqglviewer.com - contact@libqglviewer.com

 This file may be used under the terms of the GNU General Public License 
 versions 2.0 or 3.0 as published by the Free Software Foundation and
 appearing in the LICENSE file included in the packaging of this file.
 In addition, as a special exception, Gilles Debunne gives you certain 
 additional rights, described in the file GPL_EXCEPTION in this package.

 libQGLViewer uses dual licensing. Commercial/proprietary software must
 purchase a libQGLViewer Commercial License.

 This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.

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

#ifndef QGLVIEWER_MANIPULATED_FRAME_H
#define QGLVIEWER_MANIPULATED_FRAME_H

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

#if QT_VERSION >= 0x040000
# include <QString>
# include <QTimer>
# include <QDateTime>
#else
# include <qstring.h>
# include <qtimer.h>
# include <qdatetime.h>
#endif

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) { rotSensitivity_ = sensitivity; };
    void setTranslationSensitivity(float sensitivity) { transSensitivity_ = sensitivity; };
    void setSpinningSensitivity(float sensitivity) { spinningSensitivity_ = sensitivity; };
    void setWheelSensitivity(float sensitivity) { wheelSensitivity_ = sensitivity; };
  public:
    float rotationSensitivity() const { return rotSensitivity_; };
    float translationSensitivity() const { return transSensitivity_; };
    float spinningSensitivity() const { return spinningSensitivity_; };
    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;

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

    int action_; // Should be a QGLViewer::MouseAction, but include loop
    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);

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

  private:
    // Sensitivity
    float rotSensitivity_;
    float transSensitivity_;
    float spinningSensitivity_;
    float wheelSensitivity_;

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