# ManipulatedFrame Class Reference

A ManipulatedFrame is a Frame that can be rotated and translated using the mouse. More...

List of all members.

## Signals
void | manipulated ()
void | spun ()
## Public Member Functions
| ManipulatedFrame ()
virtual | ~ManipulatedFrame ()
| ManipulatedFrame (const ManipulatedFrame &mf)
ManipulatedFrame & | operator= (const ManipulatedFrame &mf)
## Manipulation sensitivity
float | rotationSensitivity () const
float | translationSensitivity () const
float | spinningSensitivity () const
float | wheelSensitivity () const
void | setRotationSensitivity (float sensitivity)
void | setTranslationSensitivity (float sensitivity)
void | setSpinningSensitivity (float sensitivity)
void | setWheelSensitivity (float sensitivity)
## Spinning
bool | isSpinning () const
Quaternion | spinningQuaternion () const
void | setSpinningQuaternion (const Quaternion &spinningQuaternion)
virtual void | startSpinning (int updateInterval)
virtual void | stopSpinning ()
virtual void | spin ()
## Current state
bool | isManipulated () const
## MouseGrabber implementation
virtual void | checkIfGrabsMouse (int x, int y, const Camera *const camera)
## XML representation
virtual QDomElement | domElement (const QString &name, QDomDocument &document) const
virtual void | initFromDOMElement (const QDomElement &element)
## Mouse event handlers
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)

## Detailed Description

A ManipulatedFrame is a Frame that can be rotated and translated using the mouse.

It converts the mouse motion into a translation and an orientation updates. A ManipulatedFrame is used to move an object in the scene. Combined with object selection, its MouseGrabber properties and a dynamic update of the scene, the ManipulatedFrame introduces a great reactivity in your applications.

A ManipulatedFrame is attached to a QGLViewer using QGLViewer::setManipulatedFrame():

      init() { setManipulatedFrame( new ManipulatedFrame() ); }

      draw()
      {
        glPushMatrix();
        glMultMatrixd(manipulatedFrame()->matrix());
        // draw the manipulated object here
        glPopMatrix();
      }

See the manipulatedFrame example for a complete application.

Mouse events are normally sent to the QGLViewer::camera(). You have to press the FRAME state key (default is `Control`) to move the QGLViewer::manipulatedFrame() instead. See the mouse page for a description of mouse button bindings.

### Inherited functionalities

A ManipulatedFrame is an overloaded instance of a Frame. The powerful coordinate system transformation functions (Frame::coordinatesOf(), Frame::transformOf(), ...) can hence be applied to a ManipulatedFrame.

A ManipulatedFrame is also a MouseGrabber. If the mouse cursor gets within a distance of 10 pixels from the projected position of the ManipulatedFrame, the ManipulatedFrame becomes the new QGLViewer::mouseGrabber(). It can then be manipulated directly, without any specific state key, object selection or GUI intervention. This is very convenient to directly move some objects in the scene (typically a light). See the mouseGrabber example as an illustration. Note that QWidget::setMouseTracking() needs to be enabled in order to use this feature (see the MouseGrabber documentation).

### Advanced functionalities

A QGLViewer can handle at most one ManipulatedFrame at a time. If you want to move several objects in the scene, you simply have to keep a list of the different ManipulatedFrames, and to activate the right one (using QGLViewer::setManipulatedFrame()) when needed. This can for instance be done according to an object selection: see the luxo example for an illustration.

When the ManipulatedFrame is being manipulated using the mouse (mouse pressed and not yet released), isManipulated() returns `true`. This might be used to trigger a specific action or display (as is done with QGLViewer::fastDraw()).

The ManipulatedFrame also emits a manipulated() signal each time its state is modified by the mouse. This signal is automatically connected to the QGLViewer::updateGL() slot when the ManipulatedFrame is attached to a viewer using QGLViewer::setManipulatedFrame().

You can make the ManipulatedFrame spin() if you release the rotation mouse button while moving the mouse fast enough (see spinningSensitivity()). See also translationSensitivity() and rotationSensitivity() for sensitivity tuning.

## Constructor & Destructor Documentation

ManipulatedFrame | ( |  | ) |

Default constructor.

The translation is set to (0,0,0), with an identity rotation (0,0,0,1) (see Frame constructor for details).

The different sensitivities are set to their default values (see rotationSensitivity(), translationSensitivity(), spinningSensitivity() and wheelSensitivity()).

virtual ~ManipulatedFrame | ( |  | ) | `[virtual]`

Virtual destructor. Empty.

ManipulatedFrame | ( | const ManipulatedFrame & | mf | ) |

Copy constructor. Performs a deep copy of all attributes using operator=().

## Member Function Documentation

void checkIfGrabsMouse | ( | int | x,
|  | int | y,
|  | const Camera *const | camera |
| ) |  |  | `[virtual]`

Implementation of the MouseGrabber main method.

The ManipulatedFrame grabsMouse() when the mouse is within a 10 pixels region around its Camera::projectedCoordinatesOf() position().

See the mouseGrabber example for an illustration.

Implements MouseGrabber.

QDomElement domElement | ( | const QString & | name,
|  | QDomDocument & | document |
| ) |  |  | const`[virtual]`

Returns an XML `QDomElement` that represents the ManipulatedFrame.

Adds to the Frame::domElement() the ManipulatedFrame specific informations in a `ManipulatedParameters` child QDomElement.

`name` is the name of the QDomElement tag. `doc` is the `QDomDocument` factory used to create QDomElement.

Use initFromDOMElement() to restore the ManipulatedFrame state from the resulting `QDomElement`.

See Vec::domElement() for a complete example. See also Quaternion::domElement(), Camera::domElement()...

Reimplemented from Frame.

Reimplemented in ManipulatedCameraFrame.

void initFromDOMElement | ( | const QDomElement & | element | ) | `[virtual, slot]`

Restores the ManipulatedFrame state from a `QDomElement` created by domElement().

Fields that are not described in `element` are set to their default values (see ManipulatedFrame()).

First calls Frame::initFromDOMElement() and then initializes ManipulatedFrame specific parameters. Note that constraint() and referenceFrame() are not restored and are left unchanged.

See Vec::initFromDOMElement() for a complete code example.

Reimplemented from Frame.

Reimplemented in ManipulatedCameraFrame.

bool isManipulated | ( |  | ) | const

Returns `true` when the ManipulatedFrame is being manipulated with the mouse.

Can be used to change the display of the manipulated object during manipulation.

When Camera::frame() of the QGLViewer::camera() isManipulated(), QGLViewer::fastDraw() is used in place of QGLViewer::draw() for scene rendering. A simplified drawing will then allow for interactive camera displacements.

bool isSpinning | ( |  | ) | const

Returns `true` when the ManipulatedFrame is spinning.

During spinning, spin() rotates the ManipulatedFrame by its spinningQuaternion() at a frequency defined when the ManipulatedFrame startSpinning().

Use startSpinning() and stopSpinning() to change this state. Default value is `false`.

void manipulated | ( |  | ) | `[signal]`

This signal is emitted when ever the ManipulatedFrame is manipulated (i.e. rotated or translated) using the mouse. Connect this signal to any object that should be notified.

Note that this signal is automatically connected to the QGLViewer::updateGL() slot, when the ManipulatedFrame is attached to a viewer using QGLViewer::setManipulatedFrame(), which is probably all you need.

Use the QGLViewer::QGLViewerPool() if you need to connect this signal to all the viewers.

See also the spun(), modified(), interpolated() and KeyFrameInterpolator::interpolated() signals' documentations.

void mouseDoubleClickEvent | ( | QMouseEvent *const | event,
|  | Camera *const | camera |
| ) |  |  | `[protected, virtual]`

Overloading of MouseGrabber::mouseDoubleClickEvent().

Left button double click aligns the ManipulatedFrame with the `camera` axis (see alignWithFrame() and ALIGN_FRAME). Right button projects the ManipulatedFrame on the `camera` view direction.

Reimplemented from MouseGrabber.

void mouseMoveEvent | ( | QMouseEvent *const | event,
|  | Camera *const | camera |
| ) |  |  | `[protected, virtual]`

Modifies the ManipulatedFrame according to the mouse motion.

Actual behavior depends on mouse bindings. See the QGLViewer::MouseAction enum and the QGLViewer mouse page for details.

The `camera` is used to fit the mouse motion with the display parameters (see Camera::screenWidth(), Camera::screenHeight(), Camera::fieldOfView()).

Emits the manipulated() signal.

Reimplemented from MouseGrabber.

Reimplemented in ManipulatedCameraFrame.

void mousePressEvent | ( | QMouseEvent *const | event,
|  | Camera *const | camera |
| ) |  |  | `[protected, virtual]`

Initiates the ManipulatedFrame mouse manipulation.

Overloading of MouseGrabber::mousePressEvent(). See also mouseMoveEvent() and mouseReleaseEvent().

The mouse behavior depends on which button is pressed. See the QGLViewer mouse page for details.

Reimplemented from MouseGrabber.

void mouseReleaseEvent | ( | QMouseEvent *const | event,
|  | Camera *const | camera |
| ) |  |  | `[protected, virtual]`

Stops the ManipulatedFrame mouse manipulation.

Overloading of MouseGrabber::mouseReleaseEvent().

If the action was a ROTATE QGLViewer::MouseAction, a continuous spinning is possible if the speed of the mouse cursor is larger than spinningSensitivity() when the button is released. Press the rotate button again to stop spinning. See startSpinning() and isSpinning().

Reimplemented from MouseGrabber.

Reimplemented in ManipulatedCameraFrame.

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

Equal operator. Calls Frame::operator=() and then copy attributes.

float rotationSensitivity | ( |  | ) | const

Returns the influence of a mouse displacement on the ManipulatedFrame rotation.

Default value is 1.0. With an identical mouse displacement, a higher value will generate a larger rotation (and inversely for lower values). A 0.0 value will forbid ManipulatedFrame mouse rotation (see also constraint()).

See also setRotationSensitivity(), translationSensitivity(), spinningSensitivity() and wheelSensitivity().

void setRotationSensitivity | ( | float | sensitivity | ) | `[slot]`

Defines the rotationSensitivity().

void setSpinningQuaternion | ( | const Quaternion & | spinningQuaternion | ) | `[slot]`

Defines the spinningQuaternion(). Its axis is defined in the ManipulatedFrame coordinate system.

void setSpinningSensitivity | ( | float | sensitivity | ) | `[slot]`

Defines the spinningSensitivity(), in pixels per milliseconds.

void setTranslationSensitivity | ( | float | sensitivity | ) | `[slot]`

Defines the translationSensitivity().

void setWheelSensitivity | ( | float | sensitivity | ) | `[slot]`

Defines the wheelSensitivity().

void spin | ( |  | ) | `[protected, virtual, slot]`

Rotates the ManipulatedFrame by its spinningQuaternion(). Called by a timer when the ManipulatedFrame isSpinning().

Reimplemented in ManipulatedCameraFrame.

Quaternion spinningQuaternion | ( |  | ) | const

Returns the incremental rotation that is applied by spin() to the ManipulatedFrame orientation when it isSpinning().

Default value is a null rotation (identity Quaternion). Use setSpinningQuaternion() to change this value.

The spinningQuaternion() axis is defined in the ManipulatedFrame coordinate system. You can use Frame::transformOfFrom() to convert this axis from an other Frame coordinate system.

float spinningSensitivity | ( |  | ) | const

Returns the minimum mouse speed required (at button release) to make the ManipulatedFrame spin().

See spin(), spinningQuaternion() and startSpinning() for details.

Mouse speed is expressed in pixels per milliseconds. Default value is 0.3 (300 pixels per second). Use setSpinningSensitivity() to tune this value. A higher value will make spinning more difficult (a value of 100.0 forbids spinning in practice).

See also setSpinningSensitivity(), translationSensitivity(), rotationSensitivity() and wheelSensitivity().

void spun | ( |  | ) | `[signal]`

This signal is emitted when the ManipulatedFrame isSpinning().

Note that for the QGLViewer::manipulatedFrame(), this signal is automatically connected to the QGLViewer::updateGL() slot.

Connect this signal to any object that should be notified. Use the QGLViewer::QGLViewerPool() if you need to connect this signal to all the viewers.

See also the manipulated(), modified(), interpolated() and KeyFrameInterpolator::interpolated() signals' documentations.

void startSpinning | ( | int | updateInterval | ) | `[virtual, slot]`

Starts the spinning of the ManipulatedFrame.

This method starts a timer that will call spin() every `updateInterval` milliseconds. The ManipulatedFrame isSpinning() until you call stopSpinning().

virtual void stopSpinning | ( |  | ) | `[virtual, slot]`

Stops the spinning motion started using startSpinning(). isSpinning() will return `false` after this call.

float translationSensitivity | ( |  | ) | const

Returns the influence of a mouse displacement on the ManipulatedFrame translation.

Default value is 1.0. You should not have to modify this value, since with 1.0 the ManipulatedFrame precisely stays under the mouse cursor.

With an identical mouse displacement, a higher value will generate a larger translation (and inversely for lower values). A 0.0 value will forbid ManipulatedFrame mouse translation (see also constraint()).

Note:
  When the ManipulatedFrame is used to move a Camera (see the ManipulatedCameraFrame class documentation), after zooming on a small region of your scene, the camera may translate too fast. For a camera, it is the Camera::revolveAroundPoint() that exactly matches the mouse displacement. Hence, instead of changing the translationSensitivity(), solve the problem by (temporarily) setting the Camera::revolveAroundPoint() to a point on the zoomed region (see the RAP_FROM_PIXEL mouse binding in the mouse page).

See also setTranslationSensitivity(), rotationSensitivity(), spinningSensitivity() and wheelSensitivity().

void wheelEvent | ( | QWheelEvent *const | event,
|  | Camera *const | camera |
| ) |  |  | `[protected, virtual]`

Overloading of MouseGrabber::wheelEvent().

Using the wheel is equivalent to a ZOOM QGLViewer::MouseAction. See QGLViewer::setWheelBinding() and setWheelSensitivity().

Reimplemented from MouseGrabber.

Reimplemented in ManipulatedCameraFrame.

float wheelSensitivity | ( |  | ) | const

Returns the mouse wheel sensitivity.

Default value is 1.0. A higher value will make the wheel action more efficient (usually meaning a faster zoom). Use a negative value to invert the zoom in and out directions.

See also setWheelSensitivity(), translationSensitivity(), rotationSensitivity() and spinningSensitivity().