2434229b6db1097e22f3981d47d848488d0fd3fa
[occt.git] / src / AIS / AIS_Manipulator.cxx
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 #include <AIS_Manipulator.hxx>
17
18 #include <AIS_InteractiveContext.hxx>
19 #include <AIS_ManipulatorOwner.hxx>
20 #include <gce_MakeDir.hxx>
21 #include <GeomAPI_ExtremaCurveCurve.hxx>
22 #include <GeomAPI_IntCS.hxx>
23 #include <Geom_Circle.hxx>
24 #include <Geom_Line.hxx>
25 #include <Geom_Plane.hxx>
26 #include <Geom_Transformation.hxx>
27 #include <Prs3d_Root.hxx>
28 #include <Prs3d_ShadingAspect.hxx>
29 #include <Select3D_SensitiveCircle.hxx>
30 #include <Select3D_SensitivePoint.hxx>
31 #include <Select3D_SensitiveSegment.hxx>
32 #include <Select3D_SensitiveTriangulation.hxx>
33 #include <SelectMgr_SequenceOfOwner.hxx>
34 #include <StdPrs_ToolDisk.hxx>
35 #include <StdPrs_ToolCylinder.hxx>
36 #include <StdPrs_ToolSphere.hxx>
37 #include <TColgp_Array1OfPnt.hxx>
38 #include <V3d_View.hxx>
39
40 IMPLEMENT_STANDARD_HANDLE (AIS_Manipulator, AIS_InteractiveObject)
41 IMPLEMENT_STANDARD_RTTIEXT(AIS_Manipulator, AIS_InteractiveObject)
42
43 IMPLEMENT_HSEQUENCE(AIS_ManipulatorObjectSequence)
44
45 //=======================================================================
46 //function : init
47 //purpose  : 
48 //=======================================================================
49 void AIS_Manipulator::init()
50 {
51   // Create axis in the default coordinate system. The custom position is applied in local transformation.
52   myAxes[0] = Axis (gp::OX(), Quantity_NOC_RED);
53   myAxes[1] = Axis (gp::OY(), Quantity_NOC_GREEN);
54   myAxes[2] = Axis (gp::OZ(), Quantity_NOC_BLUE1);
55
56   Graphic3d_MaterialAspect aShadingMaterial;
57   aShadingMaterial.SetReflectionModeOff (Graphic3d_TOR_SPECULAR);
58   aShadingMaterial.SetMaterialType (Graphic3d_MATERIAL_ASPECT);
59
60   myDrawer->SetShadingAspect (new Prs3d_ShadingAspect());
61   myDrawer->ShadingAspect()->Aspect()->SetInteriorStyle (Aspect_IS_SOLID);
62   myDrawer->ShadingAspect()->SetColor (Quantity_NOC_WHITE);
63   myDrawer->ShadingAspect()->SetMaterial (aShadingMaterial);
64
65   Graphic3d_MaterialAspect aHilightMaterial;
66   aHilightMaterial.SetColor (Quantity_NOC_AZURE);
67   aHilightMaterial.SetReflectionModeOff (Graphic3d_TOR_AMBIENT);
68   aHilightMaterial.SetReflectionModeOff (Graphic3d_TOR_DIFFUSE);
69   aHilightMaterial.SetReflectionModeOff (Graphic3d_TOR_SPECULAR);
70   aHilightMaterial.SetReflectionModeOff (Graphic3d_TOR_EMISSION);
71   aHilightMaterial.SetMaterialType (Graphic3d_MATERIAL_ASPECT);
72
73   myHighlightAspect = new Prs3d_ShadingAspect();
74   myHighlightAspect->Aspect()->SetInteriorStyle (Aspect_IS_SOLID);
75   myHighlightAspect->SetMaterial (aHilightMaterial);
76
77   SetSize (100);
78   SetZLayer (Graphic3d_ZLayerId_Topmost);
79 }
80
81 //=======================================================================
82 //function : getHighlightPresentation
83 //purpose  : 
84 //=======================================================================
85 Handle(Prs3d_Presentation) AIS_Manipulator::getHighlightPresentation (const Handle(SelectMgr_EntityOwner)& theOwner) const
86 {
87   Handle(Prs3d_Presentation) aDummyPrs;
88   Handle(AIS_ManipulatorOwner) anOwner = Handle(AIS_ManipulatorOwner)::DownCast (theOwner);
89   if (anOwner.IsNull())
90   {
91     return aDummyPrs;
92   }
93
94   switch (anOwner->Mode())
95   {
96     case AIS_MM_Translation: return myAxes[anOwner->Index()].TranslatorHighlightPrs();
97     case AIS_MM_Rotation   : return myAxes[anOwner->Index()].RotatorHighlightPrs();
98     case AIS_MM_Scaling    : return myAxes[anOwner->Index()].ScalerHighlightPrs();
99     case AIS_MM_None       : break;
100   }
101
102   return aDummyPrs;
103 }
104
105 //=======================================================================
106 //function : getGroup
107 //purpose  : 
108 //=======================================================================
109 Handle(Graphic3d_Group) AIS_Manipulator::getGroup (const Standard_Integer theIndex, const AIS_ManipulatorMode theMode) const
110 {
111   Handle(Graphic3d_Group) aDummyGroup;
112
113   if (theIndex < 0 || theIndex > 2)
114   {
115     return aDummyGroup;
116   }
117
118   switch (theMode)
119   {
120     case AIS_MM_Translation: return myAxes[theIndex].TranslatorGroup();
121     case AIS_MM_Rotation   : return myAxes[theIndex].RotatorGroup();
122     case AIS_MM_Scaling    : return myAxes[theIndex].ScalerGroup();
123     case AIS_MM_None       : break;
124   }
125
126   return aDummyGroup;
127 }
128
129 //=======================================================================
130 //function : Constructor
131 //purpose  : 
132 //=======================================================================
133 AIS_Manipulator::AIS_Manipulator()
134 : myPosition (gp::XOY()),
135   myCurrentIndex (-1),
136   myCurrentMode (AIS_MM_None),
137   myIsActivationOnDetection (Standard_False),
138   myIsZoomPersistentMode (Standard_True),
139   myHasStartedTransformation (Standard_False),
140   myStartPosition (gp::XOY()),
141   myStartPick (0.0, 0.0, 0.0),
142   myPrevState (0.0)
143 {
144   SetInfiniteState();
145   SetMutable (Standard_True);
146   SetDisplayMode (AIS_Shaded);
147   init();
148 }
149
150 //=======================================================================
151 //function : Constructor
152 //purpose  : 
153 //=======================================================================
154 AIS_Manipulator::AIS_Manipulator (const gp_Ax2& thePosition)
155 : myPosition (thePosition),
156   myCurrentIndex (-1),
157   myCurrentMode (AIS_MM_None),
158   myIsActivationOnDetection (Standard_False),
159   myIsZoomPersistentMode (Standard_True),
160   myHasStartedTransformation (Standard_False),
161   myStartPosition (gp::XOY()),
162   myStartPick (0.0, 0.0, 0.0),
163   myPrevState (0.0)
164 {
165   SetInfiniteState();
166   SetMutable (Standard_True);
167   SetDisplayMode (AIS_Shaded);
168   init();
169 }
170
171 //=======================================================================
172 //function : SetPart
173 //purpose  : 
174 //=======================================================================
175 void AIS_Manipulator::SetPart (const Standard_Integer theAxisIndex, const AIS_ManipulatorMode theMode, const Standard_Boolean theIsEnabled)
176 {
177   Standard_ProgramError_Raise_if (theAxisIndex < 0 || theAxisIndex > 2, "AIS_Manipulator::SetMode(): axis index should be between 0 and 2");
178   switch (theMode)
179   {
180     case AIS_MM_Translation:
181       myAxes[theAxisIndex].SetTranslation (theIsEnabled);
182       break;
183
184     case AIS_MM_Rotation:
185       myAxes[theAxisIndex].SetRotation (theIsEnabled);
186       break;
187
188     case AIS_MM_Scaling:
189       myAxes[theAxisIndex].SetScaling (theIsEnabled);
190       break;
191
192     case AIS_MM_None:
193       break;
194   }
195 }
196
197 //=======================================================================
198 //function : EnableMode
199 //purpose  : 
200 //=======================================================================
201 void AIS_Manipulator::EnableMode (const AIS_ManipulatorMode theMode)
202 {
203   if (!IsAttached())
204   {
205     return;
206   }
207
208   const Handle(AIS_InteractiveContext)& aContext = GetContext();
209   if (aContext.IsNull())
210   {
211     return;
212   }
213
214   aContext->Activate (this, theMode);
215 }
216
217 //=======================================================================
218 //function : attachToBox
219 //purpose  : 
220 //=======================================================================
221 void AIS_Manipulator::attachToBox (const Bnd_Box& theBox)
222 {
223   if (theBox.IsVoid())
224   {
225     return;
226   }
227
228   Standard_Real anXmin = 0.0, anYmin = 0.0, aZmin = 0.0, anXmax = 0.0, anYmax = 0.0, aZmax = 0.0;
229   theBox.Get (anXmin, anYmin, aZmin, anXmax, anYmax, aZmax);
230
231   gp_Ax2 aPosition = gp::XOY();
232   aPosition.SetLocation (gp_Pnt ((anXmin + anXmax) * 0.5, (anYmin + anYmax) * 0.5, (aZmin + aZmax) * 0.5));
233   SetPosition (aPosition);
234 }
235
236 //=======================================================================
237 //function : adjustSize
238 //purpose  : 
239 //=======================================================================
240 void AIS_Manipulator::adjustSize (const Bnd_Box& theBox)
241 {
242   Standard_Real aXmin = 0., aYmin = 0., aZmin = 0., aXmax = 0., aYmax = 0., aZmax = 0.0;
243   theBox.Get (aXmin, aYmin, aZmin, aXmax, aYmax, aZmax);
244   Standard_Real aXSize = aXmax - aXmin;
245   Standard_Real aYSize = aYmax - aYmin;
246   Standard_Real aZSize  = aZmax  - aZmin;
247
248   SetSize ((Standard_ShortReal) (Max (aXSize, Max (aYSize, aZSize)) * 0.5));
249 }
250
251 //=======================================================================
252 //function : Attach
253 //purpose  : 
254 //=======================================================================
255 void AIS_Manipulator::Attach (const Handle(AIS_InteractiveObject)& theObject, const OptionsForAttach& theOptions)
256 {
257   if (theObject->IsKind (STANDARD_TYPE(AIS_Manipulator)))
258   {
259     return;
260   }
261
262   Handle(AIS_ManipulatorObjectSequence) aSeq = new AIS_ManipulatorObjectSequence();
263   aSeq->Append (theObject);
264   Attach (aSeq, theOptions);
265 }
266
267 //=======================================================================
268 //function : Attach
269 //purpose  : 
270 //=======================================================================
271 void AIS_Manipulator::Attach (const Handle(AIS_ManipulatorObjectSequence)& theObjects, const OptionsForAttach& theOptions)
272 {
273   if (theObjects->Size() < 1)
274   {
275     return;
276   }
277
278   SetOwner (theObjects);
279   Bnd_Box aBox;
280   const Handle(AIS_InteractiveObject)& aCurObject = theObjects->Value (theObjects->Lower());
281   aCurObject->BoundingBox (aBox);
282
283   if (theOptions.AdjustPosition)
284   {
285     attachToBox (aBox);
286   }
287
288   if (theOptions.AdjustSize)
289   {
290     adjustSize (aBox);
291   }
292
293   const Handle(AIS_InteractiveContext)& aContext = Object()->GetContext();
294   if (!aContext.IsNull())
295   {
296     if (!aContext->IsDisplayed (this))
297     {
298       aContext->Display (this, Standard_False);
299     }
300     else
301     {
302       aContext->Update (this, Standard_False);
303       aContext->RecomputeSelectionOnly (this);
304     }
305
306     aContext->Load (this);
307     aContext->CurrentViewer()->RedrawImmediate();
308   }
309
310   if (theOptions.EnableModes)
311   {
312     EnableMode (AIS_MM_Rotation);
313     EnableMode (AIS_MM_Translation);
314     EnableMode (AIS_MM_Scaling);
315   }
316 }
317
318 //=======================================================================
319 //function : Detach
320 //purpose  : 
321 //=======================================================================
322 void AIS_Manipulator::Detach()
323 {
324   DeactivateCurrentMode();
325
326   if (!IsAttached())
327   {
328     return;
329   }
330
331   Handle(AIS_InteractiveObject) anObject = Object();
332   const Handle(AIS_InteractiveContext)& aContext = anObject->GetContext();
333   if (!aContext.IsNull())
334   {
335     aContext->Remove (this, Standard_False);
336   }
337
338   SetOwner (NULL);
339 }
340
341 //=======================================================================
342 //function : Objects
343 //purpose  : 
344 //=======================================================================
345 Handle(AIS_ManipulatorObjectSequence) AIS_Manipulator::Objects() const
346 {
347   return Handle(AIS_ManipulatorObjectSequence)::DownCast (GetOwner());
348 }
349
350 //=======================================================================
351 //function : Object
352 //purpose  : 
353 //=======================================================================
354 Handle(AIS_InteractiveObject) AIS_Manipulator::Object (const Standard_Integer theIndex) const
355 {
356   Handle(AIS_ManipulatorObjectSequence) anOwner = Handle(AIS_ManipulatorObjectSequence)::DownCast (GetOwner());
357
358   Standard_ProgramError_Raise_if (theIndex < anOwner->Lower() || theIndex > anOwner->Upper(), "AIS_Manipulator::Object(): wrong index value");
359
360   if (anOwner.IsNull() || anOwner->IsEmpty())
361   {
362     return NULL;
363   }
364
365   return anOwner->Value (theIndex);
366 }
367
368 //=======================================================================
369 //function : Object
370 //purpose  : 
371 //=======================================================================
372 Handle(AIS_InteractiveObject) AIS_Manipulator::Object() const
373 {
374   return Object (1);
375 }
376
377 //=======================================================================
378 //function : ObjectTransformation
379 //purpose  : 
380 //=======================================================================
381 Standard_Boolean AIS_Manipulator::ObjectTransformation (const Standard_Integer theMaxX, const Standard_Integer theMaxY,
382                                                         const Handle(V3d_View)& theView, gp_Trsf& theTrsf)
383 {
384   // Initialize start reference data
385   if (!myHasStartedTransformation)
386   {
387     Handle(AIS_ManipulatorObjectSequence) anObjects = Objects();
388     myStartTrsfs.Clear();
389     for (Standard_Integer anIt = anObjects->Lower(); anIt <= anObjects->Upper(); ++anIt)
390     {
391       myStartTrsfs.Append (anObjects->Value (anIt)->LocalTransformation());
392     }
393     myStartPosition = myPosition;
394   }
395
396   // Get 3d point with projection vector
397   Graphic3d_Vec3d anInputPoint;
398   Graphic3d_Vec3d aProj;
399   theView->ConvertWithProj (theMaxX, theMaxY, anInputPoint.x(), anInputPoint.y(), anInputPoint.z(), aProj.x(), aProj.y(), aProj.z());
400   gp_Lin anInputLine (gp_Pnt (anInputPoint.x(), anInputPoint.y(), anInputPoint.z()), gp_Dir (aProj.x(), aProj.y(), aProj.z()));
401   gp_Pnt aNewPosition = gp::Origin();
402
403   switch (myCurrentMode)
404   {
405     case AIS_MM_Translation:
406     {
407       gp_Lin aLine (myStartPick, myAxes[myCurrentIndex].Position().Direction());
408       Handle(Geom_Curve) anInputCurve = new Geom_Line (anInputLine);
409       Handle(Geom_Curve) aCurve = new Geom_Line (aLine);
410       GeomAPI_ExtremaCurveCurve anExtrema (anInputCurve, aCurve);
411       gp_Pnt aP1, aP2;
412       anExtrema.NearestPoints (aP1, aP2);
413       aNewPosition = aP2;
414
415       if (!myHasStartedTransformation)
416       {
417         myStartPick = aNewPosition;
418         myHasStartedTransformation = Standard_True;
419         return Standard_True;
420       }
421
422       if (aNewPosition.Distance (myStartPick) < Precision::Confusion())
423       {
424         return Standard_False;
425       }
426
427       gp_Trsf aNewTrsf;
428       aNewTrsf.SetTranslation (gp_Vec(myStartPick, aNewPosition));
429       theTrsf *= aNewTrsf;
430       break;
431     }
432     case AIS_MM_Rotation:
433     {
434       Handle(Geom_Curve) anInputCurve = new Geom_Line (anInputLine);
435       Handle(Geom_Surface) aSurface = new Geom_Plane (myPosition.Location(), myAxes[myCurrentIndex].Position().Direction());
436       GeomAPI_IntCS aIntersector (anInputCurve, aSurface);
437       if (!aIntersector.IsDone() || aIntersector.NbPoints() < 1)
438       {
439         return Standard_False;
440       }
441
442       aNewPosition = aIntersector.Point (1);
443
444       if (!myHasStartedTransformation)
445       {
446         myStartPick = aNewPosition;
447         myHasStartedTransformation = Standard_True;
448         gp_Dir aStartAxis = gce_MakeDir (myPosition.Location(), myStartPick);
449         myPrevState = aStartAxis.AngleWithRef (gce_MakeDir(myPosition.Location(), aNewPosition), myAxes[myCurrentIndex].Position().Direction());
450         return Standard_True;
451       }
452
453       if (aNewPosition.Distance (myStartPick) < Precision::Confusion())
454       {
455         return Standard_False;
456       }
457
458       gp_Dir aStartAxis = myPosition.Location().IsEqual (myStartPick, Precision::Confusion())
459         ? myAxes[(myCurrentIndex + 1) % 3].Position().Direction()
460         : gce_MakeDir (myPosition.Location(), myStartPick);
461
462       gp_Dir aCurrentAxis = gce_MakeDir (myPosition.Location(), aNewPosition);
463       Standard_Real anAngle = aStartAxis.AngleWithRef (aCurrentAxis, myAxes[myCurrentIndex].Position().Direction());
464
465       // Change value of an angle if it should have different sign.
466       if (anAngle * myPrevState < 0 && Abs (anAngle) < M_PI_2)
467       {
468         Standard_ShortReal aSign = myPrevState > 0 ? -1.0f : 1.0f;
469         anAngle = aSign * (M_PI * 2 - anAngle);
470       }
471
472       if (Abs (anAngle) < Precision::Confusion())
473       {
474         return Standard_False;
475       }
476
477       gp_Trsf aNewTrsf;
478       aNewTrsf.SetRotation (myAxes[myCurrentIndex].Position(), anAngle);
479       theTrsf *= aNewTrsf;
480       myPrevState = anAngle;
481       break;
482     }
483     case AIS_MM_Scaling:
484     {
485       gp_Lin aLine (myStartPosition.Location(), myAxes[myCurrentIndex].Position().Direction());
486       Handle(Geom_Curve) anInputCurve = new Geom_Line (anInputLine);
487       Handle(Geom_Curve) aCurve = new Geom_Line (aLine);
488       GeomAPI_ExtremaCurveCurve anExtrema (anInputCurve, aCurve);
489       gp_Pnt aTmp;
490       anExtrema.NearestPoints (aTmp, aNewPosition);
491
492       if (!myHasStartedTransformation)
493       {
494         myStartPick = aNewPosition;
495         myHasStartedTransformation = Standard_True;
496         return Standard_True;
497       }
498
499       if (aNewPosition.Distance (myStartPick) < Precision::Confusion() 
500        || aNewPosition.Distance (myStartPosition.Location()) < Precision::Confusion())
501       {
502         return Standard_False;
503       }
504
505       Standard_Real aCoeff = myStartPosition.Location().Distance (aNewPosition)
506                            / myStartPosition.Location().Distance (myStartPick);
507       gp_Trsf aNewTrsf;
508       aNewTrsf.SetScale (myPosition.Location(), aCoeff);
509
510       theTrsf = aNewTrsf;
511       break;
512     }
513     case AIS_MM_None:
514       return Standard_False;
515   }
516
517   return Standard_True;
518 }
519
520 //=======================================================================
521 //function : StartTransform
522 //purpose  : 
523 //=======================================================================
524 void AIS_Manipulator::StartTransform (const Standard_Integer theX, const Standard_Integer theY, const Handle(V3d_View)& theView)
525 {
526   if (myHasStartedTransformation)
527   {
528     return;
529   }
530
531   gp_Trsf aTrsf;
532   ObjectTransformation (theX, theY, theView, aTrsf);
533 }
534
535 //=======================================================================
536 //function : StopTransform
537 //purpose  : 
538 //=======================================================================
539 void AIS_Manipulator::StopTransform (const Standard_Boolean theToApply)
540 {
541   if (!IsAttached() || !myHasStartedTransformation)
542   {
543     return;
544   }
545
546   myHasStartedTransformation = Standard_False;
547
548   if (!theToApply)
549   {
550     Handle(AIS_ManipulatorObjectSequence) anObjects = Objects();
551
552     for (Standard_Integer anIt = anObjects->Lower(); anIt <= anObjects->Upper(); ++anIt)
553     {
554       anObjects->Value (anIt)->SetLocalTransformation (myStartTrsfs(anIt));
555     }
556
557     SetPosition (myStartPosition);
558   }
559 }
560
561 //=======================================================================
562 //function : Transform
563 //purpose  : 
564 //=======================================================================
565 void AIS_Manipulator::Transform (const gp_Trsf& theTrsf)
566 {
567   if (!IsAttached() || !myHasStartedTransformation)
568   {
569     return;
570   }
571
572   Handle(AIS_ManipulatorObjectSequence) anObjects = Objects();
573
574   for (Standard_Integer anIt = anObjects->Lower(); anIt <= anObjects->Upper(); ++anIt)
575   {
576     anObjects->Value (anIt)->SetLocalTransformation (theTrsf * myStartTrsfs(anIt));
577   }
578
579   if ((myCurrentMode == AIS_MM_Translation && myBehaviorOnTransform.FollowTranslation)
580    || (myCurrentMode == AIS_MM_Rotation    && myBehaviorOnTransform.FollowRotation))
581   {
582     gp_Pnt aPos  = myStartPosition.Location().Transformed (theTrsf);
583     gp_Dir aVDir = myStartPosition.Direction().Transformed (theTrsf);
584     gp_Dir aXDir = myStartPosition.XDirection().Transformed (theTrsf);
585     SetPosition (gp_Ax2 (aPos, aVDir, aXDir));
586   }
587 }
588
589 //=======================================================================
590 //function : Transform
591 //purpose  : 
592 //=======================================================================
593 gp_Trsf AIS_Manipulator::Transform (const Standard_Integer thePX, const Standard_Integer thePY,
594                                     const Handle(V3d_View)& theView)
595 {
596   gp_Trsf aTrsf;
597   if (ObjectTransformation (thePX, thePY, theView, aTrsf))
598   {
599     Transform (aTrsf);
600   }
601
602   return aTrsf;
603 }
604
605 //=======================================================================
606 //function : SetPosition
607 //purpose  : 
608 //=======================================================================
609 void AIS_Manipulator::SetPosition (const gp_Ax2& thePosition)
610 {
611   if (!myPosition.Location().IsEqual (thePosition.Location(), Precision::Confusion())
612    || !myPosition.Direction().IsEqual (thePosition.Direction(), Precision::Angular())
613    || !myPosition.XDirection().IsEqual (thePosition.XDirection(), Precision::Angular()))
614   {
615     myPosition = thePosition;
616     myAxes[0].SetPosition (gp_Ax1 (myPosition.Location(), myPosition.XDirection()));
617     myAxes[1].SetPosition (gp_Ax1 (myPosition.Location(), myPosition.YDirection()));
618     myAxes[2].SetPosition (gp_Ax1 (myPosition.Location(), myPosition.Direction()));
619
620     updateTransformation();
621   }
622 }
623
624 //=======================================================================
625 //function : updateTransformation
626 //purpose  : set local transformation to avoid graphics recomputation
627 //=======================================================================
628 void AIS_Manipulator::updateTransformation()
629 {
630   gp_Trsf aTrsf;
631
632   if (!myIsZoomPersistentMode)
633   {
634     aTrsf.SetTransformation (myPosition, gp::XOY());
635   }
636   else
637   {
638     const gp_Dir& aVDir = myPosition.Direction();
639     const gp_Dir& aXDir = myPosition.XDirection();
640     aTrsf.SetTransformation (gp_Ax2 (gp::Origin(), aVDir, aXDir), gp::XOY());
641   }
642
643   AIS_InteractiveObject::SetLocalTransformation (aTrsf);
644
645   Handle(Geom_Transformation) aGeomTrsf = new Geom_Transformation (this->Transformation());
646
647   for (Standard_Integer anIt = 0; anIt < 3; ++anIt)
648   {
649     myAxes[anIt].Transform (aGeomTrsf);
650   }
651
652   if (myIsZoomPersistentMode)
653   {
654     if (!(GetTransformPersistenceMode () == Graphic3d_TMF_ZoomPers
655        && GetTransformPersistencePoint().IsEqual (myPosition.Location(), 0.)))
656     {
657       setTransformPersistence (Graphic3d_TMF_ZoomPers, myPosition.Location());
658     }
659   }
660 }
661
662 //=======================================================================
663 //function : SetSize
664 //purpose  : 
665 //=======================================================================
666 void AIS_Manipulator::SetSize (const Standard_ShortReal theSideLength)
667 {
668   for (Standard_Integer anIt = 0; anIt < 3; ++anIt)
669   {
670     myAxes[anIt].SetSize (theSideLength);
671   }
672
673   SetToUpdate();
674 }
675
676 //=======================================================================
677 //function : SetGap
678 //purpose  : 
679 //=======================================================================
680 void AIS_Manipulator::SetGap (const Standard_ShortReal theValue)
681 {
682   for (Standard_Integer anIt = 0; anIt < 3; ++anIt)
683   {
684     myAxes[anIt].SetIndent (theValue);
685   }
686
687   SetToUpdate();
688 }
689
690 //=======================================================================
691 //function : DeactivateCurrentMode
692 //purpose  : 
693 //=======================================================================
694 void AIS_Manipulator::DeactivateCurrentMode()
695 {
696   if (!myIsActivationOnDetection)
697   {
698     Handle(Graphic3d_Group) aGroup = getGroup (myCurrentIndex, myCurrentMode);
699     if (aGroup.IsNull())
700     {
701       return;
702     }
703
704     Handle(Prs3d_ShadingAspect) anAspect = new Prs3d_ShadingAspect();
705     anAspect->Aspect()->SetInteriorStyle (Aspect_IS_SOLID);
706     anAspect->SetMaterial (myDrawer->ShadingAspect()->Material());
707     anAspect->SetTransparency (myDrawer->ShadingAspect()->Transparency());
708     anAspect->SetColor (myAxes[myCurrentIndex].Color());
709
710     aGroup->SetGroupPrimitivesAspect (anAspect->Aspect());
711   }
712
713   myCurrentIndex = -1;
714   myCurrentMode = AIS_MM_None;
715
716   if (myHasStartedTransformation)
717   {
718     myHasStartedTransformation = Standard_False;
719   }
720 }
721
722 //=======================================================================
723 //function : SetZoomPersistence
724 //purpose  : 
725 //=======================================================================
726 void AIS_Manipulator::SetZoomPersistence (const Standard_Boolean theToEnable)
727 {
728   if (myIsZoomPersistentMode != theToEnable)
729   {
730     SetToUpdate();
731   }
732
733   myIsZoomPersistentMode = theToEnable;
734
735   if (!theToEnable)
736   {
737     setTransformPersistence (Graphic3d_TMF_None, gp::Origin());
738   }
739
740   updateTransformation();
741 }
742
743 //=======================================================================
744 //function : SetTransformPersistence
745 //purpose  : 
746 //=======================================================================
747 void AIS_Manipulator::SetTransformPersistence (const Graphic3d_TransModeFlags& theFlag, const gp_Pnt& thePoint)
748 {
749   Standard_ASSERT_RETURN (!myIsZoomPersistentMode,
750     "AIS_Manipulator::SetTransformPersistence: "
751     "Custom settings are not supported by this class in ZoomPersistence mode",);
752
753   setTransformPersistence (theFlag, thePoint);
754 }
755
756 //=======================================================================
757 //function : setTransformPersistence
758 //purpose  : 
759 //=======================================================================
760 void AIS_Manipulator::setTransformPersistence (const Graphic3d_TransModeFlags& theFlag, const gp_Pnt& thePoint)
761 {
762   AIS_InteractiveObject::SetTransformPersistence (theFlag, thePoint);
763
764   for (Standard_Integer anIt = 0; anIt < 3; ++anIt)
765   {
766     myAxes[anIt].SetTransformPersistence (theFlag, thePoint);
767   }
768 }
769
770 //=======================================================================
771 //function : SetLocalTransformation
772 //purpose  : 
773 //=======================================================================
774 void AIS_Manipulator::SetLocalTransformation (const gp_Trsf& /*theTransformation*/)
775 {
776   Standard_ASSERT_INVOKE (
777     "AIS_Manipulator::SetLocalTransformation: "
778     "Custom transformation is not supported by this class");
779 }
780
781 //=======================================================================
782 //function : Compute
783 //purpose  : 
784 //=======================================================================
785 void AIS_Manipulator::Compute (const Handle(PrsMgr_PresentationManager3d)& thePrsMgr,
786                                const Handle(Prs3d_Presentation)& thePrs,
787                                const Standard_Integer theMode)
788 {
789   if (theMode != AIS_Shaded)
790   {
791     return;
792   }
793
794   thePrs->SetInfiniteState (Standard_True);
795   thePrs->SetMutable (Standard_True);
796   Handle(Graphic3d_Group) aGroup;
797   Handle(Prs3d_ShadingAspect) anAspect = new Prs3d_ShadingAspect();
798   anAspect->Aspect()->SetInteriorStyle (Aspect_IS_SOLID);
799   anAspect->SetMaterial (myDrawer->ShadingAspect()->Material());
800   anAspect->SetTransparency (myDrawer->ShadingAspect()->Transparency());
801
802   // Display center
803   myCenter.Init (myAxes[0].AxisRadius() * 2.0f, gp::Origin());
804   aGroup = Prs3d_Root::NewGroup (thePrs);
805   aGroup->SetPrimitivesAspect (myDrawer->ShadingAspect()->Aspect());
806   aGroup->AddPrimitiveArray (myCenter.Array());
807
808   for (Standard_Integer anIt = 0; anIt < 3; ++anIt)
809   {
810     // Display axes
811     aGroup = Prs3d_Root::NewGroup (thePrs);
812     anAspect->SetColor (myAxes[anIt].Color());
813     aGroup->SetGroupPrimitivesAspect (anAspect->Aspect());
814     myAxes[anIt].Compute (thePrsMgr, thePrs, anAspect);
815     myAxes[anIt].SetTransformPersistence (GetTransformPersistenceMode(),
816                                           GetTransformPersistencePoint());
817   }
818
819   updateTransformation();
820 }
821
822 //=======================================================================
823 //function : HilightSelected
824 //purpose  : 
825 //=======================================================================
826 void AIS_Manipulator::HilightSelected (const Handle(PrsMgr_PresentationManager3d)& thePM,
827                                        const SelectMgr_SequenceOfOwner& theSeq)
828 {
829   if (theSeq.IsEmpty())
830   {
831     return;
832   }
833
834   if (myIsActivationOnDetection)
835   {
836     return;
837   }
838
839   if (!theSeq (1)->IsKind (STANDARD_TYPE (AIS_ManipulatorOwner)))
840   {
841     thePM->Color (this, GetContext()->HilightColor(), 0);
842     return;
843   }
844
845   Handle(AIS_ManipulatorOwner) anOwner = Handle(AIS_ManipulatorOwner)::DownCast (theSeq (1));
846   myHighlightAspect->Aspect()->SetInteriorColor (GetContext()->HilightColor());
847   Handle(Graphic3d_Group) aGroup = getGroup (anOwner->Index(), anOwner->Mode());
848   if (aGroup.IsNull())
849   {
850     return;
851   }
852
853   aGroup->SetGroupPrimitivesAspect (myHighlightAspect->Aspect());
854
855   myCurrentIndex = anOwner->Index();
856   myCurrentMode = anOwner->Mode();
857 }
858
859 //=======================================================================
860 //function : ClearSelected
861 //purpose  :
862 //=======================================================================
863 void AIS_Manipulator::ClearSelected()
864 {
865   DeactivateCurrentMode();
866 }
867
868 //=======================================================================
869 //function : HilightOwnerWithColor
870 //purpose  : 
871 //=======================================================================
872 void AIS_Manipulator::HilightOwnerWithColor (const Handle(PrsMgr_PresentationManager3d)& thePM, const Quantity_NameOfColor theColor, const Handle(SelectMgr_EntityOwner)& theOwner)
873 {
874   Handle(AIS_ManipulatorOwner) anOwner = Handle(AIS_ManipulatorOwner)::DownCast (theOwner);
875   Handle(Prs3d_Presentation) aPresentation = getHighlightPresentation (anOwner);
876   if (aPresentation.IsNull())
877   {
878     return;
879   }
880   aPresentation->Highlight (Aspect_TOHM_COLOR, theColor);
881   aPresentation->SetShadingAspect (myHighlightAspect);
882   aPresentation->SetZLayer (Graphic3d_ZLayerId_Topmost);
883   thePM->AddToImmediateList (aPresentation);
884
885   if (myIsActivationOnDetection)
886   {
887     if (HasActiveMode())
888     {
889       DeactivateCurrentMode();
890     }
891
892     myCurrentIndex = anOwner->Index();
893     myCurrentMode = anOwner->Mode();
894   }
895 }
896
897 //=======================================================================
898 //function : ComputeSelection
899 //purpose  : 
900 //=======================================================================
901 void AIS_Manipulator::ComputeSelection (const Handle(SelectMgr_Selection)& theSelection,
902                                         const Standard_Integer theMode)
903 {
904   //Check mode
905   AIS_ManipulatorMode aMode = (AIS_ManipulatorMode) theMode;
906   if (aMode == AIS_MM_None)
907   {
908     return;
909   }
910   Handle(SelectMgr_EntityOwner) anOwner;
911   if (aMode == AIS_MM_None)
912   {
913     anOwner = new SelectMgr_EntityOwner (this, 5);
914   }
915   Handle(Select3D_SensitiveTriangulation) aTri;
916   if (aMode == AIS_MM_Translation || aMode == AIS_MM_None)
917   {
918     for (Standard_Integer anIt = 0; anIt < 3; ++anIt)
919     {
920       const Axis& anAxis = myAxes[anIt];
921       if (aMode != AIS_MM_None)
922       {
923         anOwner = new AIS_ManipulatorOwner(this, anIt, AIS_MM_Translation, 9);
924       }
925       // define sensitivity by line
926       Handle(Select3D_SensitiveSegment) aLine = new Select3D_SensitiveSegment (anOwner, gp::Origin(), anAxis.TranslatorTipPosition());
927       aLine->SetSensitivityFactor (15);
928       theSelection->Add (aLine);
929       // enlarge sensitivity by triangulation
930       aTri = new Select3D_SensitiveTriangulation (anOwner, anAxis.TranslatorCylinder().Triangulation(), TopLoc_Location(), Standard_True);
931       theSelection->Add (aTri);
932       aTri = new Select3D_SensitiveTriangulation (anOwner, anAxis.TranslatorArrow().Triangulation(), TopLoc_Location(), Standard_True);
933       theSelection->Add (aTri);
934       aTri = new Select3D_SensitiveTriangulation (anOwner, anAxis.TranslatorArrowBottom().Triangulation(), TopLoc_Location(), Standard_True);
935       theSelection->Add (aTri);
936     }
937   }
938
939   if (aMode == AIS_MM_Rotation || aMode == AIS_MM_None)
940   {
941     for (Standard_Integer anIt = 0; anIt < 3; ++anIt)
942     {
943       const Axis& anAxis = myAxes[anIt];
944       if (aMode != AIS_MM_None)
945       {
946         anOwner = new AIS_ManipulatorOwner (this, anIt, AIS_MM_Rotation, 9);
947       }
948       // define sensitivity by circle
949       Handle(Geom_Circle) aGeomCircle = new Geom_Circle (gp_Ax2 (gp::Origin(), anAxis.ReferenceAxis().Direction()), anAxis.RotatorDiskRadius());
950       Handle(Select3D_SensitiveCircle) aCircle = new Select3D_SensitiveCircle (anOwner, aGeomCircle, Standard_False, anAxis.FacettesNumber());
951       aCircle->SetSensitivityFactor (15);
952       theSelection->Add (aCircle);
953       // enlarge sensitivity by triangulation
954       aTri = new Select3D_SensitiveTriangulation (anOwner, myAxes[anIt].RotatorDisk().Triangulation(), TopLoc_Location(), Standard_True);
955       theSelection->Add (aTri);
956     }
957   }
958
959   if (aMode == AIS_MM_Scaling || aMode == AIS_MM_None)
960   {
961     for (Standard_Integer anIt = 0; anIt < 3; ++anIt)
962     {
963       if (aMode != AIS_MM_None)
964       {
965         anOwner = new AIS_ManipulatorOwner (this, anIt, AIS_MM_Scaling, 9);
966       }
967       // define sensitivity by point
968       Handle(Select3D_SensitivePoint) aPnt = new Select3D_SensitivePoint (anOwner, myAxes[anIt].ScalerCubePosition());
969       aPnt->SetSensitivityFactor (15);
970       theSelection->Add (aPnt);
971       // enlarge sensitivity by triangulation
972       aTri = new Select3D_SensitiveTriangulation (anOwner, myAxes[anIt].ScalerCube().Triangulation(), TopLoc_Location(), Standard_True);
973       theSelection->Add (aTri);
974     }
975   }
976 }
977
978 //=======================================================================
979 //class    : Cylinder
980 //function : Init
981 //purpose  : 
982 //=======================================================================
983 void AIS_Manipulator::Cylinder::Init (const Standard_ShortReal theBotRad, const Standard_ShortReal theTopRad,
984                                       const Standard_ShortReal theHeight,
985                                       const Standard_Integer theSlicesNb, const Standard_Integer theStacksNb,
986                                       const gp_Ax1& thePosition)
987 {
988   myPosition = thePosition;
989   myBottomRad = theBotRad;
990   myTopRad = theTopRad;
991   myHeight = theHeight;
992
993   StdPrs_ToolCylinder aTool (myBottomRad, myTopRad, myHeight, theSlicesNb, theStacksNb);
994   gp_Ax3 aSystem (myPosition.Location(), myPosition.Direction());
995   gp_Trsf aTrsf;
996   aTrsf.SetTransformation (aSystem, gp_Ax3());
997
998   aTool.FillArray (myArray, myTriangulation, aTrsf);
999 }
1000
1001 //=======================================================================
1002 //class    : Disk
1003 //function : Init
1004 //purpose  : 
1005 //=======================================================================
1006 void AIS_Manipulator::Disk::Init (const Standard_ShortReal theInnerRadius,
1007                                   const Standard_ShortReal theOuterRadius,
1008                                   const gp_Ax1& thePosition,
1009                                   const Standard_Integer theSlicesNb,
1010                                   const Standard_Integer theStacksNb)
1011 {
1012   myPosition = thePosition;
1013   myInnerRad = theInnerRadius;
1014   myOuterRad = theOuterRadius;
1015
1016   StdPrs_ToolDisk aTool (theInnerRadius, theOuterRadius, theSlicesNb, theStacksNb);
1017   gp_Ax3 aSystem (myPosition.Location(), myPosition.Direction());
1018   gp_Trsf aTrsf;
1019   aTrsf.SetTransformation (aSystem, gp_Ax3());
1020   aTool.FillArray (myArray, myTriangulation, aTrsf);
1021 }
1022
1023 //=======================================================================
1024 //class    : Sphere
1025 //function : Init
1026 //purpose  : 
1027 //=======================================================================
1028 void AIS_Manipulator::Sphere::Init (const Standard_ShortReal theRadius,
1029                                     const gp_Pnt& thePosition,
1030                                     const Standard_Integer theSlicesNb,
1031                                     const Standard_Integer theStacksNb)
1032 {
1033   myPosition = thePosition;
1034   myRadius = theRadius;
1035
1036   StdPrs_ToolSphere aTool (theRadius, theSlicesNb, theStacksNb);
1037   gp_Trsf aTrsf;
1038   aTrsf.SetTranslation (gp_Vec(gp::Origin(), thePosition));
1039   aTool.FillArray (myArray, myTriangulation, aTrsf);
1040 }
1041
1042 //=======================================================================
1043 //class    : Cube
1044 //function : Init
1045 //purpose  : 
1046 //=======================================================================
1047 void AIS_Manipulator::Cube::Init (const gp_Ax1& thePosition, const Standard_ShortReal theSize)
1048 {
1049   myArray = new Graphic3d_ArrayOfTriangles (12 * 3, 0, Standard_True);
1050
1051   Poly_Array1OfTriangle aPolyTriangles (1, 12);
1052   TColgp_Array1OfPnt aPoints (1, 36);
1053   NCollection_Array1<gp_Dir> aNormals (1, 12);
1054   myTriangulation = new Poly_Triangulation (aPoints, aPolyTriangles);
1055
1056   gp_Ax2 aPln (thePosition.Location(), thePosition.Direction());
1057   gp_Pnt aBottomLeft = thePosition.Location().XYZ() - aPln.XDirection().XYZ() * theSize * 0.5 - aPln.YDirection().XYZ() * theSize * 0.5;
1058   gp_Pnt aV2 = aBottomLeft.XYZ() + aPln.YDirection().XYZ() * theSize;
1059   gp_Pnt aV3 = aBottomLeft.XYZ() + aPln.YDirection().XYZ() * theSize + aPln.XDirection().XYZ() * theSize;
1060   gp_Pnt aV4 = aBottomLeft.XYZ() + aPln.XDirection().XYZ() * theSize;
1061   gp_Pnt aTopRight = thePosition.Location().XYZ() + thePosition.Direction().XYZ() * theSize
1062     + aPln.XDirection().XYZ() * theSize * 0.5 + aPln.YDirection().XYZ() * theSize * 0.5;
1063   gp_Pnt aV5 = aTopRight.XYZ() - aPln.YDirection().XYZ() * theSize;
1064   gp_Pnt aV6 = aTopRight.XYZ() - aPln.YDirection().XYZ() * theSize - aPln.XDirection().XYZ() * theSize;
1065   gp_Pnt aV7 = aTopRight.XYZ() - aPln.XDirection().XYZ() * theSize;
1066
1067   gp_Dir aRight ((gp_Vec(aTopRight, aV7) ^ gp_Vec(aTopRight, aV2)).XYZ());
1068   gp_Dir aFront ((gp_Vec(aV3, aV4) ^ gp_Vec(aV3, aV5)).XYZ());
1069
1070   // Bottom
1071   addTriangle (0, aBottomLeft, aV2, aV3, -thePosition.Direction());
1072   addTriangle (1, aBottomLeft, aV3, aV4, -thePosition.Direction());
1073
1074   // Front
1075   addTriangle (2, aV3, aV4, aV5, aFront);
1076   addTriangle (3, aV3, aV5, aTopRight, aFront);
1077
1078   // Back
1079   addTriangle (4, aBottomLeft, aV2, aV7, -aFront);
1080   addTriangle (5, aBottomLeft, aV7, aV6, -aFront);
1081
1082   // aTop
1083   addTriangle (6, aV7, aV6, aV5, thePosition.Direction());
1084   addTriangle (7, aTopRight, aV7, aV5, thePosition.Direction());
1085
1086   //Left
1087   addTriangle (8, aV6, aV5, aV4, -aRight);
1088   addTriangle (9, aBottomLeft, aV6, aV4, -aRight);
1089
1090   // Right
1091   addTriangle (10, aV3, aTopRight, aV7, aRight);
1092   addTriangle (11, aV3, aV7, aV2, aRight);
1093 }
1094
1095 //=======================================================================
1096 //class    : Cube
1097 //function : addTriangle
1098 //purpose  : 
1099 //=======================================================================
1100 void AIS_Manipulator::Cube::addTriangle (const Standard_Integer theIndex,
1101                                          const gp_Pnt& theP1, const gp_Pnt& theP2, const gp_Pnt& theP3,
1102                                          const gp_Dir& theNormal)
1103 {
1104   myTriangulation->ChangeNodes().SetValue (theIndex * 3 + 1, theP1);
1105   myTriangulation->ChangeNodes().SetValue (theIndex * 3 + 2, theP2);
1106   myTriangulation->ChangeNodes().SetValue (theIndex * 3 + 3, theP3);
1107
1108   myTriangulation->ChangeTriangles().SetValue (theIndex + 1, Poly_Triangle (theIndex * 3 + 1, theIndex * 3 + 2, theIndex * 3 + 3));
1109   myArray->AddVertex (theP1, theNormal);
1110   myArray->AddVertex (theP2, theNormal);
1111   myArray->AddVertex (theP3, theNormal);
1112 }
1113
1114 //=======================================================================
1115 //class    : Axis
1116 //function : Constructor
1117 //purpose  : 
1118 //=======================================================================
1119 AIS_Manipulator::Axis::Axis (const gp_Ax1& theAxis,
1120                              const Quantity_Color& theColor,
1121                              const Standard_ShortReal theLength)
1122 : myReferenceAxis (theAxis),
1123   myPosition (theAxis),
1124   myColor (theColor),
1125   myHasTranslation (Standard_True),
1126   myLength (theLength),
1127   myAxisRadius (0.5f),
1128   myHasScaling (Standard_True),
1129   myBoxSize (2.0f),
1130   myHasRotation (Standard_True),
1131   myInnerRadius (myLength + myBoxSize),
1132   myDiskThickness (myBoxSize * 0.5f),
1133   myIndent (0.2f),
1134   myFacettesNumber (20),
1135   myCircleRadius (myLength + myBoxSize + myBoxSize * 0.5f * 0.5f)
1136 {
1137   //
1138 }
1139
1140 //=======================================================================
1141 //class    : Axis
1142 //function : Compute
1143 //purpose  : 
1144 //=======================================================================
1145 void AIS_Manipulator::Axis::Compute (const Handle_PrsMgr_PresentationManager3d& thePrsMgr,
1146                                      const Handle(Prs3d_Presentation)& thePrs,
1147                                      const Handle(Prs3d_ShadingAspect)& theAspect)
1148 {
1149   Handle(Graphic3d_Group) aGroup;
1150
1151   if (myHasTranslation)
1152   {
1153     const Standard_ShortReal anArrowLength = 0.25f * myLength;
1154     const Standard_ShortReal aCylinderLength = myLength - anArrowLength;
1155
1156     myCylinder.Init (myAxisRadius, myAxisRadius, aCylinderLength, myFacettesNumber, 2, gp_Ax1 (gp::Origin(), myReferenceAxis.Direction()));
1157
1158     gp_Pnt anArrowBottom (0.0, 0.0, 0.0);
1159     anArrowBottom.Translate (myReferenceAxis.Direction().XYZ() * aCylinderLength);
1160
1161     myArrow.Init (myAxisRadius * 1.5f, 0.0f, anArrowLength, myFacettesNumber, 2, gp_Ax1 (anArrowBottom, myReferenceAxis.Direction()));
1162     myArrowBottom.Init (myAxisRadius, myAxisRadius * 1.5f, gp_Ax1 (anArrowBottom, myReferenceAxis.Direction()), myFacettesNumber);
1163     myArrowTipPos = anArrowBottom;
1164
1165     myTranslatorGroup = Prs3d_Root::NewGroup (thePrs);
1166     myTranslatorGroup->SetGroupPrimitivesAspect (theAspect->Aspect());
1167     myTranslatorGroup->AddPrimitiveArray (myCylinder.Array());
1168     myTranslatorGroup->AddPrimitiveArray (myArrow.Array());
1169     myTranslatorGroup->AddPrimitiveArray (myArrowBottom.Array());
1170
1171     if (myHighlightTranslator.IsNull())
1172     {
1173       myHighlightTranslator = new Prs3d_Presentation (thePrsMgr->StructureManager());
1174     }
1175
1176     myHighlightTranslator->Clear();
1177     aGroup = Prs3d_Root::CurrentGroup (myHighlightTranslator);
1178     aGroup->AddPrimitiveArray (myCylinder.Array());
1179     aGroup->AddPrimitiveArray (myArrow.Array());
1180     aGroup->AddPrimitiveArray (myArrowBottom.Array());
1181   }
1182
1183   if (myHasScaling)
1184   {
1185     myCubePos = myReferenceAxis.Direction().XYZ() * (myLength + myIndent);
1186     myCube.Init (gp_Ax1 (myCubePos, myReferenceAxis.Direction()), myBoxSize);
1187
1188     myScalerGroup = Prs3d_Root::NewGroup (thePrs);
1189     myScalerGroup->SetGroupPrimitivesAspect (theAspect->Aspect());
1190     myScalerGroup->AddPrimitiveArray (myCube.Array());
1191
1192     if (myHighlightScaler.IsNull())
1193     {
1194       myHighlightScaler = new Prs3d_Presentation (thePrsMgr->StructureManager());
1195     }
1196
1197     myHighlightScaler->Clear();
1198     aGroup = Prs3d_Root::CurrentGroup (myHighlightScaler);
1199     aGroup->AddPrimitiveArray (myCube.Array());
1200   }
1201
1202   if (myHasRotation)
1203   {
1204     myCircleRadius = myInnerRadius + myIndent * 2 + myDiskThickness * 0.5f;
1205     myCircle.Init (myInnerRadius + myIndent * 2, myInnerRadius + myDiskThickness + myIndent * 2, gp_Ax1(gp::Origin(), myReferenceAxis.Direction()), myFacettesNumber * 2);
1206     myRotatorGroup = Prs3d_Root::NewGroup (thePrs);
1207     myRotatorGroup->SetGroupPrimitivesAspect (theAspect->Aspect());
1208     myRotatorGroup->AddPrimitiveArray (myCircle.Array());
1209
1210     if (myHighlightRotator.IsNull())
1211     {
1212       myHighlightRotator = new Prs3d_Presentation (thePrsMgr->StructureManager());
1213     }
1214
1215     myHighlightRotator->Clear();
1216     aGroup = Prs3d_Root::CurrentGroup (myHighlightRotator);
1217     Prs3d_Root::CurrentGroup (myHighlightRotator)->AddPrimitiveArray (myCircle.Array());
1218   }
1219 }