0031007: Coding - eliminate warnings issued while compiling with -pedantic flag
[occt.git] / src / AIS / AIS_Manipulator.hxx
1 // Created on: 2015-12-23
2 // Created by: Anastasia BORISOVA
3 // Copyright (c) 2015 OPEN CASCADE SAS
4 //
5 // This file is part of Open CASCADE Technology software library.
6 //
7 // This library is free software; you can redistribute it and/or modify it under
8 // the terms of the GNU Lesser General Public License version 2.1 as published
9 // by the Free Software Foundation, with special exception defined in the file
10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
11 // distribution for complete text of the license and disclaimer of any warranty.
12 //
13 // Alternatively, this file may be used under the terms of Open CASCADE
14 // commercial license or contractual agreement.
15
16 #ifndef _AIS_Manipulator_HeaderFile
17 #define _AIS_Manipulator_HeaderFile
18
19 #include <AIS_InteractiveObject.hxx>
20 #include <AIS_ManipulatorMode.hxx>
21 #include <gp.hxx>
22 #include <gp_Ax1.hxx>
23 #include <gp_Dir.hxx>
24 #include <gp_Pnt.hxx>
25 #include <Graphic3d_ArrayOfQuadrangles.hxx>
26 #include <Graphic3d_ArrayOfTriangles.hxx>
27 #include <Graphic3d_Group.hxx>
28 #include <NCollection_HSequence.hxx>
29 #include <Poly_Triangulation.hxx>
30 #include <V3d_View.hxx>
31 #include <Standard_Version.hxx>
32 #include <Standard_DefineHandle.hxx>
33
34 NCOLLECTION_HSEQUENCE(AIS_ManipulatorObjectSequence, Handle(AIS_InteractiveObject))
35
36 DEFINE_STANDARD_HANDLE (AIS_Manipulator, AIS_InteractiveObject)
37
38 //! Interactive object class to manipulate local transformation of another interactive
39 //! object or a group of objects via mouse.
40 //! It manages three types of manipulations in 3D space:
41 //! - translation through axis
42 //! - scaling within axis
43 //! - rotation around axis
44 //! To enable one of this modes, selection mode (from 1 to 3) is to be activated.
45 //! There are three orthogonal transformation axes defined by position property of
46 //! the manipulator. Particular transformation mode can be disabled for each
47 //! of the axes or all of them. Furthermore each of the axes can be hidden or
48 //! made visible.
49 //! The following steps demonstrate how to attach, configure and use manipulator
50 //! for an interactive object:
51 //! Step 1. Create manipulator object and adjust it appearance:
52 //! @code
53 //! Handle(AIS_Manipulator) aManipulator = new AIS_Manipulator();
54 //! aManipulator->SetPart (0, AIS_Manipulator::Scaling, Standard_False);
55 //! aManipulator->SetPart (1, AIS_Manipulator::Rotation, Standard_False);
56 //! // Attach manipulator to already displayed object and manage manipulation modes
57 //! aManipulator->AttachToObject (anAISObject);
58 //! aManipulator->EnableMode (AIS_Manipulator::Translation);
59 //! aManipulator->EnableMode (AIS_Manipulator::Rotation);
60 //! aManipulator->EnableMode (AIS_Manipulator::Scaling);
61 //! @endcode
62 //! Note that you can enable only one manipulation mode but have all visual parts displayed.
63 //! This code allows you to view manipulator and select its manipulation parts.
64 //! Note that manipulator activates mode on part selection.
65 //! If this mode is activated, no selection will be performed for manipulator.
66 //! It can be activated with highlighting. To enable this:
67 //! @code
68 //! aManipulator->SetModeActivationOnDetection (Standard_True);
69 //! @endcode
70 //! Step 2. To perform transformation of object use next code in your event processing chain:
71 //! @code
72 //! // catch mouse button down event
73 //! if (aManipulator->HasActiveMode())
74 //! {
75 //!   aManipulator->StartTransform (anXPix, anYPix, aV3dView);
76 //! }
77 //! ...
78 //! // or track mouse move event
79 //! if (aManipulator->HasActiveMode())
80 //! {
81 //!   aManipulator->Transform (anXPix, anYPix, aV3dView);
82 //!   aV3dView->Redraw();
83 //! }
84 //! ...
85 //! // or catch mouse button up event (apply) or escape event (cancel)
86 //! aManipulator->StopTransform(/*Standard_Boolean toApply*/);
87 //! @endcode
88 //! Step 3. To deactivate current manipulation mode use:
89 //! @code aManipulator->DeactivateCurrentMode();
90 //! @endcode
91 //! Step 4. To detach manipulator from object use:
92 //! @code
93 //! aManipulator->Detach();
94 //! @endcode
95 //! The last method erases manipulator object.
96 //! @warning
97 //! On construction an instance of AIS_Manipulator object is bound to Graphic3d_ZLayerId_Topmost layer,
98 //! so make sure to call for your AIS_InteractiveContext the method MainSelector()->SetPickClosest (Standard_False)
99 //! otherwise you may notice issues with activation of modes.
100 class AIS_Manipulator : public AIS_InteractiveObject
101 {
102 public:
103
104   //! Constructs a manipulator object with default placement and all parts to be displayed.
105   Standard_EXPORT AIS_Manipulator();
106
107   //! Constructs a manipulator object with input location and positions of axes and all parts to be displayed.
108   Standard_EXPORT AIS_Manipulator (const gp_Ax2& thePosition);
109
110   //! Disable or enable visual parts for translation, rotation or scaling for some axis.
111   //! By default all parts are enabled (will be displayed).
112   //! @warning Enabling or disabling of visual parts of manipulator does not manage the manipulation (selection) mode.
113   //! @warning Raises program error if axis index is < 0 or > 2.
114   Standard_EXPORT void SetPart (const Standard_Integer theAxisIndex, const AIS_ManipulatorMode theMode, const Standard_Boolean theIsEnabled);
115
116   //! Disable or enable visual parts for translation, rotation or scaling for ALL axes.
117   //! By default all parts are enabled (will be displayed).
118   //! @warning Enabling or disabling of visual parts of manipulator does not manage the manipulation (selection) mode.
119   //! @warning Raises program error if axis index is < 0 or > 2.
120   Standard_EXPORT void SetPart (const AIS_ManipulatorMode theMode, const Standard_Boolean theIsEnabled);
121
122   //! Behavior settings to be applied when performing transformation:
123   //! - FollowTranslation - whether the manipulator will be moved together with an object.
124   //! - FollowRotation - whether the manipulator will be rotated together with an object.
125   struct OptionsForAttach {
126
127     OptionsForAttach() : AdjustPosition (Standard_True), AdjustSize (Standard_False), EnableModes (Standard_True) {}
128     OptionsForAttach& SetAdjustPosition (const Standard_Boolean theApply) { AdjustPosition = theApply; return *this; }
129     OptionsForAttach& SetAdjustSize     (const Standard_Boolean theApply) { AdjustSize     = theApply; return *this; }
130     OptionsForAttach& SetEnableModes    (const Standard_Boolean theApply) { EnableModes    = theApply; return *this; }
131
132     Standard_Boolean AdjustPosition;
133     Standard_Boolean AdjustSize;
134     Standard_Boolean EnableModes;
135   };
136
137   //! Attaches himself to the input interactive object and become displayed in the same context.
138   //! It is placed in the center of object bounding box, and its size is adjusted to the object bounding box.
139   Standard_EXPORT void Attach (const Handle(AIS_InteractiveObject)& theObject, const OptionsForAttach& theOptions = OptionsForAttach());
140
141   //! Attaches himself to the input interactive object group and become displayed in the same context.
142   //! It become attached to the first object, baut manage manipulation of the whole group.
143   //! It is placed in the center of object bounding box, and its size is adjusted to the object bounding box.
144   Standard_EXPORT void Attach (const Handle(AIS_ManipulatorObjectSequence)& theObject, const OptionsForAttach& theOptions = OptionsForAttach());
145
146   //! Enable manipualtion mode.
147   //! @warning It activates selection mode in the current context.
148   //! If manipulator is not displayed, no mode will be activated.
149   Standard_EXPORT void EnableMode (const AIS_ManipulatorMode theMode);
150
151   //! Enables mode activation on detection (highlighting).
152   //! By default, mode is activated on selection of manipulator part.
153   //! @warning If this mode is enabled, selection of parts does nothing.
154   void SetModeActivationOnDetection (const Standard_Boolean theToEnable)
155   {
156     myIsActivationOnDetection = theToEnable;
157   }
158
159   //! @return true if manual mode activation is enabled.
160   Standard_Boolean IsModeActivationOnDetection() const
161   {
162     return myIsActivationOnDetection;
163   }
164
165 public:
166
167   //! Init start (reference) transformation.
168   //! @warning It is used in chain with StartTransform-Transform(gp_Trsf)-StopTransform
169   //! and is used only for custom transform set. If Transform(const Standard_Integer, const Standard_Integer) is used,
170   //! initial data is set automatically, and it is reset on DeactivateCurrentMode call if it is not reset yet.
171   Standard_EXPORT void StartTransform (const Standard_Integer theX, const Standard_Integer theY, const Handle(V3d_View)& theView);
172
173   //! Apply to the owning objects the input transformation.
174   //! @remark The transformation is set using SetLocalTransformation for owning objects.
175   //! The location of the manipulator is stored also in Local Transformation,
176   //! so that there's no need to redisplay objects.
177   //! @warning It is used in chain with StartTransform-Transform(gp_Trsf)-StopTransform
178   //! and is used only for custom transform set.
179   //! @warning It will does nothing if transformation is not initiated (with StartTransform() call).
180   Standard_EXPORT void Transform (const gp_Trsf& aTrsf);
181
182   //! Reset start (reference) transformation.
183   //! @param theToApply [in] option to apply or to cancel the started transformation.
184   //! @warning It is used in chain with StartTransform-Transform(gp_Trsf)-StopTransform
185   //! and is used only for custom transform set.
186   Standard_EXPORT void StopTransform (const Standard_Boolean theToApply = Standard_True);
187
188   //! Apply transformation made from mouse moving from start position
189   //! (save on the first Tranform() call and reset on DeactivateCurrentMode() call.)
190   //! to the in/out mouse position (theX, theY)
191   Standard_EXPORT gp_Trsf Transform (const Standard_Integer theX, const Standard_Integer theY,
192                                      const Handle(V3d_View)& theView);
193
194   //! Computes transformation of parent object according to the active mode and input motion vector.
195   //! You can use this method to get object transformation according to current mode or use own algorithm
196   //! to implement any other tranformation for modes.
197   //! @return transformation of parent object.
198   Standard_EXPORT Standard_Boolean ObjectTransformation (const Standard_Integer theX, const Standard_Integer theY,
199                                                          const Handle(V3d_View)& theView, gp_Trsf& theTrsf);
200
201   //! Make inactive the current selected manipulator part and reset current axis index and current mode.
202   //! After its call HasActiveMode() returns false.
203   //! @sa HasActiveMode()
204   Standard_EXPORT void DeactivateCurrentMode();
205
206   //! Detaches himself from the owner object, and removes itself from context.
207   Standard_EXPORT void Detach();
208
209   //! @return all owning objects.
210   Standard_EXPORT Handle(AIS_ManipulatorObjectSequence) Objects() const;
211
212   //! @return the first (leading) object of the owning objects.
213   Standard_EXPORT Handle(AIS_InteractiveObject) Object() const;
214
215   //! @return one of the owning objects.
216   //! @warning raises program error if theIndex is more than owning objects count or less than 1.
217   Standard_EXPORT Handle(AIS_InteractiveObject) Object (const Standard_Integer theIndex) const;
218
219   //! @return true if manipulator is attached to some interactive object (has owning object).
220   Standard_Boolean IsAttached() const { return HasOwner(); }
221
222   //! @return true if some part of manipulator is selected (transformation mode is active, and owning object can be transformed).
223   Standard_Boolean HasActiveMode() const { return IsAttached() && myCurrentMode != AIS_MM_None; }
224
225   Standard_Boolean HasActiveTransformation() { return myHasStartedTransformation; }
226
227   gp_Trsf StartTransformation() const { return !myStartTrsfs.IsEmpty() ? myStartTrsfs.First() : gp_Trsf(); }
228
229   gp_Trsf StartTransformation (Standard_Integer theIndex) const
230   {
231     Standard_ProgramError_Raise_if (theIndex < 1 || theIndex > Objects()->Upper(),
232       "AIS_Manipulator::StartTransformation(): theIndex is out of bounds");
233     return !myStartTrsfs.IsEmpty() ? myStartTrsfs (theIndex) : gp_Trsf();
234   }
235
236 public: //! @name Configuration of graphical transformations
237
238   //! Enable or disable zoom persistence mode for the manipulator. With
239   //! this mode turned on the presentation will keep fixed screen size.
240   //! @warning when turned on this option overrides transform persistence
241   //! properties and local transformation to achieve necessary visual effect.
242   //! @warning revise use of AdjustSize argument of of \sa AttachToObjects method
243   //! when enabling zoom persistence.
244   Standard_EXPORT void SetZoomPersistence (const Standard_Boolean theToEnable);
245
246   //! Returns state of zoom persistence mode, whether it turned on or off.
247   Standard_Boolean ZoomPersistence() const { return myIsZoomPersistentMode; }
248
249   //! Redefines transform persistence management to setup transformation for sub-presentation of axes.
250   //! @warning this interactive object does not support custom transformation persistence when
251   //! using \sa ZoomPersistence mode. In this mode the transformation persistence flags for
252   //! presentations are overridden by this class.
253   //! @warning Invokes debug assertion to catch incompatible usage of the method with \sa ZoomPersistence mode,
254   //! silently does nothing in release mode.
255   //! @warning revise use of AdjustSize argument of of \sa AttachToObjects method
256   //! when enabling zoom persistence.
257   Standard_EXPORT virtual void SetTransformPersistence (const  Handle(Graphic3d_TransformPers)& theTrsfPers) Standard_OVERRIDE;
258
259 public: //! @name Setters for parameters
260
261   AIS_ManipulatorMode ActiveMode() const { return myCurrentMode; }
262
263   //! @return poition of manipulator interactive object.
264   const gp_Ax2& Position() const { return myPosition; }
265
266   //! Sets position of the manipulator object.
267   Standard_EXPORT void SetPosition (const gp_Ax2& thePosition);
268
269   Standard_ShortReal Size() const { return myAxes[0].Size(); }
270
271   //! Sets size (length of side of the manipulator cubic bounding box.
272   Standard_EXPORT void SetSize (const Standard_ShortReal theSideLength);
273
274   //! Sets gaps between translator, scaler and rotator sub-presentations.
275   Standard_EXPORT void SetGap (const Standard_ShortReal theValue);
276
277 public:
278
279   //! Behavior settings to be applied when performing transformation:
280   //! - FollowTranslation - whether the manipulator will be moved together with an object.
281   //! - FollowRotation - whether the manipulator will be rotated together with an object.
282   struct BehaviorOnTransform {
283
284     BehaviorOnTransform() : FollowTranslation (Standard_True), FollowRotation (Standard_True), FollowDragging (Standard_True) {}
285     BehaviorOnTransform& SetFollowTranslation (const Standard_Boolean theApply) { FollowTranslation = theApply; return *this; }
286     BehaviorOnTransform& SetFollowRotation    (const Standard_Boolean theApply) { FollowRotation    = theApply; return *this; }
287     BehaviorOnTransform& SetFollowDragging    (const Standard_Boolean theApply) { FollowDragging    = theApply; return *this; }
288
289     Standard_Boolean FollowTranslation;
290     Standard_Boolean FollowRotation;
291     Standard_Boolean FollowDragging;
292   };
293
294   //! Sets behavior settings for transformation action carried on the manipulator,
295   //! whether it translates, rotates together with the transformed object or not.
296   void SetTransformBehavior (const BehaviorOnTransform& theSettings) { myBehaviorOnTransform = theSettings; }
297
298   //! @return behavior settings for transformation action of the manipulator.
299   BehaviorOnTransform& ChangeTransformBehavior() { return myBehaviorOnTransform; }
300
301   //! @return behavior settings for transformation action of the manipulator.
302   const BehaviorOnTransform& TransformBehavior() const { return myBehaviorOnTransform; }
303
304 public: //! @name Presentation computation
305
306   //! Fills presentation.
307   //! @note Manipulator presentation does not use display mode and for all modes has the same presentation.
308   Standard_EXPORT virtual void Compute (const Handle(PrsMgr_PresentationManager3d)& thePrsMgr,
309                                         const Handle(Prs3d_Presentation)& thePrs,
310                                         const Standard_Integer theMode = 0) Standard_OVERRIDE;
311
312   //! Computes selection sensitive zones (triangulation) for manipulator.
313   //! @param theNode [in] Selection mode that is treated as transformation mode.
314   Standard_EXPORT virtual void ComputeSelection (const Handle(SelectMgr_Selection)& theSelection,
315                                                  const Standard_Integer theMode) Standard_OVERRIDE;
316
317   //! Disables auto highlighting to use HilightSelected() and HilightOwnerWithColor() overridden methods.
318   virtual Standard_Boolean IsAutoHilight() const Standard_OVERRIDE
319   {
320     return Standard_False;
321   }
322
323   //! Method which clear all selected owners belonging
324   //! to this selectable object ( for fast presentation draw ).
325   Standard_EXPORT virtual void ClearSelected() Standard_OVERRIDE;
326
327   //! Method which draws selected owners ( for fast presentation draw ).
328   Standard_EXPORT virtual void HilightSelected (const Handle(PrsMgr_PresentationManager3d)& thePM, const SelectMgr_SequenceOfOwner& theSeq) Standard_OVERRIDE;
329
330   //! Method which hilight an owner belonging to
331   //! this selectable object  ( for fast presentation draw ).
332   Standard_EXPORT virtual void HilightOwnerWithColor (const Handle(PrsMgr_PresentationManager3d)& thePM,
333                                                       const Handle(Prs3d_Drawer)& theStyle,
334                                                       const Handle(SelectMgr_EntityOwner)& theOwner) Standard_OVERRIDE;
335
336 protected:
337
338   Standard_EXPORT void init();
339
340   Standard_EXPORT void updateTransformation();
341
342   Standard_EXPORT Handle(Prs3d_Presentation) getHighlightPresentation (const Handle(SelectMgr_EntityOwner)& theOwner) const;
343
344   Standard_EXPORT Handle(Graphic3d_Group) getGroup (const Standard_Integer theIndex, const AIS_ManipulatorMode theMode) const;
345
346   Standard_EXPORT void attachToBox (const Bnd_Box& theBox);
347
348   Standard_EXPORT void adjustSize (const Bnd_Box& theBox);
349
350   Standard_EXPORT void setTransformPersistence (const Handle(Graphic3d_TransformPers)& theTrsfPers);
351
352   //! Redefines local transformation management method to inform user of inproper use.
353   //! @warning this interactive object does not support setting custom local transformation,
354   //! this class solely uses this property to implement visual positioning of the manipulator
355   //! without need for recomputing presentation.
356   //! @warning Invokes debug assertion in debug to catch incompatible usage of the
357   //! method, silently does nothing in release mode.
358   Standard_EXPORT virtual void setLocalTransformation (const Handle(Geom_Transformation)& theTrsf) Standard_OVERRIDE;
359   using AIS_InteractiveObject::SetLocalTransformation; // hide visibility
360
361 protected: //! @name Auxiliary classes to fill presentation with proper primitives
362
363   class Quadric
364   {
365   public:
366
367     virtual ~Quadric()
368     {
369       myTriangulation.Nullify();
370       myArray.Nullify();
371     }
372
373
374     const Handle(Poly_Triangulation)& Triangulation() const { return myTriangulation; }
375
376     const Handle(Graphic3d_ArrayOfTriangles)& Array() const { return myArray; }
377
378   protected:
379
380     Handle(Poly_Triangulation) myTriangulation;
381     Handle(Graphic3d_ArrayOfTriangles) myArray;
382   };
383
384   class Disk : public Quadric
385   {
386   public:
387
388     Disk()
389       : Quadric(),
390       myInnerRad(0.0f),
391       myOuterRad(1.0f)
392     { }
393
394     ~Disk() { }
395
396     void Init (const Standard_ShortReal theInnerRadius,
397                const Standard_ShortReal theOuterRadius,
398                const gp_Ax1& thePosition,
399                const Standard_Integer theSlicesNb = 20,
400                const Standard_Integer theStacksNb = 20);
401
402   protected:
403
404     gp_Ax1             myPosition;
405     Standard_ShortReal myInnerRad;
406     Standard_ShortReal myOuterRad;
407   };
408
409   class Sphere : public Quadric
410   {
411   public:
412     Sphere()
413       : Quadric(),
414       myRadius(1.0f)
415     {}
416
417     void Init (const Standard_ShortReal theRadius,
418                const gp_Pnt& thePosition,
419                const Standard_Integer theSlicesNb = 20,
420                const Standard_Integer theStacksNb = 20);
421
422   protected:
423
424     gp_Pnt myPosition;
425     Standard_ShortReal myRadius;
426   };
427
428   class Cube
429   {
430   public:
431
432     Cube() { }
433     ~Cube() { }
434
435     void Init (const gp_Ax1& thePosition, const Standard_ShortReal myBoxSize);
436
437     const Handle(Poly_Triangulation)& Triangulation() const { return myTriangulation; }
438
439     const Handle(Graphic3d_ArrayOfTriangles)& Array() const { return myArray; }
440
441   private:
442
443     void addTriangle (const Standard_Integer theIndex, const gp_Pnt& theP1, const gp_Pnt& theP2, const gp_Pnt& theP3,
444                       const gp_Dir& theNormal);
445
446   protected:
447
448     Handle(Poly_Triangulation) myTriangulation;
449     Handle(Graphic3d_ArrayOfTriangles) myArray;
450   };
451
452   class Sector : public Quadric
453   {
454   public:
455
456     Sector()
457       : Quadric(),
458       myRadius(0.0f)
459     { }
460
461     ~Sector() { }
462
463     void Init(const Standard_ShortReal theRadius,
464               const gp_Ax1&            thePosition,
465               const gp_Dir&            theXDirection,
466               const Standard_Integer   theSlicesNb = 5,
467               const Standard_Integer   theStacksNb = 5);
468
469   protected:
470
471     gp_Ax1             myPosition;
472     Standard_ShortReal myRadius;
473   };
474
475   //! The class describes on axis sub-object.
476   //! It includes sub-objects itself:
477   //! -rotator
478   //! -translator
479   //! -scaler
480   class Axis
481   {
482   public:
483
484     Axis (const gp_Ax1& theAxis              = gp_Ax1(),
485           const Quantity_Color& theColor     = Quantity_Color(),
486           const Standard_ShortReal theLength = 10.0f);
487
488     void Compute (const Handle(PrsMgr_PresentationManager)& thePrsMgr,
489                   const Handle(Prs3d_Presentation)& thePrs,
490                   const Handle(Prs3d_ShadingAspect)& theAspect);
491
492     const gp_Ax1& ReferenceAxis() const { return myReferenceAxis; }
493
494     void SetPosition (const gp_Ax1& thePosition) { myPosition = thePosition; }
495
496     const gp_Ax1& Position() const { return myPosition; }
497
498     void SetTransformPersistence (const Handle(Graphic3d_TransformPers)& theTrsfPers)
499     {
500       if (!myHighlightTranslator.IsNull())
501       {
502         myHighlightTranslator->SetTransformPersistence (theTrsfPers);
503       }
504
505       if (!myHighlightScaler.IsNull())
506       {
507         myHighlightScaler->SetTransformPersistence (theTrsfPers);
508       }
509
510       if (!myHighlightRotator.IsNull())
511       {
512         myHighlightRotator->SetTransformPersistence (theTrsfPers);
513       }
514
515       if (!myHighlightDragger.IsNull())
516       {
517         myHighlightDragger->SetTransformPersistence(theTrsfPers);
518       }
519     }
520
521     void Transform (const Handle(Geom_Transformation)& theTransformation)
522     {
523       if (!myHighlightTranslator.IsNull())
524       {
525         myHighlightTranslator->SetTransformation (theTransformation);
526       }
527
528       if (!myHighlightScaler.IsNull())
529       {
530         myHighlightScaler->SetTransformation (theTransformation);
531       }
532
533       if (!myHighlightRotator.IsNull())
534       {
535         myHighlightRotator->SetTransformation (theTransformation);
536       }
537
538       if (!myHighlightDragger.IsNull())
539       {
540         myHighlightDragger->SetTransformation(theTransformation);
541       }
542     }
543
544     Standard_Boolean HasTranslation() const { return myHasTranslation; }
545
546     Standard_Boolean HasRotation() const { return myHasRotation; }
547
548     Standard_Boolean HasScaling() const { return myHasScaling; }
549
550     Standard_Boolean HasDragging() const { return myHasDragging; }
551
552     void SetTranslation (const Standard_Boolean theIsEnabled) { myHasTranslation = theIsEnabled; }
553
554     void SetRotation (const Standard_Boolean theIsEnabled) { myHasRotation = theIsEnabled; }
555
556     void SetScaling (const Standard_Boolean theIsEnabled) { myHasScaling = theIsEnabled; }
557
558     void SetDragging(const Standard_Boolean theIsEnabled) { myHasDragging = theIsEnabled; }
559
560     Quantity_Color Color() const { return myColor; }
561
562     Standard_ShortReal AxisLength() const { return myLength; }
563
564     Standard_ShortReal AxisRadius() const { return myAxisRadius; }
565
566     void SetAxisRadius (const Standard_ShortReal theValue) { myAxisRadius = theValue; }
567
568     const Handle(Prs3d_Presentation)& TranslatorHighlightPrs() const { return myHighlightTranslator; }
569
570     const Handle(Prs3d_Presentation)& RotatorHighlightPrs() const { return myHighlightRotator; }
571
572     const Handle(Prs3d_Presentation)& ScalerHighlightPrs() const { return myHighlightScaler; }
573
574     const Handle(Prs3d_Presentation)& DraggerHighlightPrs() const { return myHighlightDragger; }
575
576     const Handle(Graphic3d_Group)& TranslatorGroup() const { return myTranslatorGroup; }
577
578     const Handle(Graphic3d_Group)& RotatorGroup() const { return myRotatorGroup; }
579
580     const Handle(Graphic3d_Group)& ScalerGroup() const { return myScalerGroup; }
581
582     const Handle(Graphic3d_Group)& DraggerGroup() const { return myDraggerGroup; }
583
584     const Handle(Graphic3d_ArrayOfTriangles)& TriangleArray() const { return myTriangleArray; }
585
586     void SetIndent (const Standard_ShortReal theValue) { myIndent = theValue; }
587
588     Standard_ShortReal Size() const { return myLength + myBoxSize + myDiskThickness + myIndent * 2.0f; }
589
590     gp_Pnt ScalerCenter (const gp_Pnt& theLocation) const { return theLocation.XYZ() + myPosition.Direction().XYZ() * (myLength + myIndent + myBoxSize * 0.5f); }
591
592     void SetSize (const Standard_ShortReal theValue)
593     {
594       if (myIndent > theValue * 0.1f)
595       {
596         myLength = theValue * 0.7f;
597         myBoxSize = theValue * 0.15f;
598         myDiskThickness = theValue * 0.05f;
599         myIndent = theValue * 0.05f;
600       }
601       else // use pre-set value of predent
602       {
603         Standard_ShortReal aLength = theValue - 2 * myIndent;
604         myLength = aLength * 0.8f;
605         myBoxSize = aLength * 0.15f;
606         myDiskThickness = aLength * 0.05f;
607       }
608       myInnerRadius = myIndent * 2 + myBoxSize + myLength;
609       myAxisRadius = myBoxSize / 4.0f;
610     }
611
612     Standard_Integer FacettesNumber() const { return myFacettesNumber; }
613
614   public:
615
616     const gp_Pnt& TranslatorTipPosition() const { return myArrowTipPos; }
617     const Sector& DraggerSector() const { return mySector; }
618     const Disk& RotatorDisk() const { return myCircle; }
619     float RotatorDiskRadius() const { return myCircleRadius; }
620     const Cube& ScalerCube() const { return myCube; }
621     const gp_Pnt& ScalerCubePosition() const { return myCubePos; }
622
623   protected:
624
625     gp_Ax1 myReferenceAxis; //!< Returns reference axis assignment.
626     gp_Ax1 myPosition; //!< Position of the axis including local transformation.
627     Quantity_Color myColor;
628
629     Standard_Boolean myHasTranslation;
630     Standard_ShortReal myLength; //!< Length of translation axis.
631     Standard_ShortReal myAxisRadius;
632
633     Standard_Boolean myHasScaling;
634     Standard_ShortReal myBoxSize; //!< Size of scaling cube.
635
636     Standard_Boolean myHasRotation;
637     Standard_ShortReal myInnerRadius; //!< Radius of rotation circle.
638     Standard_ShortReal myDiskThickness;
639     Standard_ShortReal myIndent; //!< Gap between visual part of the manipulator.
640
641     Standard_Boolean myHasDragging;
642
643   protected:
644
645     Standard_Integer myFacettesNumber;
646
647     gp_Pnt   myArrowTipPos;
648     Sector   mySector;
649     Disk     myCircle;
650     float    myCircleRadius;
651     Cube     myCube;
652     gp_Pnt   myCubePos;
653
654     Handle(Graphic3d_Group) myTranslatorGroup;
655     Handle(Graphic3d_Group) myScalerGroup;
656     Handle(Graphic3d_Group) myRotatorGroup;
657     Handle(Graphic3d_Group) myDraggerGroup;
658
659     Handle(Prs3d_Presentation) myHighlightTranslator;
660     Handle(Prs3d_Presentation) myHighlightScaler;
661     Handle(Prs3d_Presentation) myHighlightRotator;
662     Handle(Prs3d_Presentation) myHighlightDragger;
663
664     Handle(Graphic3d_ArrayOfTriangles) myTriangleArray;
665
666   };
667
668 protected:
669
670   Axis myAxes[3]; //!< Tree axes of the manipulator.
671   Sphere myCenter; //!< Visual part displaying the center sphere of the manipulator.
672   gp_Ax2 myPosition; //!< Position of the manipulator object. it displays its location and position of its axes.
673
674   Standard_Integer myCurrentIndex; //!< Index of active axis.
675   AIS_ManipulatorMode myCurrentMode; //!< Name of active manipulation mode.
676
677   Standard_Boolean myIsActivationOnDetection; //!< Manual activation of modes (not on parts selection).
678   Standard_Boolean myIsZoomPersistentMode; //!< Zoom persistence mode activation.
679   BehaviorOnTransform myBehaviorOnTransform; //!< Behavior settings applied on manipulator when transforming an object.
680
681 protected: //! @name Fields for interactive transformation. Fields only for internal needs. They do not have public interface.
682
683   NCollection_Sequence<gp_Trsf> myStartTrsfs; //!< Owning object transformation for start. It is used internally.
684   Standard_Boolean myHasStartedTransformation; //!< Shows if transformation is processed (sequential calls of Transform()).
685   gp_Ax2 myStartPosition; //! Start position of manipulator.
686   gp_Pnt myStartPick; //! 3d point corresponding to start mouse pick.
687   Standard_Real myPrevState; //! Previous value of angle during rotation.
688
689   //! Aspect used to color current detected part and current selected part.
690   Handle(Prs3d_ShadingAspect) myHighlightAspect;
691
692   //! Aspect used to color sector part when it's selected.
693   Handle(Prs3d_ShadingAspect) myDraggerHighlight;
694 public:
695
696   DEFINE_STANDARD_RTTIEXT(AIS_Manipulator, AIS_InteractiveObject)
697 };
698 #endif // _AIS_Manipulator_HeaderFile