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