47242fe29edbfa93cbfe7b1b4f699644fa10aca0
[occt.git] / src / ViewerTest / ViewerTest.cxx
1 // Created on: 1997-07-23
2 // Created by: Henri JEANNIN
3 // Copyright (c) 1997-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17 // Modified by  Eric Gouthiere [sep-oct 98] -> add commands for display...
18 // Modified by  Robert Coublanc [nov 16-17-18 1998]
19 //             -split ViewerTest.cxx into 3 files : ViewerTest.cxx,
20 //                                                  ViewerTest_ObjectCommands.cxx
21 //                                                  ViewerTest_RelationCommands.cxx
22 //             -add Functions and commands for interactive selection of shapes and objects
23 //              in AIS Viewers. (PickShape(s), PickObject(s),
24
25 #include <Standard_Stream.hxx>
26
27 #include <ViewerTest.hxx>
28 #include <ViewerTest_CmdParser.hxx>
29
30 #include <TopLoc_Location.hxx>
31 #include <TopTools_HArray1OfShape.hxx>
32 #include <TColStd_HArray1OfTransient.hxx>
33 #include <TColStd_SequenceOfAsciiString.hxx>
34 #include <TColStd_HSequenceOfAsciiString.hxx>
35 #include <TColStd_MapOfTransient.hxx>
36 #include <OSD_Timer.hxx>
37 #include <Geom_Axis2Placement.hxx>
38 #include <Geom_Axis1Placement.hxx>
39 #include <gp_Trsf.hxx>
40 #include <TopExp_Explorer.hxx>
41 #include <BRepAdaptor_Curve.hxx>
42 #include <StdSelect_ShapeTypeFilter.hxx>
43 #include <AIS.hxx>
44 #include <AIS_ColoredShape.hxx>
45 #include <AIS_InteractiveObject.hxx>
46 #include <AIS_Trihedron.hxx>
47 #include <AIS_Axis.hxx>
48 #include <AIS_Relation.hxx>
49 #include <AIS_TypeFilter.hxx>
50 #include <AIS_SignatureFilter.hxx>
51 #include <AIS_LocalContext.hxx>
52 #include <AIS_ListOfInteractive.hxx>
53 #include <AIS_ListIteratorOfListOfInteractive.hxx>
54 #include <Aspect_InteriorStyle.hxx>
55 #include <Aspect_Window.hxx>
56 #include <Graphic3d_AspectFillArea3d.hxx>
57 #include <Graphic3d_AspectLine3d.hxx>
58 #include <Graphic3d_CStructure.hxx>
59 #include <Graphic3d_TextureRoot.hxx>
60 #include <Image_AlienPixMap.hxx>
61 #include <Prs3d_Drawer.hxx>
62 #include <Prs3d_ShadingAspect.hxx>
63 #include <Prs3d_IsoAspect.hxx>
64 #include <Prs3d_PointAspect.hxx>
65 #include <Select3D_SensitiveWire.hxx>
66 #include <SelectMgr_EntityOwner.hxx>
67 #include <StdSelect_BRepOwner.hxx>
68 #include <StdSelect_ViewerSelector3d.hxx>
69 #include <TopTools_MapOfShape.hxx>
70 #include <ViewerTest_AutoUpdater.hxx>
71
72 #include <stdio.h>
73
74 #include <Draw_Interpretor.hxx>
75 #include <TCollection_AsciiString.hxx>
76 #include <Draw_PluginMacro.hxx>
77
78 // avoid warnings on 'extern "C"' functions returning C++ classes
79 #ifdef WNT
80 #define _CRT_SECURE_NO_DEPRECATE
81 #pragma warning(4:4190)
82 #pragma warning (disable:4996)
83 #endif
84
85 extern int ViewerMainLoop(Standard_Integer argc, const char** argv);
86
87 #include <Quantity_Color.hxx>
88 #include <Quantity_NameOfColor.hxx>
89
90 #include <Graphic3d_NameOfMaterial.hxx>
91
92 #define DEFAULT_COLOR              Quantity_NOC_GOLDENROD
93 #define DEFAULT_FREEBOUNDARY_COLOR Quantity_NOC_GREEN
94 #define DEFAULT_MATERIAL           Graphic3d_NOM_BRASS
95
96 //=======================================================================
97 //function : GetColorFromName
98 //purpose  : get the Quantity_NameOfColor from a string
99 //=======================================================================
100
101 Quantity_NameOfColor ViewerTest::GetColorFromName (const Standard_CString theName)
102 {
103   Quantity_NameOfColor aColor = DEFAULT_COLOR;
104   Quantity_Color::ColorFromName (theName, aColor);
105   return aColor;
106 }
107
108 //=======================================================================
109 //function : ParseColor
110 //purpose  :
111 //=======================================================================
112
113 Standard_Integer ViewerTest::ParseColor (Standard_Integer  theArgNb,
114                                          const char**      theArgVec,
115                                          Quantity_Color&   theColor)
116 {
117   Quantity_NameOfColor aColor = Quantity_NOC_BLACK;
118   if (theArgNb >= 1
119    && Quantity_Color::ColorFromName (theArgVec[0], aColor))
120   {
121     theColor = aColor;
122     return 1;
123   }
124   else if (theArgNb >= 3)
125   {
126     const TCollection_AsciiString anRgbStr[3] =
127     {
128       theArgVec[0],
129       theArgVec[1],
130       theArgVec[2]
131     };
132     if (!anRgbStr[0].IsRealValue()
133      || !anRgbStr[1].IsRealValue()
134      || !anRgbStr[2].IsRealValue())
135     {
136       return 0;
137     }
138
139     Graphic3d_Vec4d anRgb;
140     anRgb.x() = anRgbStr[0].RealValue();
141     anRgb.y() = anRgbStr[1].RealValue();
142     anRgb.z() = anRgbStr[2].RealValue();
143     if (anRgb.x() < 0.0 || anRgb.x() > 1.0
144      || anRgb.y() < 0.0 || anRgb.y() > 1.0
145      || anRgb.z() < 0.0 || anRgb.z() > 1.0)
146     {
147       std::cout << "Error: RGB color values should be within range 0..1!\n";
148       return 0;
149     }
150
151     theColor.SetValues (anRgb.x(), anRgb.y(), anRgb.z(), Quantity_TOC_RGB);
152     return 3;
153   }
154
155   return 0;
156 }
157
158 //=======================================================================
159 //function : GetTypeNames
160 //purpose  :
161 //=======================================================================
162 static const char** GetTypeNames()
163 {
164   static const char* names[14] = {"Point","Axis","Trihedron","PlaneTrihedron", "Line","Circle","Plane",
165                           "Shape","ConnectedShape","MultiConn.Shape",
166                           "ConnectedInter.","MultiConn.",
167                           "Constraint","Dimension"};
168   static const char** ThePointer = names;
169   return ThePointer;
170 }
171
172 //=======================================================================
173 //function : GetTypeAndSignfromString
174 //purpose  :
175 //=======================================================================
176 void GetTypeAndSignfromString (const char* name,AIS_KindOfInteractive& TheType,Standard_Integer& TheSign)
177 {
178   const char ** thefullnames = GetTypeNames();
179   Standard_Integer index(-1);
180
181   for(Standard_Integer i=0;i<=13 && index==-1;i++)
182     if(!strcasecmp(name,thefullnames[i]))
183       index = i;
184
185   if(index ==-1){
186     TheType = AIS_KOI_None;
187     TheSign = -1;
188     return;
189   }
190
191   if(index<=6){
192     TheType = AIS_KOI_Datum;
193     TheSign = index+1;
194   }
195   else if (index <=9){
196     TheType = AIS_KOI_Shape;
197     TheSign = index-7;
198   }
199   else if(index<=11){
200     TheType = AIS_KOI_Object;
201     TheSign = index-10;
202   }
203   else{
204     TheType = AIS_KOI_Relation;
205     TheSign = index-12;
206   }
207
208 }
209
210
211
212 #include <string.h>
213 #include <Draw_Interpretor.hxx>
214 #include <Draw.hxx>
215 #include <Draw_Appli.hxx>
216 #include <DBRep.hxx>
217
218
219 #include <TCollection_AsciiString.hxx>
220 #include <V3d_Viewer.hxx>
221 #include <V3d_View.hxx>
222 #include <V3d.hxx>
223
224 #include <AIS_InteractiveContext.hxx>
225 #include <AIS_Shape.hxx>
226 #include <AIS_TexturedShape.hxx>
227 #include <AIS_DisplayMode.hxx>
228 #include <TColStd_MapOfInteger.hxx>
229 #include <AIS_MapOfInteractive.hxx>
230 #include <ViewerTest_DoubleMapOfInteractiveAndName.hxx>
231 #include <ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName.hxx>
232 #include <ViewerTest_EventManager.hxx>
233
234 #include <TopoDS_Solid.hxx>
235 #include <BRepTools.hxx>
236 #include <BRep_Builder.hxx>
237 #include <TopAbs_ShapeEnum.hxx>
238
239 #include <TopoDS.hxx>
240 #include <BRep_Tool.hxx>
241
242
243 #include <Draw_Window.hxx>
244 #include <AIS_ListIteratorOfListOfInteractive.hxx>
245 #include <AIS_ListOfInteractive.hxx>
246 #include <AIS_DisplayMode.hxx>
247 #include <TopTools_ListOfShape.hxx>
248 #include <BRepOffsetAPI_MakeThickSolid.hxx>
249 #include <BRepOffset.hxx>
250
251 //==============================================================================
252 //  VIEWER OBJECT MANAGEMENT GLOBAL VARIABLES
253 //==============================================================================
254 Standard_EXPORT ViewerTest_DoubleMapOfInteractiveAndName& GetMapOfAIS(){
255   static ViewerTest_DoubleMapOfInteractiveAndName TheMap;
256   return TheMap;
257 }
258
259 //=======================================================================
260 //function : Display
261 //purpose  :
262 //=======================================================================
263 Standard_Boolean ViewerTest::Display (const TCollection_AsciiString&       theName,
264                                       const Handle(AIS_InteractiveObject)& theObject,
265                                       const Standard_Boolean               theToUpdate,
266                                       const Standard_Boolean               theReplaceIfExists)
267 {
268   ViewerTest_DoubleMapOfInteractiveAndName& aMap = GetMapOfAIS();
269   Handle(AIS_InteractiveContext) aCtx = ViewerTest::GetAISContext();
270   if (aCtx.IsNull())
271   {
272     std::cout << "Error: AIS context is not available.\n";
273     return Standard_False;
274   }
275
276   if (aMap.IsBound2 (theName))
277   {
278     if (!theReplaceIfExists)
279     {
280       std::cout << "Error: other interactive object has been already registered with name: " << theName << ".\n"
281                 << "Please use another name.\n";
282       return Standard_False;
283     }
284
285     Handle(AIS_InteractiveObject) anOldObj = Handle(AIS_InteractiveObject)::DownCast (aMap.Find2 (theName));
286     if (!anOldObj.IsNull())
287     {
288       aCtx->Remove (anOldObj, Standard_True);
289     }
290     aMap.UnBind2 (theName);
291   }
292
293   if (theObject.IsNull())
294   {
295     // object with specified name has been already unbound
296     return Standard_True;
297   }
298
299   // unbind AIS object if it was bound with another name
300   aMap.UnBind1 (theObject);
301
302   // can be registered without rebinding
303   aMap.Bind (theObject, theName);
304   aCtx->Display (theObject, theToUpdate);
305   return Standard_True;
306 }
307
308 //! Alias for ViewerTest::Display(), compatibility with old code.
309 Standard_EXPORT Standard_Boolean VDisplayAISObject (const TCollection_AsciiString&       theName,
310                                                     const Handle(AIS_InteractiveObject)& theObject,
311                                                     Standard_Boolean theReplaceIfExists = Standard_True)
312 {
313   return ViewerTest::Display (theName, theObject, Standard_True, theReplaceIfExists);
314 }
315
316 static TColStd_MapOfInteger theactivatedmodes(8);
317 static TColStd_ListOfTransient theEventMgrs;
318
319 static void VwrTst_InitEventMgr(const Handle(V3d_View)& aView,
320                                 const Handle(AIS_InteractiveContext)& Ctx)
321 {
322   theEventMgrs.Clear();
323   theEventMgrs.Prepend(new ViewerTest_EventManager(aView, Ctx));
324 }
325
326 static Handle(V3d_View)&  a3DView()
327 {
328   static Handle(V3d_View) Viou;
329   return Viou;
330 }
331
332
333 Standard_EXPORT Handle(AIS_InteractiveContext)& TheAISContext(){
334   static Handle(AIS_InteractiveContext) aContext;
335   return aContext;
336 }
337
338 const Handle(V3d_View)& ViewerTest::CurrentView()
339 {
340   return a3DView();
341 }
342 void ViewerTest::CurrentView(const Handle(V3d_View)& V)
343 {
344   a3DView() = V;
345 }
346
347 const Handle(AIS_InteractiveContext)& ViewerTest::GetAISContext()
348 {
349   return TheAISContext();
350 }
351
352 void ViewerTest::SetAISContext (const Handle(AIS_InteractiveContext)& aCtx)
353 {
354   TheAISContext() = aCtx;
355   ViewerTest::ResetEventManager();
356 }
357
358 Handle(V3d_Viewer) ViewerTest::GetViewerFromContext()
359 {
360   return !TheAISContext().IsNull() ? TheAISContext()->CurrentViewer() : Handle(V3d_Viewer)();
361 }
362
363 Handle(V3d_Viewer) ViewerTest::GetCollectorFromContext()
364 {
365   return !TheAISContext().IsNull() ? TheAISContext()->CurrentViewer() : Handle(V3d_Viewer)();
366 }
367
368
369 void ViewerTest::SetEventManager(const Handle(ViewerTest_EventManager)& EM){
370   theEventMgrs.Prepend(EM);
371 }
372
373 void ViewerTest::UnsetEventManager()
374 {
375   theEventMgrs.RemoveFirst();
376 }
377
378
379 void ViewerTest::ResetEventManager()
380 {
381   const Handle(V3d_View) aView = ViewerTest::CurrentView();
382   VwrTst_InitEventMgr(aView, ViewerTest::GetAISContext());
383 }
384
385 Handle(ViewerTest_EventManager) ViewerTest::CurrentEventManager()
386 {
387   Handle(ViewerTest_EventManager) EM;
388   if(theEventMgrs.IsEmpty()) return EM;
389   Handle(Standard_Transient) Tr =  theEventMgrs.First();
390   EM = Handle(ViewerTest_EventManager)::DownCast (Tr);
391   return EM;
392 }
393
394 //=======================================================================
395 //function : Get Context and active view
396 //purpose  :
397 //=======================================================================
398 static Standard_Boolean getCtxAndView (Handle(AIS_InteractiveContext)& theCtx,
399                                        Handle(V3d_View)&               theView)
400 {
401   theCtx  = ViewerTest::GetAISContext();
402   theView = ViewerTest::CurrentView();
403   if (theCtx.IsNull()
404    || theView.IsNull())
405   {
406     std::cout << "Error: cannot find an active view!\n";
407     return Standard_False;
408   }
409   return Standard_True;
410 }
411
412 //==============================================================================
413 //function : GetShapeFromName
414 //purpose  : Compute an Shape from a draw variable or a file name
415 //==============================================================================
416
417 static TopoDS_Shape GetShapeFromName(const char* name)
418 {
419   TopoDS_Shape S = DBRep::Get(name);
420
421   if ( S.IsNull() ) {
422         BRep_Builder aBuilder;
423         BRepTools::Read( S, name, aBuilder);
424   }
425
426   return S;
427 }
428
429 //==============================================================================
430 //function : GetAISShapeFromName
431 //purpose  : Compute an AIS_Shape from a draw variable or a file name
432 //==============================================================================
433 Handle(AIS_Shape) GetAISShapeFromName(const char* name)
434 {
435   Handle(AIS_Shape) retsh;
436
437   if(GetMapOfAIS().IsBound2(name)){
438     const Handle(AIS_InteractiveObject) IO =
439       Handle(AIS_InteractiveObject)::DownCast(GetMapOfAIS().Find2(name));
440     if (!IO.IsNull()) {
441       if(IO->Type()==AIS_KOI_Shape) {
442         if(IO->Signature()==0){
443           retsh = Handle(AIS_Shape)::DownCast (IO);
444         }
445         else
446           cout << "an Object which is not an AIS_Shape "
447             "already has this name!!!"<<endl;
448       }
449     }
450     return retsh;
451   }
452
453
454   TopoDS_Shape S = GetShapeFromName(name);
455   if ( !S.IsNull() ) {
456     retsh = new AIS_Shape(S);
457   }
458   return retsh;
459 }
460
461
462 //==============================================================================
463 //function : Clear
464 //purpose  : Remove all the object from the viewer
465 //==============================================================================
466 void ViewerTest::Clear()
467 {
468   if ( !a3DView().IsNull() ) {
469     if (TheAISContext()->HasOpenedContext())
470       TheAISContext()->CloseLocalContext();
471     ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName it(GetMapOfAIS());
472     while ( it.More() ) {
473       cout << "Remove " << it.Key2() << endl;
474       const Handle(AIS_InteractiveObject) anObj = Handle(AIS_InteractiveObject)::DownCast (it.Key1());
475       TheAISContext()->Remove(anObj,Standard_False);
476       it.Next();
477     }
478     TheAISContext()->RebuildSelectionStructs();
479     TheAISContext()->UpdateCurrentViewer();
480     GetMapOfAIS().Clear();
481   }
482 }
483
484 //==============================================================================
485 //function : StandardModesActivation
486 //purpose  : Activate a selection mode, vertex, edge, wire ..., in a local
487 //           Context
488 //==============================================================================
489 void ViewerTest::StandardModeActivation(const Standard_Integer mode )
490 {
491   Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
492   if(mode==0) {
493     if (TheAISContext()->HasOpenedContext())
494       aContext->CloseLocalContext();
495   } else {
496
497     if(!aContext->HasOpenedContext()) {
498       // To unhilight the preselected object
499       aContext->UnhilightSelected(Standard_False);
500       // Open a local Context in order to be able to select subshape from
501       // the selected shape if any or for all if there is no selection
502       if (!aContext->FirstSelectedObject().IsNull()){
503         aContext->OpenLocalContext(Standard_False);
504
505         for(aContext->InitSelected();aContext->MoreSelected();aContext->NextSelected()){
506           aContext->Load(       aContext->SelectedInteractive(),-1,Standard_True);
507         }
508       }
509       else
510         aContext->OpenLocalContext();
511     }
512
513     const char *cmode="???";
514
515     switch (mode) {
516     case 0: cmode = "Shape"; break;
517     case 1: cmode = "Vertex"; break;
518     case 2: cmode = "Edge"; break;
519     case 3: cmode = "Wire"; break;
520     case 4: cmode = "Face"; break;
521     case 5: cmode = "Shell"; break;
522     case 6: cmode = "Solid"; break;
523     case 7: cmode = "Compsolid"; break;
524     case 8: cmode = "Compound"; break;
525     }
526
527     if(theactivatedmodes.Contains(mode))
528       { // Desactivate
529         aContext->DeactivateStandardMode(AIS_Shape::SelectionType(mode));
530         theactivatedmodes.Remove(mode);
531         cout<<"Mode "<< cmode <<" OFF"<<endl;
532       }
533     else
534       { // Activate
535         aContext->ActivateStandardMode(AIS_Shape::SelectionType(mode));
536         theactivatedmodes.Add(mode);
537         cout<<"Mode "<< cmode << " ON" << endl;
538       }
539   }
540 }
541
542 //==============================================================================
543 //function : CopyIsoAspect
544 //purpose  : Returns copy Prs3d_IsoAspect with new number of isolines.
545 //==============================================================================
546 static Handle(Prs3d_IsoAspect) CopyIsoAspect
547       (const Handle(Prs3d_IsoAspect) &theIsoAspect,
548        const Standard_Integer theNbIsos)
549 {
550   Quantity_Color    aColor;
551   Aspect_TypeOfLine aType;
552   Standard_Real     aWidth;
553
554   theIsoAspect->Aspect()->Values(aColor, aType, aWidth);
555
556   Handle(Prs3d_IsoAspect) aResult =
557     new Prs3d_IsoAspect(aColor, aType, aWidth, theNbIsos);
558
559   return aResult;
560 }
561
562 //==============================================================================
563 //function : visos
564 //purpose  : Returns or sets the number of U- and V- isos and isIsoOnPlane flag
565 //Draw arg : [name1 ...] [nbUIsos nbVIsos IsoOnPlane(0|1)]
566 //==============================================================================
567 static int visos (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
568 {
569   if (TheAISContext().IsNull()) {
570     di << argv[0] << " Call 'vinit' before!\n";
571     return 1;
572   }
573
574   if (argc <= 1) {
575     di << "Current number of isos : " <<
576       TheAISContext()->IsoNumber(AIS_TOI_IsoU) << " " <<
577       TheAISContext()->IsoNumber(AIS_TOI_IsoV) << "\n";
578     di << "IsoOnPlane mode is " <<
579       (TheAISContext()->IsoOnPlane() ? "ON" : "OFF") << "\n";
580     di << "IsoOnTriangulation mode is " <<
581       (TheAISContext()->IsoOnTriangulation() ? "ON" : "OFF") << "\n";
582     return 0;
583   }
584
585   Standard_Integer aLastInd = argc - 1;
586   Standard_Boolean isChanged = Standard_False;
587   Standard_Integer aNbUIsos = 0;
588   Standard_Integer aNbVIsos = 0;
589
590   if (aLastInd >= 3) {
591     Standard_Boolean isIsoOnPlane = Standard_False;
592
593     if (strcmp(argv[aLastInd], "1") == 0) {
594       isIsoOnPlane = Standard_True;
595       isChanged    = Standard_True;
596     } else if (strcmp(argv[aLastInd], "0") == 0) {
597       isIsoOnPlane = Standard_False;
598       isChanged    = Standard_True;
599     }
600
601     if (isChanged) {
602       aNbVIsos = Draw::Atoi(argv[aLastInd - 1]);
603       aNbUIsos = Draw::Atoi(argv[aLastInd - 2]);
604       aLastInd -= 3;
605
606       di << "New number of isos : " << aNbUIsos << " " << aNbVIsos << "\n";
607       di << "New IsoOnPlane mode is " << (isIsoOnPlane ? "ON" : "OFF") << "\n";
608
609       TheAISContext()->IsoOnPlane(isIsoOnPlane);
610
611       if (aLastInd == 0) {
612         // If there are no shapes provided set the default numbers.
613         TheAISContext()->SetIsoNumber(aNbUIsos, AIS_TOI_IsoU);
614         TheAISContext()->SetIsoNumber(aNbVIsos, AIS_TOI_IsoV);
615       }
616     }
617   }
618
619   Standard_Integer i;
620
621   for (i = 1; i <= aLastInd; i++) {
622     TCollection_AsciiString name(argv[i]);
623     Standard_Boolean IsBound = GetMapOfAIS().IsBound2(name);
624
625     if (IsBound) {
626       const Handle(Standard_Transient) anObj = GetMapOfAIS().Find2(name);
627       if (anObj->IsKind(STANDARD_TYPE(AIS_InteractiveObject))) {
628         const Handle(AIS_InteractiveObject) aShape =
629         Handle(AIS_InteractiveObject)::DownCast (anObj);
630         Handle(Prs3d_Drawer) CurDrawer = aShape->Attributes();
631         Handle(Prs3d_IsoAspect) aUIso = CurDrawer->UIsoAspect();
632         Handle(Prs3d_IsoAspect) aVIso = CurDrawer->VIsoAspect();
633
634         if (isChanged) {
635           CurDrawer->SetUIsoAspect(CopyIsoAspect(aUIso, aNbUIsos));
636           CurDrawer->SetVIsoAspect(CopyIsoAspect(aVIso, aNbVIsos));
637           TheAISContext()->SetLocalAttributes
638                   (aShape, CurDrawer, Standard_False);
639           TheAISContext()->Redisplay(aShape);
640         } else {
641           di << "Number of isos for " << argv[i] << " : "
642              << aUIso->Number() << " " << aVIso->Number() << "\n";
643         }
644       } else {
645         di << argv[i] << ": Not an AIS interactive object!\n";
646       }
647     } else {
648       di << argv[i] << ": Use 'vdisplay' before\n";
649     }
650   }
651
652   if (isChanged) {
653     TheAISContext()->UpdateCurrentViewer();
654   }
655
656   return 0;
657 }
658
659 static Standard_Integer VDispSensi (Draw_Interpretor& ,
660                                     Standard_Integer  theArgNb,
661                                     Standard_CString* )
662 {
663   if (theArgNb > 1)
664   {
665     std::cout << "Error: wrong syntax!\n";
666     return 1;
667   }
668
669   Handle(AIS_InteractiveContext) aCtx;
670   Handle(V3d_View)               aView;
671   if (!getCtxAndView (aCtx, aView))
672   {
673     return 1;
674   }
675
676   aCtx->DisplayActiveSensitive (aView);
677   return 0;
678
679 }
680
681 static Standard_Integer VClearSensi (Draw_Interpretor& ,
682                                      Standard_Integer  theArgNb,
683                                      Standard_CString* )
684 {
685   if (theArgNb > 1)
686   {
687     std::cout << "Error: wrong syntax!\n";
688     return 1;
689   }
690
691   Handle(AIS_InteractiveContext) aCtx;
692   Handle(V3d_View)               aView;
693   if (!getCtxAndView (aCtx, aView))
694   {
695     return 1;
696   }
697   aCtx->ClearActiveSensitive (aView);
698   return 0;
699 }
700
701 //==============================================================================
702 //function : VDir
703 //purpose  : To list the displayed object with their attributes
704 //==============================================================================
705 static int VDir (Draw_Interpretor& theDI,
706                  Standard_Integer ,
707                  const char** )
708 {
709   if (!a3DView().IsNull())
710   {
711     return 0;
712   }
713
714   for (ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName anIter (GetMapOfAIS());
715        anIter.More(); anIter.Next())
716   {
717     theDI << "\t" << anIter.Key2().ToCString() << "\n";
718   }
719   return 0;
720 }
721
722 //==============================================================================
723 //function : VSelPrecision
724 //purpose  : To set the selection tolerance value
725 //Draw arg : Selection tolerance value (real value determining the width and
726 //           height of selecting frustum bases). Without arguments the function
727 //           just prints current tolerance.
728 //==============================================================================
729 static int VSelPrecision(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
730 {
731   if( argc > 2 )
732   {
733     di << "Wrong parameters! Must be: " << argv[0] << " [-unset] [tolerance]\n";
734     return 1;
735   }
736
737   Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
738   if( aContext.IsNull() )
739     return 1;
740
741   if( argc == 1 )
742   {
743     Standard_Real aPixelTolerance = aContext->PixelTolerance();
744     di << "Pixel tolerance : " << aPixelTolerance << "\n";
745   }
746   else if (argc == 2)
747   {
748     TCollection_AsciiString anArg = TCollection_AsciiString (argv[1]);
749     anArg.LowerCase();
750     if (anArg == "-unset")
751     {
752       aContext->SetPixelTolerance (-1);
753     }
754     else
755     {
756       aContext->SetPixelTolerance (anArg.IntegerValue());
757     }
758   }
759
760   return 0;
761 }
762
763 //! Auxiliary enumeration
764 enum ViewerTest_StereoPair
765 {
766   ViewerTest_SP_Single,
767   ViewerTest_SP_SideBySide,
768   ViewerTest_SP_OverUnder
769 };
770
771 //==============================================================================
772 //function : VDump
773 //purpose  : To dump the active view snapshot to image file
774 //==============================================================================
775 static Standard_Integer VDump (Draw_Interpretor& theDI,
776                                Standard_Integer  theArgNb,
777                                Standard_CString* theArgVec)
778 {
779   if (theArgNb < 2)
780   {
781     std::cout << "Error: wrong number of arguments! Image file name should be specified at least.\n";
782     return 1;
783   }
784
785   Standard_Integer      anArgIter   = 1;
786   Standard_CString      aFilePath   = theArgVec[anArgIter++];
787   Graphic3d_BufferType  aBufferType = Graphic3d_BT_RGB;
788   V3d_StereoDumpOptions aStereoOpts = V3d_SDO_MONO;
789   ViewerTest_StereoPair aStereoPair = ViewerTest_SP_Single;
790   Standard_Integer      aWidth      = 0;
791   Standard_Integer      aHeight     = 0;
792   for (; anArgIter < theArgNb; ++anArgIter)
793   {
794     TCollection_AsciiString anArg (theArgVec[anArgIter]);
795     anArg.LowerCase();
796     if (anArg == "-buffer")
797     {
798       if (++anArgIter >= theArgNb)
799       {
800         std::cout << "Error: wrong syntax at '" << anArg << "'\n";
801         return 1;
802       }
803
804       TCollection_AsciiString aBufArg (theArgVec[anArgIter]);
805       aBufArg.LowerCase();
806       if (aBufArg == "rgba")
807       {
808         aBufferType = Graphic3d_BT_RGBA;
809       }
810       else if (aBufArg == "rgb")
811       {
812         aBufferType = Graphic3d_BT_RGB;
813       }
814       else if (aBufArg == "depth")
815       {
816         aBufferType = Graphic3d_BT_Depth;
817       }
818       else
819       {
820         std::cout << "Error: unknown buffer '" << aBufArg << "'\n";
821         return 1;
822       }
823     }
824     else if (anArg == "-stereo")
825     {
826       if (++anArgIter >= theArgNb)
827       {
828         std::cout << "Error: wrong syntax at '" << anArg << "'\n";
829         return 1;
830       }
831
832       TCollection_AsciiString aStereoArg (theArgVec[anArgIter]);
833       aStereoArg.LowerCase();
834       if (aStereoArg == "l"
835        || aStereoArg == "left")
836       {
837         aStereoOpts = V3d_SDO_LEFT_EYE;
838       }
839       else if (aStereoArg == "r"
840             || aStereoArg == "right")
841       {
842         aStereoOpts = V3d_SDO_RIGHT_EYE;
843       }
844       else if (aStereoArg == "mono")
845       {
846         aStereoOpts = V3d_SDO_MONO;
847       }
848       else if (aStereoArg == "blended"
849             || aStereoArg == "blend"
850             || aStereoArg == "stereo")
851       {
852         aStereoOpts = V3d_SDO_BLENDED;
853       }
854       else if (aStereoArg == "sbs"
855             || aStereoArg == "sidebyside")
856       {
857         aStereoPair = ViewerTest_SP_SideBySide;
858       }
859       else if (aStereoArg == "ou"
860             || aStereoArg == "overunder")
861       {
862         aStereoPair = ViewerTest_SP_OverUnder;
863       }
864       else
865       {
866         std::cout << "Error: unknown stereo format '" << aStereoArg << "'\n";
867         return 1;
868       }
869     }
870     else if (anArg == "-rgba"
871           || anArg ==  "rgba")
872     {
873       aBufferType = Graphic3d_BT_RGBA;
874     }
875     else if (anArg == "-rgb"
876           || anArg ==  "rgb")
877     {
878       aBufferType = Graphic3d_BT_RGB;
879     }
880     else if (anArg == "-depth"
881           || anArg ==  "depth")
882     {
883       aBufferType = Graphic3d_BT_Depth;
884     }
885
886     else if (anArg == "-width"
887           || anArg ==  "width"
888           || anArg ==  "sizex")
889     {
890       if (aWidth != 0)
891       {
892         std::cout << "Error: wrong syntax at " << theArgVec[anArgIter] << "\n";
893         return 1;
894       }
895       else if (++anArgIter >= theArgNb)
896       {
897         std::cout << "Error: integer value is expected right after 'width'\n";
898         return 1;
899       }
900       aWidth = Draw::Atoi (theArgVec[anArgIter]);
901     }
902     else if (anArg == "-height"
903           || anArg ==  "height"
904           || anArg ==  "-sizey")
905     {
906       if (aHeight != 0)
907       {
908         std::cout << "Error: wrong syntax at " << theArgVec[anArgIter] << "\n";
909         return 1;
910       }
911       else if (++anArgIter >= theArgNb)
912       {
913         std::cout << "Error: integer value is expected right after 'height'\n";
914         return 1;
915       }
916       aHeight = Draw::Atoi (theArgVec[anArgIter]);
917     }
918     else
919     {
920       std::cout << "Error: unknown argument '" << theArgVec[anArgIter] << "'\n";
921       return 1;
922     }
923   }
924   if ((aWidth <= 0 && aHeight >  0)
925    || (aWidth >  0 && aHeight <= 0))
926   {
927     std::cout << "Error: dimensions " << aWidth << "x" << aHeight << " are incorrect\n";
928     return 1;
929   }
930
931   Handle(V3d_View) aView = ViewerTest::CurrentView();
932   if (aView.IsNull())
933   {
934     std::cout << "Error: cannot find an active view!\n";
935     return 1;
936   }
937
938   if (aWidth <= 0 || aHeight <= 0)
939   {
940     aView->Window()->Size (aWidth, aHeight);
941   }
942
943   Image_AlienPixMap aPixMap;
944
945   bool isBigEndian = Image_PixMap::IsBigEndianHost();
946   Image_PixMap::ImgFormat aFormat = Image_PixMap::ImgUNKNOWN;
947   switch (aBufferType)
948   {
949     case Graphic3d_BT_RGB:   aFormat = isBigEndian ? Image_PixMap::ImgRGB  : Image_PixMap::ImgBGR;  break;
950     case Graphic3d_BT_RGBA:  aFormat = isBigEndian ? Image_PixMap::ImgRGBA : Image_PixMap::ImgBGRA; break;
951     case Graphic3d_BT_Depth: aFormat = Image_PixMap::ImgGrayF; break;
952   }
953
954   switch (aStereoPair)
955   {
956     case ViewerTest_SP_Single:
957     {
958       if (!aView->ToPixMap (aPixMap, aWidth, aHeight, aBufferType, Standard_True, aStereoOpts))
959       {
960         theDI << "Fail: view dump failed!\n";
961         return 0;
962       }
963       else if (aPixMap.SizeX() != Standard_Size(aWidth)
964             || aPixMap.SizeY() != Standard_Size(aHeight))
965       {
966         theDI << "Fail: dumped dimensions "    << (Standard_Integer )aPixMap.SizeX() << "x" << (Standard_Integer )aPixMap.SizeY()
967               << " are lesser than requested " << aWidth << "x" << aHeight << "\n";
968       }
969       break;
970     }
971     case ViewerTest_SP_SideBySide:
972     {
973       if (!aPixMap.InitZero (aFormat, aWidth * 2, aHeight))
974       {
975         theDI << "Fail: not enough memory for image allocation!\n";
976         return 0;
977       }
978
979       Image_PixMap aPixMapL, aPixMapR;
980       aPixMapL.InitWrapper (aPixMap.Format(), aPixMap.ChangeData(),
981                             aWidth, aHeight, aPixMap.SizeRowBytes());
982       aPixMapR.InitWrapper (aPixMap.Format(), aPixMap.ChangeData() + aPixMap.SizePixelBytes() * aWidth,
983                             aWidth, aHeight, aPixMap.SizeRowBytes());
984       if (!aView->ToPixMap (aPixMapL, aWidth, aHeight, aBufferType, Standard_True, V3d_SDO_LEFT_EYE)
985        || !aView->ToPixMap (aPixMapR, aWidth, aHeight, aBufferType, Standard_True, V3d_SDO_RIGHT_EYE)
986        )
987       {
988         theDI << "Fail: view dump failed!\n";
989         return 0;
990       }
991       break;
992     }
993     case ViewerTest_SP_OverUnder:
994     {
995       if (!aPixMap.InitZero (aFormat, aWidth, aHeight * 2))
996       {
997         theDI << "Fail: not enough memory for image allocation!\n";
998         return 0;
999       }
1000
1001       Image_PixMap aPixMapL, aPixMapR;
1002       aPixMapL.InitWrapper (aFormat, aPixMap.ChangeData(),
1003                             aWidth, aHeight, aPixMap.SizeRowBytes());
1004       aPixMapR.InitWrapper (aFormat, aPixMap.ChangeData() + aPixMap.SizeRowBytes() * aHeight,
1005                             aWidth, aHeight, aPixMap.SizeRowBytes());
1006       if (!aView->ToPixMap (aPixMapL, aWidth, aHeight, aBufferType, Standard_True, V3d_SDO_LEFT_EYE)
1007        || !aView->ToPixMap (aPixMapR, aWidth, aHeight, aBufferType, Standard_True, V3d_SDO_RIGHT_EYE))
1008       {
1009         theDI << "Fail: view dump failed!\n";
1010         return 0;
1011       }
1012       break;
1013     }
1014   }
1015
1016   if (!aPixMap.Save (aFilePath))
1017   {
1018     theDI << "Fail: image can not be saved!\n";
1019   }
1020   return 0;
1021 }
1022
1023 //==============================================================================
1024 //function : Displays,Erase...
1025 //purpose  :
1026 //Draw arg :
1027 //==============================================================================
1028 static int VwrTst_DispErase(const Handle(AIS_InteractiveObject)& IO,
1029                             const Standard_Integer Mode,
1030                             const Standard_Integer TypeOfOperation,
1031                             const Standard_Boolean Upd)
1032 {
1033   Handle(AIS_InteractiveContext) Ctx = ViewerTest::GetAISContext();
1034
1035   switch(TypeOfOperation){
1036   case 1:
1037     Ctx->Display(IO,Mode,Upd);
1038     break;
1039   case 2:{
1040     Ctx->Erase(IO,Upd);
1041     break;
1042   }
1043   case 3:{
1044     if(IO.IsNull())
1045       Ctx->SetDisplayMode((AIS_DisplayMode)Mode,Upd);
1046     else
1047       Ctx->SetDisplayMode(IO,Mode,Upd);
1048     break;
1049   }
1050   case 4:{
1051     if(IO.IsNull())
1052       Ctx->SetDisplayMode(0,Upd);
1053     else
1054       Ctx->UnsetDisplayMode(IO,Upd);
1055     break;
1056   }
1057   }
1058   return 0;
1059 }
1060
1061 //=======================================================================
1062 //function :
1063 //purpose  :
1064 //=======================================================================
1065 static int VDispMode (Draw_Interpretor& , Standard_Integer argc, const char** argv)
1066 {
1067
1068   TCollection_AsciiString name;
1069   if(argc>3)
1070     return 1;
1071   // display others presentations
1072   Standard_Integer TypeOfOperation = (strcasecmp(argv[0],"vdispmode")==0)? 1:
1073     (strcasecmp(argv[0],"verasemode")==0) ? 2 :
1074       (strcasecmp(argv[0],"vsetdispmode")==0) ? 3 :
1075         (strcasecmp(argv[0],"vunsetdispmode")==0) ? 4 : -1;
1076
1077   Handle(AIS_InteractiveContext) Ctx = ViewerTest::GetAISContext();
1078
1079   //unset displaymode.. comportement particulier...
1080   if(TypeOfOperation==4){
1081     if(argc==1){
1082       if(Ctx->NbSelected()==0){
1083         Handle(AIS_InteractiveObject) IO;
1084         VwrTst_DispErase(IO,-1,4,Standard_False);
1085       }
1086       else{
1087         for(Ctx->InitSelected();Ctx->MoreSelected();Ctx->NextSelected())
1088           VwrTst_DispErase(Ctx->SelectedInteractive(),-1,4,Standard_False);}
1089       Ctx->UpdateCurrentViewer();
1090     }
1091     else{
1092       Handle(AIS_InteractiveObject) IO;
1093       name = argv[1];
1094       if(GetMapOfAIS().IsBound2(name)){
1095         IO = Handle(AIS_InteractiveObject)::DownCast(GetMapOfAIS().Find2(name));
1096         if (!IO.IsNull())
1097           VwrTst_DispErase(IO,-1,4,Standard_True);
1098       }
1099     }
1100   }
1101   else if(argc==2){
1102     Standard_Integer Dmode = Draw::Atoi(argv[1]);
1103     if(Ctx->NbSelected()==0 && TypeOfOperation==3){
1104       Handle(AIS_InteractiveObject) IO;
1105       VwrTst_DispErase(IO,Dmode,TypeOfOperation,Standard_True);
1106     }
1107     if(!Ctx->HasOpenedContext()){
1108       // set/unset display mode sur le Contexte...
1109       for(Ctx->InitSelected();Ctx->MoreSelected();Ctx->NextSelected()){
1110         VwrTst_DispErase(Ctx->SelectedInteractive(),Dmode,TypeOfOperation,Standard_False);
1111       }
1112       Ctx->UpdateCurrentViewer();
1113     }
1114     else{
1115       for(Ctx->InitSelected();Ctx->MoreSelected();Ctx->NextSelected())
1116         Ctx->Display(Ctx->SelectedInteractive(),Dmode);
1117     }
1118   }
1119   else{
1120     Handle(AIS_InteractiveObject) IO;
1121     name = argv[1];
1122     if(GetMapOfAIS().IsBound2(name))
1123       IO = Handle(AIS_InteractiveObject)::DownCast(GetMapOfAIS().Find2(name));
1124     if (!IO.IsNull())
1125       VwrTst_DispErase(IO,Draw::Atoi(argv[2]),TypeOfOperation,Standard_True);
1126   }
1127   return 0;
1128 }
1129
1130
1131 //=======================================================================
1132 //function :
1133 //purpose  :
1134 //=======================================================================
1135 static int VSubInt(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
1136 {
1137   if(argc==1) return 1;
1138   Standard_Integer On = Draw::Atoi(argv[1]);
1139   const Handle(AIS_InteractiveContext)& Ctx = ViewerTest::GetAISContext();
1140
1141   if(argc==2)
1142   {
1143     TCollection_AsciiString isOnOff = On == 1 ? "on" : "off";
1144     di << "Sub intensite is turned " << isOnOff << " for " << Ctx->NbSelected() << "objects\n";
1145     for (Ctx->InitSelected(); Ctx->MoreSelected(); Ctx->NextSelected())
1146     {
1147       if(On==1)
1148       {
1149         Ctx->SubIntensityOn (Ctx->SelectedInteractive(), Standard_False);
1150       }
1151       else
1152       {
1153         Ctx->SubIntensityOff (Ctx->SelectedInteractive(), Standard_False);
1154       }
1155     }
1156
1157     Ctx->UpdateCurrentViewer();
1158   }
1159   else {
1160     Handle(AIS_InteractiveObject) IO;
1161     TCollection_AsciiString name = argv[2];
1162     if(GetMapOfAIS().IsBound2(name)){
1163       IO = Handle(AIS_InteractiveObject)::DownCast(GetMapOfAIS().Find2(name));
1164       if (!IO.IsNull()) {
1165         if(On==1)
1166           Ctx->SubIntensityOn(IO);
1167         else
1168           Ctx->SubIntensityOff(IO);
1169       }
1170     }
1171     else return 1;
1172   }
1173   return 0;
1174 }
1175
1176 //! Auxiliary class to iterate presentations from different collections.
1177 class ViewTest_PrsIter
1178 {
1179 public:
1180
1181   //! Create and initialize iterator object.
1182   ViewTest_PrsIter (const TCollection_AsciiString& theName)
1183   : mySource (IterSource_All)
1184   {
1185     NCollection_Sequence<TCollection_AsciiString> aNames;
1186     if (!theName.IsEmpty())
1187     aNames.Append (theName);
1188     Init (aNames);
1189   }
1190
1191   //! Create and initialize iterator object.
1192   ViewTest_PrsIter (const NCollection_Sequence<TCollection_AsciiString>& theNames)
1193   : mySource (IterSource_All)
1194   {
1195     Init (theNames);
1196   }
1197
1198   //! Initialize the iterator.
1199   void Init (const NCollection_Sequence<TCollection_AsciiString>& theNames)
1200   {
1201     Handle(AIS_InteractiveContext) aCtx = ViewerTest::GetAISContext();
1202     mySeq = theNames;
1203     mySelIter.Nullify();
1204     myCurrent.Nullify();
1205     myCurrentTrs.Nullify();
1206     if (!mySeq.IsEmpty())
1207     {
1208       mySource = IterSource_List;
1209       mySeqIter = NCollection_Sequence<TCollection_AsciiString>::Iterator (mySeq);
1210     }
1211     else if (aCtx->NbSelected() > 0)
1212     {
1213       mySource  = IterSource_Selected;
1214       mySelIter = aCtx;
1215       mySelIter->InitSelected();
1216     }
1217     else
1218     {
1219       mySource = IterSource_All;
1220       myMapIter.Initialize (GetMapOfAIS());
1221     }
1222     initCurrent();
1223   }
1224
1225   const TCollection_AsciiString& CurrentName() const
1226   {
1227     return myCurrentName;
1228   }
1229
1230   const Handle(AIS_InteractiveObject)& Current() const
1231   {
1232     return myCurrent;
1233   }
1234
1235   const Handle(Standard_Transient)& CurrentTrs() const
1236   {
1237     return myCurrentTrs;
1238   }
1239
1240   //! @return true if iterator points to valid object within collection
1241   Standard_Boolean More() const
1242   {
1243     switch (mySource)
1244     {
1245       case IterSource_All:      return myMapIter.More();
1246       case IterSource_List:     return mySeqIter.More();
1247       case IterSource_Selected: return mySelIter->MoreSelected();
1248     }
1249     return Standard_False;
1250   }
1251
1252   //! Go to the next item.
1253   void Next()
1254   {
1255     myCurrentName.Clear();
1256     myCurrentTrs.Nullify();
1257     myCurrent.Nullify();
1258     switch (mySource)
1259     {
1260       case IterSource_All:
1261       {
1262         myMapIter.Next();
1263         break;
1264       }
1265       case IterSource_List:
1266       {
1267         mySeqIter.Next();
1268         break;
1269       }
1270       case IterSource_Selected:
1271       {
1272         mySelIter->NextSelected();
1273         break;
1274       }
1275     }
1276     initCurrent();
1277   }
1278
1279 private:
1280
1281   void initCurrent()
1282   {
1283     switch (mySource)
1284     {
1285       case IterSource_All:
1286       {
1287         if (myMapIter.More())
1288         {
1289           myCurrentName = myMapIter.Key2();
1290           myCurrentTrs  = myMapIter.Key1();
1291           myCurrent     = Handle(AIS_InteractiveObject)::DownCast (myCurrentTrs);
1292         }
1293         break;
1294       }
1295       case IterSource_List:
1296       {
1297         if (mySeqIter.More())
1298         {
1299           if (!GetMapOfAIS().IsBound2 (mySeqIter.Value()))
1300           {
1301             std::cout << "Error: object " << mySeqIter.Value() << " is not displayed!\n";
1302             return;
1303           }
1304           myCurrentName = mySeqIter.Value();
1305           myCurrentTrs  = GetMapOfAIS().Find2 (mySeqIter.Value());
1306           myCurrent     = Handle(AIS_InteractiveObject)::DownCast (myCurrentTrs);
1307         }
1308         break;
1309       }
1310       case IterSource_Selected:
1311       {
1312         if (mySelIter->MoreSelected())
1313         {
1314           myCurrentName = GetMapOfAIS().Find1 (mySelIter->SelectedInteractive());
1315           myCurrent     = mySelIter->SelectedInteractive();
1316         }
1317         break;
1318       }
1319     }
1320   }
1321
1322 private:
1323
1324   enum IterSource
1325   {
1326     IterSource_All,
1327     IterSource_List,
1328     IterSource_Selected
1329   };
1330
1331 private:
1332
1333   Handle(AIS_InteractiveContext) mySelIter;    //!< iterator for current (selected) objects (IterSource_Selected)
1334   ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName myMapIter; //!< iterator for map of all objects (IterSource_All)
1335   NCollection_Sequence<TCollection_AsciiString>           mySeq;
1336   NCollection_Sequence<TCollection_AsciiString>::Iterator mySeqIter;
1337
1338   TCollection_AsciiString        myCurrentName;//!< current item name
1339   Handle(Standard_Transient)     myCurrentTrs; //!< current item (as transient object)
1340   Handle(AIS_InteractiveObject)  myCurrent;    //!< current item
1341
1342   IterSource                     mySource;     //!< iterated collection
1343
1344 };
1345
1346 //==============================================================================
1347 //function : VInteriorStyle
1348 //purpose  : sets interior style of the a selected or named or displayed shape
1349 //==============================================================================
1350 static int VSetInteriorStyle (Draw_Interpretor& theDI,
1351                               Standard_Integer  theArgNb,
1352                               const char**      theArgVec)
1353 {
1354   const Handle(AIS_InteractiveContext)& aCtx = ViewerTest::GetAISContext();
1355   ViewerTest_AutoUpdater anUpdateTool (aCtx, ViewerTest::CurrentView());
1356   if (aCtx.IsNull())
1357   {
1358     std::cerr << "Error: no active view!\n";
1359     return 1;
1360   }
1361
1362   Standard_Integer anArgIter = 1;
1363   for (; anArgIter < theArgNb; ++anArgIter)
1364   {
1365     if (!anUpdateTool.parseRedrawMode (theArgVec[anArgIter]))
1366     {
1367       break;
1368     }
1369   }
1370   TCollection_AsciiString aName;
1371   if (theArgNb - anArgIter == 2)
1372   {
1373     aName = theArgVec[anArgIter++];
1374   }
1375   else if (theArgNb - anArgIter != 1)
1376   {
1377     std::cout << "Error: wrong number of arguments! See usage:\n";
1378     theDI.PrintHelp (theArgVec[0]);
1379     return 1;
1380   }
1381   Standard_Integer        anInterStyle = Aspect_IS_SOLID;
1382   TCollection_AsciiString aStyleArg (theArgVec[anArgIter++]);
1383   aStyleArg.LowerCase();
1384   if (aStyleArg == "empty")
1385   {
1386     anInterStyle = 0;
1387   }
1388   else if (aStyleArg == "hollow")
1389   {
1390     anInterStyle = 1;
1391   }
1392   else if (aStyleArg == "hatch")
1393   {
1394     anInterStyle = 2;
1395   }
1396   else if (aStyleArg == "solid")
1397   {
1398     anInterStyle = 3;
1399   }
1400   else if (aStyleArg == "hiddenline")
1401   {
1402     anInterStyle = 4;
1403   }
1404   else
1405   {
1406     anInterStyle = aStyleArg.IntegerValue();
1407   }
1408   if (anInterStyle < Aspect_IS_EMPTY
1409    || anInterStyle > Aspect_IS_HIDDENLINE)
1410   {
1411     std::cout << "Error: style must be within a range [0 (Aspect_IS_EMPTY), "
1412               << Aspect_IS_HIDDENLINE << " (Aspect_IS_HIDDENLINE)]\n";
1413     return 1;
1414   }
1415
1416   if (!aName.IsEmpty()
1417    && !GetMapOfAIS().IsBound2 (aName))
1418   {
1419     std::cout << "Error: object " << aName << " is not displayed!\n";
1420     return 1;
1421   }
1422
1423   if (aCtx->HasOpenedContext())
1424   {
1425     aCtx->CloseLocalContext();
1426   }
1427   for (ViewTest_PrsIter anIter (aName); anIter.More(); anIter.Next())
1428   {
1429     const Handle(AIS_InteractiveObject)& anIO = anIter.Current();
1430     if (!anIO.IsNull())
1431     {
1432       const Handle(Prs3d_Drawer)& aDrawer        = anIO->Attributes();
1433       Handle(Prs3d_ShadingAspect) aShadingAspect = aDrawer->ShadingAspect();
1434       Handle(Graphic3d_AspectFillArea3d) aFillAspect = aShadingAspect->Aspect();
1435       aFillAspect->SetInteriorStyle ((Aspect_InteriorStyle )anInterStyle);
1436       aCtx->RecomputePrsOnly (anIO, Standard_False, Standard_True);
1437     }
1438   }
1439   return 0;
1440 }
1441
1442 //! Auxiliary structure for VAspects
1443 struct ViewerTest_AspectsChangeSet
1444 {
1445   Standard_Integer         ToSetVisibility;
1446   Standard_Integer         Visibility;
1447
1448   Standard_Integer         ToSetColor;
1449   Quantity_Color           Color;
1450
1451   Standard_Integer         ToSetLineWidth;
1452   Standard_Real            LineWidth;
1453
1454   Standard_Integer         ToSetTypeOfLine;
1455   Aspect_TypeOfLine        TypeOfLine;
1456
1457   Standard_Integer         ToSetTransparency;
1458   Standard_Real            Transparency;
1459
1460   Standard_Integer         ToSetMaterial;
1461   Graphic3d_NameOfMaterial Material;
1462   TCollection_AsciiString  MatName;
1463
1464   NCollection_Sequence<TopoDS_Shape> SubShapes;
1465
1466   Standard_Integer         ToSetShowFreeBoundary;
1467   Standard_Integer         ToSetFreeBoundaryWidth;
1468   Standard_Real            FreeBoundaryWidth;
1469   Standard_Integer         ToSetFreeBoundaryColor;
1470   Quantity_Color           FreeBoundaryColor;
1471
1472   Standard_Integer         ToEnableIsoOnTriangulation;
1473
1474   Standard_Integer         ToSetMaxParamValue;
1475   Standard_Real            MaxParamValue;
1476
1477   //! Empty constructor
1478   ViewerTest_AspectsChangeSet()
1479   : ToSetVisibility   (0),
1480     Visibility        (1),
1481     ToSetColor        (0),
1482     Color             (DEFAULT_COLOR),
1483     ToSetLineWidth    (0),
1484     LineWidth         (1.0),
1485     ToSetTypeOfLine   (0),
1486     TypeOfLine        (Aspect_TOL_SOLID),
1487     ToSetTransparency (0),
1488     Transparency      (0.0),
1489     ToSetMaterial     (0),
1490     Material          (Graphic3d_NOM_DEFAULT),
1491     ToSetShowFreeBoundary      (0),
1492     ToSetFreeBoundaryWidth     (0),
1493     FreeBoundaryWidth          (1.0),
1494     ToSetFreeBoundaryColor     (0),
1495     FreeBoundaryColor          (DEFAULT_FREEBOUNDARY_COLOR),
1496     ToEnableIsoOnTriangulation (-1),
1497     ToSetMaxParamValue (0),
1498     MaxParamValue (500000) {}
1499
1500   //! @return true if no changes have been requested
1501   Standard_Boolean IsEmpty() const
1502   {
1503     return ToSetVisibility        == 0
1504         && ToSetLineWidth         == 0
1505         && ToSetTransparency      == 0
1506         && ToSetColor             == 0
1507         && ToSetMaterial          == 0
1508         && ToSetShowFreeBoundary  == 0
1509         && ToSetFreeBoundaryColor == 0
1510         && ToSetFreeBoundaryWidth == 0
1511         && ToSetMaxParamValue     == 0;
1512   }
1513
1514   //! @return true if properties are valid
1515   Standard_Boolean Validate (const Standard_Boolean theIsSubPart) const
1516   {
1517     Standard_Boolean isOk = Standard_True;
1518     if (Visibility != 0 && Visibility != 1)
1519     {
1520       std::cout << "Error: the visibility should be equal to 0 or 1 (0 - invisible; 1 - visible) (specified " << Visibility << ")\n";
1521       isOk = Standard_False;
1522     }
1523     if (LineWidth <= 0.0
1524      || LineWidth >  10.0)
1525     {
1526       std::cout << "Error: the width should be within [1; 10] range (specified " << LineWidth << ")\n";
1527       isOk = Standard_False;
1528     }
1529     if (Transparency < 0.0
1530      || Transparency > 1.0)
1531     {
1532       std::cout << "Error: the transparency should be within [0; 1] range (specified " << Transparency << ")\n";
1533       isOk = Standard_False;
1534     }
1535     if (theIsSubPart
1536      && ToSetTransparency)
1537     {
1538       std::cout << "Error: the transparency can not be defined for sub-part of object!\n";
1539       isOk = Standard_False;
1540     }
1541     if (ToSetMaterial == 1
1542      && Material == Graphic3d_NOM_DEFAULT)
1543     {
1544       std::cout << "Error: unknown material " << MatName << ".\n";
1545       isOk = Standard_False;
1546     }
1547     if (FreeBoundaryWidth <= 0.0
1548      || FreeBoundaryWidth >  10.0)
1549     {
1550       std::cout << "Error: the free boundary width should be within [1; 10] range (specified " << FreeBoundaryWidth << ")\n";
1551       isOk = Standard_False;
1552     }
1553     if (MaxParamValue < 0.0)
1554     {
1555       std::cout << "Error: the max parameter value should be greater than zero (specified " << MaxParamValue << ")\n";
1556       isOk = Standard_False;
1557     }
1558     return isOk;
1559   }
1560
1561 };
1562
1563 //==============================================================================
1564 //function : VAspects
1565 //purpose  :
1566 //==============================================================================
1567 static Standard_Integer VAspects (Draw_Interpretor& /*theDI*/,
1568                                   Standard_Integer  theArgNb,
1569                                   const char**      theArgVec)
1570 {
1571   TCollection_AsciiString aCmdName (theArgVec[0]);
1572   const Handle(AIS_InteractiveContext)& aCtx = ViewerTest::GetAISContext();
1573   ViewerTest_AutoUpdater anUpdateTool (aCtx, ViewerTest::CurrentView());
1574   if (aCtx.IsNull())
1575   {
1576     std::cerr << "Error: no active view!\n";
1577     return 1;
1578   }
1579
1580   Standard_Integer anArgIter = 1;
1581   Standard_Boolean isDefaults = Standard_False;
1582   NCollection_Sequence<TCollection_AsciiString> aNames;
1583   for (; anArgIter < theArgNb; ++anArgIter)
1584   {
1585     TCollection_AsciiString anArg = theArgVec[anArgIter];
1586     if (anUpdateTool.parseRedrawMode (anArg))
1587     {
1588       continue;
1589     }
1590     else if (!anArg.IsEmpty()
1591            && anArg.Value (1) != '-')
1592     {
1593       aNames.Append (anArg);
1594     }
1595     else
1596     {
1597       if (anArg == "-defaults")
1598       {
1599         isDefaults = Standard_True;
1600         ++anArgIter;
1601       }
1602       break;
1603     }
1604   }
1605
1606   if (!aNames.IsEmpty() && isDefaults)
1607   {
1608     std::cout << "Error: wrong syntax. If -defaults is used there should not be any objects' names!\n";
1609     return 1;
1610   }
1611
1612   NCollection_Sequence<ViewerTest_AspectsChangeSet> aChanges;
1613   aChanges.Append (ViewerTest_AspectsChangeSet());
1614   ViewerTest_AspectsChangeSet* aChangeSet = &aChanges.ChangeLast();
1615
1616   // parse syntax of legacy commands
1617   if (aCmdName == "vsetwidth")
1618   {
1619     if (aNames.IsEmpty()
1620     || !aNames.Last().IsRealValue())
1621     {
1622       std::cout << "Error: not enough arguments!\n";
1623       return 1;
1624     }
1625     aChangeSet->ToSetLineWidth = 1;
1626     aChangeSet->LineWidth = aNames.Last().RealValue();
1627     aNames.Remove (aNames.Length());
1628   }
1629   else if (aCmdName == "vunsetwidth")
1630   {
1631     aChangeSet->ToSetLineWidth = -1;
1632   }
1633   else if (aCmdName == "vsetcolor")
1634   {
1635     if (aNames.IsEmpty())
1636     {
1637       std::cout << "Error: not enough arguments!\n";
1638       return 1;
1639     }
1640     aChangeSet->ToSetColor = 1;
1641
1642     Quantity_NameOfColor aColor = Quantity_NOC_BLACK;
1643     Standard_Boolean     isOk   = Standard_False;
1644     if (Quantity_Color::ColorFromName (aNames.Last().ToCString(), aColor))
1645     {
1646       aChangeSet->Color = aColor;
1647       aNames.Remove (aNames.Length());
1648       isOk = Standard_True;
1649     }
1650     else if (aNames.Length() >= 3)
1651     {
1652       const TCollection_AsciiString anRgbStr[3] =
1653       {
1654         aNames.Value (aNames.Upper() - 2),
1655         aNames.Value (aNames.Upper() - 1),
1656         aNames.Value (aNames.Upper() - 0)
1657       };
1658       isOk = anRgbStr[0].IsRealValue()
1659           && anRgbStr[1].IsRealValue()
1660           && anRgbStr[2].IsRealValue();
1661       if (isOk)
1662       {
1663         Graphic3d_Vec4d anRgb;
1664         anRgb.x() = anRgbStr[0].RealValue();
1665         anRgb.y() = anRgbStr[1].RealValue();
1666         anRgb.z() = anRgbStr[2].RealValue();
1667         if (anRgb.x() < 0.0 || anRgb.x() > 1.0
1668          || anRgb.y() < 0.0 || anRgb.y() > 1.0
1669          || anRgb.z() < 0.0 || anRgb.z() > 1.0)
1670         {
1671           std::cout << "Error: RGB color values should be within range 0..1!\n";
1672           return 1;
1673         }
1674         aChangeSet->Color.SetValues (anRgb.x(), anRgb.y(), anRgb.z(), Quantity_TOC_RGB);
1675         aNames.Remove (aNames.Length());
1676         aNames.Remove (aNames.Length());
1677         aNames.Remove (aNames.Length());
1678       }
1679     }
1680     if (!isOk)
1681     {
1682       std::cout << "Error: not enough arguments!\n";
1683       return 1;
1684     }
1685   }
1686   else if (aCmdName == "vunsetcolor")
1687   {
1688     aChangeSet->ToSetColor = -1;
1689   }
1690   else if (aCmdName == "vsettransparency")
1691   {
1692     if (aNames.IsEmpty()
1693     || !aNames.Last().IsRealValue())
1694     {
1695       std::cout << "Error: not enough arguments!\n";
1696       return 1;
1697     }
1698     aChangeSet->ToSetTransparency = 1;
1699     aChangeSet->Transparency  = aNames.Last().RealValue();
1700     aNames.Remove (aNames.Length());
1701   }
1702   else if (aCmdName == "vunsettransparency")
1703   {
1704     aChangeSet->ToSetTransparency = -1;
1705   }
1706   else if (aCmdName == "vsetmaterial")
1707   {
1708     if (aNames.IsEmpty())
1709     {
1710       std::cout << "Error: not enough arguments!\n";
1711       return 1;
1712     }
1713     aChangeSet->ToSetMaterial = 1;
1714     aChangeSet->MatName  = aNames.Last();
1715     aChangeSet->Material = Graphic3d_MaterialAspect::MaterialFromName (aChangeSet->MatName.ToCString());
1716     aNames.Remove (aNames.Length());
1717   }
1718   else if (aCmdName == "vunsetmaterial")
1719   {
1720     aChangeSet->ToSetMaterial = -1;
1721   }
1722   else if (anArgIter >= theArgNb)
1723   {
1724     std::cout << "Error: not enough arguments!\n";
1725     return 1;
1726   }
1727
1728   if (!aChangeSet->IsEmpty())
1729   {
1730     anArgIter = theArgNb;
1731   }
1732   for (; anArgIter < theArgNb; ++anArgIter)
1733   {
1734     TCollection_AsciiString anArg = theArgVec[anArgIter];
1735     anArg.LowerCase();
1736     if (anArg == "-setwidth"
1737      || anArg == "-setlinewidth")
1738     {
1739       if (++anArgIter >= theArgNb)
1740       {
1741         std::cout << "Error: wrong syntax at " << anArg << "\n";
1742         return 1;
1743       }
1744       aChangeSet->ToSetLineWidth = 1;
1745       aChangeSet->LineWidth = Draw::Atof (theArgVec[anArgIter]);
1746     }
1747     else if (anArg == "-unsetwidth"
1748           || anArg == "-unsetlinewidth")
1749     {
1750       aChangeSet->ToSetLineWidth = -1;
1751       aChangeSet->LineWidth = 1.0;
1752     }
1753     else if (anArg == "-settransp"
1754           || anArg == "-settransparency")
1755     {
1756       if (++anArgIter >= theArgNb)
1757       {
1758         std::cout << "Error: wrong syntax at " << anArg << "\n";
1759         return 1;
1760       }
1761       aChangeSet->ToSetTransparency = 1;
1762       aChangeSet->Transparency = Draw::Atof (theArgVec[anArgIter]);
1763       if (aChangeSet->Transparency >= 0.0
1764        && aChangeSet->Transparency <= Precision::Confusion())
1765       {
1766         aChangeSet->ToSetTransparency = -1;
1767         aChangeSet->Transparency = 0.0;
1768       }
1769     }
1770     else if (anArg == "-setvis"
1771           || anArg == "-setvisibility")
1772     {
1773       if (++anArgIter >= theArgNb)
1774       {
1775         std::cout << "Error: wrong syntax at " << anArg << "\n";
1776         return 1;
1777       }
1778
1779       aChangeSet->ToSetVisibility = 1;
1780       aChangeSet->Visibility = Draw::Atoi (theArgVec[anArgIter]);
1781     }
1782     else if (anArg == "-setalpha")
1783     {
1784       if (++anArgIter >= theArgNb)
1785       {
1786         std::cout << "Error: wrong syntax at " << anArg << "\n";
1787         return 1;
1788       }
1789       aChangeSet->ToSetTransparency = 1;
1790       aChangeSet->Transparency  = Draw::Atof (theArgVec[anArgIter]);
1791       if (aChangeSet->Transparency < 0.0
1792        || aChangeSet->Transparency > 1.0)
1793       {
1794         std::cout << "Error: the transparency should be within [0; 1] range (specified " << aChangeSet->Transparency << ")\n";
1795         return 1;
1796       }
1797       aChangeSet->Transparency = 1.0 - aChangeSet->Transparency;
1798       if (aChangeSet->Transparency >= 0.0
1799        && aChangeSet->Transparency <= Precision::Confusion())
1800       {
1801         aChangeSet->ToSetTransparency = -1;
1802         aChangeSet->Transparency = 0.0;
1803       }
1804     }
1805     else if (anArg == "-unsettransp"
1806           || anArg == "-unsettransparency"
1807           || anArg == "-unsetalpha"
1808           || anArg == "-opaque")
1809     {
1810       aChangeSet->ToSetTransparency = -1;
1811       aChangeSet->Transparency = 0.0;
1812     }
1813     else if (anArg == "-setcolor")
1814     {
1815       Standard_Integer aNbComps  = 0;
1816       Standard_Integer aCompIter = anArgIter + 1;
1817       for (; aCompIter < theArgNb; ++aCompIter, ++aNbComps)
1818       {
1819         if (theArgVec[aCompIter][0] == '-')
1820         {
1821           break;
1822         }
1823       }
1824       switch (aNbComps)
1825       {
1826         case 1:
1827         {
1828           Quantity_NameOfColor aColor = Quantity_NOC_BLACK;
1829           Standard_CString     aName  = theArgVec[anArgIter + 1];
1830           if (!Quantity_Color::ColorFromName (aName, aColor))
1831           {
1832             std::cout << "Error: unknown color name '" << aName << "'\n";
1833             return 1;
1834           }
1835           aChangeSet->Color = aColor;
1836           break;
1837         }
1838         case 3:
1839         {
1840           Graphic3d_Vec3d anRgb;
1841           anRgb.x() = Draw::Atof (theArgVec[anArgIter + 1]);
1842           anRgb.y() = Draw::Atof (theArgVec[anArgIter + 2]);
1843           anRgb.z() = Draw::Atof (theArgVec[anArgIter + 3]);
1844           if (anRgb.x() < 0.0 || anRgb.x() > 1.0
1845            || anRgb.y() < 0.0 || anRgb.y() > 1.0
1846            || anRgb.z() < 0.0 || anRgb.z() > 1.0)
1847           {
1848             std::cout << "Error: RGB color values should be within range 0..1!\n";
1849             return 1;
1850           }
1851           aChangeSet->Color.SetValues (anRgb.x(), anRgb.y(), anRgb.z(), Quantity_TOC_RGB);
1852           break;
1853         }
1854         default:
1855         {
1856           std::cout << "Error: wrong syntax at " << anArg << "\n";
1857           return 1;
1858         }
1859       }
1860       aChangeSet->ToSetColor = 1;
1861       anArgIter += aNbComps;
1862     }
1863     else if (anArg == "-setlinetype")
1864     {
1865       if (++anArgIter >= theArgNb)
1866       {
1867         std::cout << "Error: wrong syntax at " << anArg << "\n";
1868         return 1;
1869       }
1870
1871       TCollection_AsciiString aValue (theArgVec[anArgIter]);
1872       aValue.LowerCase();
1873
1874       if (aValue.IsEqual ("solid"))
1875       {
1876         aChangeSet->TypeOfLine = Aspect_TOL_SOLID;
1877       }
1878       else if (aValue.IsEqual ("dot"))
1879       {
1880         aChangeSet->TypeOfLine = Aspect_TOL_DOT;
1881       }
1882       else if (aValue.IsEqual ("dash"))
1883       {
1884         aChangeSet->TypeOfLine = Aspect_TOL_DASH;
1885       }
1886       else if (aValue.IsEqual ("dotdash"))
1887       {
1888         aChangeSet->TypeOfLine = Aspect_TOL_DOTDASH;
1889       }
1890       else
1891       {
1892         std::cout << "Error: wrong syntax at " << anArg << "\n";
1893         return 1;
1894       }
1895
1896       aChangeSet->ToSetTypeOfLine = 1;
1897     }
1898     else if (anArg == "-unsetlinetype")
1899     {
1900       aChangeSet->ToSetTypeOfLine = -1;
1901     }
1902     else if (anArg == "-unsetcolor")
1903     {
1904       aChangeSet->ToSetColor = -1;
1905       aChangeSet->Color = DEFAULT_COLOR;
1906     }
1907     else if (anArg == "-setmat"
1908           || anArg == "-setmaterial")
1909     {
1910       if (++anArgIter >= theArgNb)
1911       {
1912         std::cout << "Error: wrong syntax at " << anArg << "\n";
1913         return 1;
1914       }
1915       aChangeSet->ToSetMaterial = 1;
1916       aChangeSet->MatName  = theArgVec[anArgIter];
1917       aChangeSet->Material = Graphic3d_MaterialAspect::MaterialFromName (aChangeSet->MatName.ToCString());
1918     }
1919     else if (anArg == "-unsetmat"
1920           || anArg == "-unsetmaterial")
1921     {
1922       aChangeSet->ToSetMaterial = -1;
1923       aChangeSet->Material = Graphic3d_NOM_DEFAULT;
1924     }
1925     else if (anArg == "-subshape"
1926           || anArg == "-subshapes")
1927     {
1928       if (isDefaults)
1929       {
1930         std::cout << "Error: wrong syntax. -subshapes can not be used together with -defaults call!\n";
1931         return 1;
1932       }
1933
1934       if (aNames.IsEmpty())
1935       {
1936         std::cout << "Error: main objects should specified explicitly when -subshapes is used!\n";
1937         return 1;
1938       }
1939
1940       aChanges.Append (ViewerTest_AspectsChangeSet());
1941       aChangeSet = &aChanges.ChangeLast();
1942
1943       for (++anArgIter; anArgIter < theArgNb; ++anArgIter)
1944       {
1945         Standard_CString aSubShapeName = theArgVec[anArgIter];
1946         if (*aSubShapeName == '-')
1947         {
1948           --anArgIter;
1949           break;
1950         }
1951
1952         TopoDS_Shape aSubShape = DBRep::Get (aSubShapeName);
1953         if (aSubShape.IsNull())
1954         {
1955           std::cerr << "Error: shape " << aSubShapeName << " doesn't found!\n";
1956           return 1;
1957         }
1958         aChangeSet->SubShapes.Append (aSubShape);
1959       }
1960
1961       if (aChangeSet->SubShapes.IsEmpty())
1962       {
1963         std::cerr << "Error: empty list is specified after -subshapes!\n";
1964         return 1;
1965       }
1966     }
1967     else if (anArg == "-freeboundary"
1968           || anArg == "-fb")
1969     {
1970       if (++anArgIter >= theArgNb)
1971       {
1972         std::cout << "Error: wrong syntax at " << anArg << "\n";
1973         return 1;
1974       }
1975       TCollection_AsciiString aValue (theArgVec[anArgIter]);
1976       aValue.LowerCase();
1977       if (aValue == "on"
1978        || aValue == "1")
1979       {
1980         aChangeSet->ToSetShowFreeBoundary = 1;
1981       }
1982       else if (aValue == "off"
1983             || aValue == "0")
1984       {
1985         aChangeSet->ToSetShowFreeBoundary = -1;
1986       }
1987       else
1988       {
1989         std::cout << "Error: wrong syntax at " << anArg << "\n";
1990         return 1;
1991       }
1992     }
1993     else if (anArg == "-setfreeboundarywidth"
1994           || anArg == "-setfbwidth")
1995     {
1996       if (++anArgIter >= theArgNb)
1997       {
1998         std::cout << "Error: wrong syntax at " << anArg << "\n";
1999         return 1;
2000       }
2001       aChangeSet->ToSetFreeBoundaryWidth = 1;
2002       aChangeSet->FreeBoundaryWidth = Draw::Atof (theArgVec[anArgIter]);
2003     }
2004     else if (anArg == "-unsetfreeboundarywidth"
2005           || anArg == "-unsetfbwidth")
2006     {
2007       aChangeSet->ToSetFreeBoundaryWidth = -1;
2008       aChangeSet->FreeBoundaryWidth = 1.0;
2009     }
2010     else if (anArg == "-setfreeboundarycolor"
2011           || anArg == "-setfbcolor")
2012     {
2013       Standard_Integer aNbComps  = 0;
2014       Standard_Integer aCompIter = anArgIter + 1;
2015       for (; aCompIter < theArgNb; ++aCompIter, ++aNbComps)
2016       {
2017         if (theArgVec[aCompIter][0] == '-')
2018         {
2019           break;
2020         }
2021       }
2022       switch (aNbComps)
2023       {
2024         case 1:
2025         {
2026           Quantity_NameOfColor aColor = Quantity_NOC_BLACK;
2027           Standard_CString     aName  = theArgVec[anArgIter + 1];
2028           if (!Quantity_Color::ColorFromName (aName, aColor))
2029           {
2030             std::cout << "Error: unknown free boundary color name '" << aName << "'\n";
2031             return 1;
2032           }
2033           aChangeSet->FreeBoundaryColor = aColor;
2034           break;
2035         }
2036         case 3:
2037         {
2038           Graphic3d_Vec3d anRgb;
2039           anRgb.x() = Draw::Atof (theArgVec[anArgIter + 1]);
2040           anRgb.y() = Draw::Atof (theArgVec[anArgIter + 2]);
2041           anRgb.z() = Draw::Atof (theArgVec[anArgIter + 3]);
2042           if (anRgb.x() < 0.0 || anRgb.x() > 1.0
2043            || anRgb.y() < 0.0 || anRgb.y() > 1.0
2044            || anRgb.z() < 0.0 || anRgb.z() > 1.0)
2045           {
2046             std::cout << "Error: free boundary RGB color values should be within range 0..1!\n";
2047             return 1;
2048           }
2049           aChangeSet->FreeBoundaryColor.SetValues (anRgb.x(), anRgb.y(), anRgb.z(), Quantity_TOC_RGB);
2050           break;
2051         }
2052         default:
2053         {
2054           std::cout << "Error: wrong syntax at " << anArg << "\n";
2055           return 1;
2056         }
2057       }
2058       aChangeSet->ToSetFreeBoundaryColor = 1;
2059       anArgIter += aNbComps;
2060     }
2061     else if (anArg == "-unsetfreeboundarycolor"
2062           || anArg == "-unsetfbcolor")
2063     {
2064       aChangeSet->ToSetFreeBoundaryColor = -1;
2065       aChangeSet->FreeBoundaryColor = DEFAULT_FREEBOUNDARY_COLOR;
2066     }
2067     else if (anArg == "-unset")
2068     {
2069       aChangeSet->ToSetVisibility = 1;
2070       aChangeSet->Visibility = 1;
2071       aChangeSet->ToSetLineWidth = -1;
2072       aChangeSet->LineWidth = 1.0;
2073       aChangeSet->ToSetTypeOfLine = -1;
2074       aChangeSet->TypeOfLine = Aspect_TOL_SOLID;
2075       aChangeSet->ToSetTransparency = -1;
2076       aChangeSet->Transparency = 0.0;
2077       aChangeSet->ToSetColor = -1;
2078       aChangeSet->Color = DEFAULT_COLOR;
2079       aChangeSet->ToSetMaterial = -1;
2080       aChangeSet->Material = Graphic3d_NOM_DEFAULT;
2081       aChangeSet->ToSetShowFreeBoundary = -1;
2082       aChangeSet->ToSetFreeBoundaryColor = -1;
2083       aChangeSet->FreeBoundaryColor = DEFAULT_FREEBOUNDARY_COLOR;
2084       aChangeSet->ToSetFreeBoundaryWidth = -1;
2085       aChangeSet->FreeBoundaryWidth = 1.0;
2086     }
2087     else if (anArg == "-isoontriangulation"
2088           || anArg == "-isoontriang")
2089     {
2090       if (++anArgIter >= theArgNb)
2091       {
2092         std::cout << "Error: wrong syntax at " << anArg << "\n";
2093         return 1;
2094       }
2095       TCollection_AsciiString aValue (theArgVec[anArgIter]);
2096       aValue.LowerCase();
2097       if (aValue == "on"
2098         || aValue == "1")
2099       {
2100         aChangeSet->ToEnableIsoOnTriangulation = 1;
2101       }
2102       else if (aValue == "off"
2103         || aValue == "0")
2104       {
2105         aChangeSet->ToEnableIsoOnTriangulation = 0;
2106       }
2107       else
2108       {
2109         std::cout << "Error: wrong syntax at " << anArg << "\n";
2110         return 1;
2111       }
2112     }
2113     else if (anArg == "-setmaxparamvalue")
2114     {
2115       if (++anArgIter >= theArgNb)
2116       {
2117         std::cout << "Error: wrong syntax at " << anArg << "\n";
2118         return 1;
2119       }
2120       aChangeSet->ToSetMaxParamValue = 1;
2121       aChangeSet->MaxParamValue = Draw::Atof (theArgVec[anArgIter]);
2122     }
2123     else
2124     {
2125       std::cout << "Error: wrong syntax at " << anArg << "\n";
2126       return 1;
2127     }
2128   }
2129
2130   Standard_Boolean isFirst = Standard_True;
2131   for (NCollection_Sequence<ViewerTest_AspectsChangeSet>::Iterator aChangesIter (aChanges);
2132        aChangesIter.More(); aChangesIter.Next())
2133   {
2134     if (!aChangesIter.Value().Validate (!isFirst))
2135     {
2136       return 1;
2137     }
2138     isFirst = Standard_False;
2139   }
2140
2141   if (aCtx->HasOpenedContext())
2142   {
2143     aCtx->CloseLocalContext();
2144   }
2145
2146   // special case for -defaults parameter.
2147   // all changed values will be set to DefaultDrawer.
2148   if (isDefaults)
2149   {
2150     const Handle(Prs3d_Drawer)& aDrawer = aCtx->DefaultDrawer();
2151
2152     if (aChangeSet->ToSetLineWidth != 0)
2153     {
2154       aDrawer->LineAspect()->SetWidth (aChangeSet->LineWidth);
2155       aDrawer->WireAspect()->SetWidth (aChangeSet->LineWidth);
2156       aDrawer->UnFreeBoundaryAspect()->SetWidth (aChangeSet->LineWidth);
2157       aDrawer->SeenLineAspect()->SetWidth (aChangeSet->LineWidth);
2158     }
2159     if (aChangeSet->ToSetColor != 0)
2160     {
2161       aDrawer->ShadingAspect()->SetColor        (aChangeSet->Color);
2162       aDrawer->LineAspect()->SetColor           (aChangeSet->Color);
2163       aDrawer->UnFreeBoundaryAspect()->SetColor (aChangeSet->Color);
2164       aDrawer->SeenLineAspect()->SetColor       (aChangeSet->Color);
2165       aDrawer->WireAspect()->SetColor           (aChangeSet->Color);
2166       aDrawer->PointAspect()->SetColor          (aChangeSet->Color);
2167     }
2168     if (aChangeSet->ToSetTypeOfLine != 0)
2169     {
2170       aDrawer->LineAspect()->SetTypeOfLine           (aChangeSet->TypeOfLine);
2171       aDrawer->WireAspect()->SetTypeOfLine           (aChangeSet->TypeOfLine);
2172       aDrawer->FreeBoundaryAspect()->SetTypeOfLine   (aChangeSet->TypeOfLine);
2173       aDrawer->UnFreeBoundaryAspect()->SetTypeOfLine (aChangeSet->TypeOfLine);
2174       aDrawer->SeenLineAspect()->SetTypeOfLine       (aChangeSet->TypeOfLine);
2175     }
2176     if (aChangeSet->ToSetTransparency != 0)
2177     {
2178       aDrawer->ShadingAspect()->SetTransparency (aChangeSet->Transparency);
2179     }
2180     if (aChangeSet->ToSetMaterial != 0)
2181     {
2182       aDrawer->ShadingAspect()->SetMaterial (aChangeSet->Material);
2183     }
2184     if (aChangeSet->ToSetShowFreeBoundary == 1)
2185     {
2186       aDrawer->SetFreeBoundaryDraw (Standard_True);
2187     }
2188     else if (aChangeSet->ToSetShowFreeBoundary == -1)
2189     {
2190       aDrawer->SetFreeBoundaryDraw (Standard_False);
2191     }
2192     if (aChangeSet->ToSetFreeBoundaryWidth != 0)
2193     {
2194       aDrawer->FreeBoundaryAspect()->SetWidth (aChangeSet->FreeBoundaryWidth);
2195     }
2196     if (aChangeSet->ToSetFreeBoundaryColor != 0)
2197     {
2198       aDrawer->FreeBoundaryAspect()->SetColor (aChangeSet->FreeBoundaryColor);
2199     }
2200     if (aChangeSet->ToEnableIsoOnTriangulation != -1)
2201     {
2202       aDrawer->SetIsoOnTriangulation (aChangeSet->ToEnableIsoOnTriangulation == 1);
2203     }
2204     if (aChangeSet->ToSetMaxParamValue != 0)
2205     {
2206       aDrawer->SetMaximalParameterValue (aChangeSet->MaxParamValue);
2207     }
2208
2209     // redisplay all objects in context
2210     for (ViewTest_PrsIter aPrsIter (aNames); aPrsIter.More(); aPrsIter.Next())
2211     {
2212       Handle(AIS_InteractiveObject)  aPrs = aPrsIter.Current();
2213       if (!aPrs.IsNull())
2214       {
2215         aCtx->Redisplay (aPrs, Standard_False);
2216       }
2217     }
2218     return 0;
2219   }
2220
2221   for (ViewTest_PrsIter aPrsIter (aNames); aPrsIter.More(); aPrsIter.Next())
2222   {
2223     const TCollection_AsciiString& aName   = aPrsIter.CurrentName();
2224     Handle(AIS_InteractiveObject)  aPrs    = aPrsIter.Current();
2225     Handle(Prs3d_Drawer)           aDrawer = aPrs->Attributes();
2226     Handle(AIS_ColoredShape) aColoredPrs;
2227     Standard_Boolean toDisplay = Standard_False;
2228     Standard_Boolean toRedisplay = Standard_False;
2229     if (aChanges.Length() > 1 || aChangeSet->ToSetVisibility == 1)
2230     {
2231       Handle(AIS_Shape) aShapePrs = Handle(AIS_Shape)::DownCast (aPrs);
2232       if (aShapePrs.IsNull())
2233       {
2234         std::cout << "Error: an object " << aName << " is not an AIS_Shape presentation!\n";
2235         return 1;
2236       }
2237       aColoredPrs = Handle(AIS_ColoredShape)::DownCast (aShapePrs);
2238       if (aColoredPrs.IsNull())
2239       {
2240         aColoredPrs = new AIS_ColoredShape (aShapePrs);
2241         aCtx->Remove (aShapePrs, Standard_False);
2242         GetMapOfAIS().UnBind2 (aName);
2243         GetMapOfAIS().Bind (aColoredPrs, aName);
2244         toDisplay = Standard_True;
2245         aShapePrs = aColoredPrs;
2246         aPrs      = aColoredPrs;
2247       }
2248     }
2249
2250     if (!aPrs.IsNull())
2251     {
2252       NCollection_Sequence<ViewerTest_AspectsChangeSet>::Iterator aChangesIter (aChanges);
2253       aChangeSet = &aChangesIter.ChangeValue();
2254       if (aChangeSet->ToSetVisibility == 1)
2255       {
2256         Handle(AIS_ColoredDrawer) aColDrawer = aColoredPrs->CustomAspects (aColoredPrs->Shape());
2257         aColDrawer->SetHidden (aChangeSet->Visibility == 0);
2258       }
2259       else if (aChangeSet->ToSetMaterial == 1)
2260       {
2261         aCtx->SetMaterial (aPrs, aChangeSet->Material, Standard_False);
2262       }
2263       else if (aChangeSet->ToSetMaterial == -1)
2264       {
2265         aCtx->UnsetMaterial (aPrs, Standard_False);
2266       }
2267       if (aChangeSet->ToSetColor == 1)
2268       {
2269         aCtx->SetColor (aPrs, aChangeSet->Color, Standard_False);
2270       }
2271       else if (aChangeSet->ToSetColor == -1)
2272       {
2273         aCtx->UnsetColor (aPrs, Standard_False);
2274       }
2275       if (aChangeSet->ToSetTransparency == 1)
2276       {
2277         aCtx->SetTransparency (aPrs, aChangeSet->Transparency, Standard_False);
2278       }
2279       else if (aChangeSet->ToSetTransparency == -1)
2280       {
2281         aCtx->UnsetTransparency (aPrs, Standard_False);
2282       }
2283       if (aChangeSet->ToSetLineWidth == 1)
2284       {
2285         aCtx->SetWidth (aPrs, aChangeSet->LineWidth, Standard_False);
2286       }
2287       else if (aChangeSet->ToSetLineWidth == -1)
2288       {
2289         aCtx->UnsetWidth (aPrs, Standard_False);
2290       }
2291       else if (aChangeSet->ToEnableIsoOnTriangulation != -1)
2292       {
2293         aCtx->IsoOnTriangulation (aChangeSet->ToEnableIsoOnTriangulation == 1, aPrs);
2294         toRedisplay = Standard_True;
2295       }
2296       if (!aDrawer.IsNull())
2297       {
2298         if (aChangeSet->ToSetShowFreeBoundary == 1)
2299         {
2300           aDrawer->SetFreeBoundaryDraw (Standard_True);
2301           toRedisplay = Standard_True;
2302         }
2303         else if (aChangeSet->ToSetShowFreeBoundary == -1)
2304         {
2305           aDrawer->SetFreeBoundaryDraw (Standard_False);
2306           toRedisplay = Standard_True;
2307         }
2308         if (aChangeSet->ToSetFreeBoundaryWidth != 0)
2309         {
2310           Handle(Prs3d_LineAspect) aBoundaryAspect =
2311               new Prs3d_LineAspect (Quantity_NOC_RED, Aspect_TOL_SOLID, 1.0);
2312           *aBoundaryAspect->Aspect() = *aDrawer->FreeBoundaryAspect()->Aspect();
2313           aBoundaryAspect->SetWidth (aChangeSet->FreeBoundaryWidth);
2314           aDrawer->SetFreeBoundaryAspect (aBoundaryAspect);
2315           toRedisplay = Standard_True;
2316         }
2317         if (aChangeSet->ToSetFreeBoundaryColor != 0)
2318         {
2319           Handle(Prs3d_LineAspect) aBoundaryAspect =
2320               new Prs3d_LineAspect (Quantity_NOC_RED, Aspect_TOL_SOLID, 1.0);
2321           *aBoundaryAspect->Aspect() = *aDrawer->FreeBoundaryAspect()->Aspect();
2322           aBoundaryAspect->SetColor (aChangeSet->FreeBoundaryColor);
2323           aDrawer->SetFreeBoundaryAspect (aBoundaryAspect);
2324           toRedisplay = Standard_True;
2325         }
2326         if (aChangeSet->ToSetTypeOfLine != 0)
2327         {
2328           aDrawer->LineAspect()->SetTypeOfLine           (aChangeSet->TypeOfLine);
2329           aDrawer->WireAspect()->SetTypeOfLine           (aChangeSet->TypeOfLine);
2330           aDrawer->FreeBoundaryAspect()->SetTypeOfLine   (aChangeSet->TypeOfLine);
2331           aDrawer->UnFreeBoundaryAspect()->SetTypeOfLine (aChangeSet->TypeOfLine);
2332           aDrawer->SeenLineAspect()->SetTypeOfLine       (aChangeSet->TypeOfLine);
2333           toRedisplay = Standard_True;
2334         }
2335         if (aChangeSet->ToSetMaxParamValue != 0)
2336         {
2337           aDrawer->SetMaximalParameterValue (aChangeSet->MaxParamValue);
2338         }
2339       }
2340
2341       for (aChangesIter.Next(); aChangesIter.More(); aChangesIter.Next())
2342       {
2343         aChangeSet = &aChangesIter.ChangeValue();
2344         for (NCollection_Sequence<TopoDS_Shape>::Iterator aSubShapeIter (aChangeSet->SubShapes);
2345              aSubShapeIter.More(); aSubShapeIter.Next())
2346         {
2347           const TopoDS_Shape& aSubShape = aSubShapeIter.Value();
2348           if (aChangeSet->ToSetVisibility == 1)
2349           {
2350             Handle(AIS_ColoredDrawer) aCurColDrawer = aColoredPrs->CustomAspects (aSubShape);
2351             aCurColDrawer->SetHidden (aChangeSet->Visibility == 0);
2352           }
2353           if (aChangeSet->ToSetColor == 1)
2354           {
2355             aColoredPrs->SetCustomColor (aSubShape, aChangeSet->Color);
2356           }
2357           if (aChangeSet->ToSetLineWidth == 1)
2358           {
2359             aColoredPrs->SetCustomWidth (aSubShape, aChangeSet->LineWidth);
2360           }
2361           if (aChangeSet->ToSetColor     == -1
2362            || aChangeSet->ToSetLineWidth == -1)
2363           {
2364             aColoredPrs->UnsetCustomAspects (aSubShape, Standard_True);
2365           }
2366           if (aChangeSet->ToSetMaxParamValue != 0)
2367           {
2368             Handle(AIS_ColoredDrawer) aCurColDrawer = aColoredPrs->CustomAspects (aSubShape);
2369             aCurColDrawer->SetMaximalParameterValue (aChangeSet->MaxParamValue);
2370           }
2371         }
2372       }
2373       if (toDisplay)
2374       {
2375         aCtx->Display (aPrs, Standard_False);
2376       }
2377       if (toRedisplay)
2378       {
2379         aCtx->Redisplay (aPrs, Standard_False);
2380       }
2381       else if (!aColoredPrs.IsNull())
2382       {
2383         aCtx->Redisplay (aColoredPrs, Standard_False);
2384       }
2385     }
2386   }
2387   return 0;
2388 }
2389
2390 //==============================================================================
2391 //function : VDonly2
2392 //author   : ege
2393 //purpose  : Display only a selected or named  object
2394 //           if there is no selected or named object s, nothing is done
2395 //==============================================================================
2396 static int VDonly2 (Draw_Interpretor& ,
2397                     Standard_Integer  theArgNb,
2398                     const char**      theArgVec)
2399 {
2400   const Handle(AIS_InteractiveContext)& aCtx = ViewerTest::GetAISContext();
2401   ViewerTest_AutoUpdater anUpdateTool (aCtx, ViewerTest::CurrentView());
2402   if (aCtx.IsNull())
2403   {
2404     std::cerr << "Error: no active view!\n";
2405     return 1;
2406   }
2407
2408   if (aCtx->HasOpenedContext())
2409   {
2410     aCtx->CloseLocalContext();
2411   }
2412
2413   Standard_Integer anArgIter = 1;
2414   for (; anArgIter < theArgNb; ++anArgIter)
2415   {
2416     if (!anUpdateTool.parseRedrawMode (theArgVec[anArgIter]))
2417     {
2418       break;
2419     }
2420   }
2421
2422   NCollection_Map<Handle(Standard_Transient)> aDispSet;
2423   if (anArgIter >= theArgNb)
2424   {
2425     // display only selected objects
2426     if (aCtx->NbSelected() < 1)
2427     {
2428       return 0;
2429     }
2430
2431     for (aCtx->InitSelected(); aCtx->MoreSelected(); aCtx->NextSelected())
2432     {
2433       aDispSet.Add (aCtx->SelectedInteractive());
2434     }
2435   }
2436   else
2437   {
2438     // display only specified objects
2439     for (; anArgIter < theArgNb; ++anArgIter)
2440     {
2441       TCollection_AsciiString aName = theArgVec[anArgIter];
2442       if (GetMapOfAIS().IsBound2 (aName))
2443       {
2444         const Handle(AIS_InteractiveObject) aShape = Handle(AIS_InteractiveObject)::DownCast (GetMapOfAIS().Find2 (aName));
2445         if (!aShape.IsNull())
2446         {
2447           aCtx->Display (aShape, Standard_False);
2448           aDispSet.Add (aShape);
2449         }
2450       }
2451     }
2452   }
2453
2454   // weed out other objects
2455   for (ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName anIter (GetMapOfAIS()); anIter.More(); anIter.Next())
2456   {
2457     if (aDispSet.Contains (anIter.Key1()))
2458     {
2459       continue;
2460     }
2461
2462     const Handle(AIS_InteractiveObject) aShape = Handle(AIS_InteractiveObject)::DownCast (anIter.Key1());
2463     if (aShape.IsNull())
2464     {
2465       aCtx->Erase (aShape, Standard_False);
2466     }
2467   }
2468   return 0;
2469 }
2470
2471 //==============================================================================
2472 //function : VRemove
2473 //purpose  : Removes selected or named objects.
2474 //           If there is no selected or named objects,
2475 //           all objects in the viewer can be removed with argument -all.
2476 //           If -context is in arguments, the object is not deleted from the map of
2477 //           objects (deleted only from the current context).
2478 //==============================================================================
2479 int VRemove (Draw_Interpretor& theDI,
2480              Standard_Integer  theArgNb,
2481              const char**      theArgVec)
2482 {
2483   const Handle(AIS_InteractiveContext)& aCtx = ViewerTest::GetAISContext();
2484   ViewerTest_AutoUpdater anUpdateTool (aCtx, ViewerTest::CurrentView());
2485   if (aCtx.IsNull())
2486   {
2487     std::cerr << "Error: no active view!\n";
2488     return 1;
2489   }
2490
2491   Standard_Boolean isContextOnly = Standard_False;
2492   Standard_Boolean toRemoveAll   = Standard_False;
2493   Standard_Boolean toPrintInfo   = Standard_True;
2494   Standard_Boolean toRemoveLocal = Standard_False;
2495
2496   Standard_Integer anArgIter = 1;
2497   for (; anArgIter < theArgNb; ++anArgIter)
2498   {
2499     TCollection_AsciiString anArg = theArgVec[anArgIter];
2500     anArg.LowerCase();
2501     if (anArg == "-context")
2502     {
2503       isContextOnly = Standard_True;
2504     }
2505     else if (anArg == "-all")
2506     {
2507       toRemoveAll = Standard_True;
2508     }
2509     else if (anArg == "-noinfo")
2510     {
2511       toPrintInfo = Standard_False;
2512     }
2513     else if (anArg == "-local")
2514     {
2515       toRemoveLocal = Standard_True;
2516     }
2517     else if (anUpdateTool.parseRedrawMode (anArg))
2518     {
2519       continue;
2520     }
2521     else
2522     {
2523       break;
2524     }
2525   }
2526   if (toRemoveAll
2527    && anArgIter < theArgNb)
2528   {
2529     std::cerr << "Error: wrong syntax!\n";
2530     return 1;
2531   }
2532
2533   if (toRemoveLocal && !aCtx->HasOpenedContext())
2534   {
2535     std::cerr << "Error: local selection context is not open.\n";
2536     return 1;
2537   }
2538   else if (!toRemoveLocal && aCtx->HasOpenedContext())
2539   {
2540     aCtx->CloseAllContexts (Standard_False);
2541   }
2542
2543   NCollection_List<TCollection_AsciiString> anIONameList;
2544   if (toRemoveAll)
2545   {
2546     for (ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName anIter (GetMapOfAIS());
2547          anIter.More(); anIter.Next())
2548     {
2549       anIONameList.Append (anIter.Key2());
2550     }
2551   }
2552   else if (anArgIter < theArgNb) // removed objects names are in argument list
2553   {
2554     for (; anArgIter < theArgNb; ++anArgIter)
2555     {
2556       TCollection_AsciiString aName = theArgVec[anArgIter];
2557       if (!GetMapOfAIS().IsBound2 (aName))
2558       {
2559         theDI << aName.ToCString() << " was not bound to some object.\n";
2560         continue;
2561       }
2562
2563       const Handle(AIS_InteractiveObject) anIO = Handle(AIS_InteractiveObject)::DownCast (GetMapOfAIS().Find2 (aName));
2564       if (anIO->GetContext() != aCtx)
2565       {
2566         theDI << aName.ToCString() << " was not displayed in current context.\n";
2567         theDI << "Please activate view with this object displayed and try again.\n";
2568         continue;
2569       }
2570
2571       anIONameList.Append (aName);
2572       continue;
2573     }
2574   }
2575   else if (aCtx->NbSelected() > 0)
2576   {
2577     for (ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName anIter (GetMapOfAIS());
2578          anIter.More(); anIter.Next())
2579     {
2580       const Handle(AIS_InteractiveObject) anIO = Handle(AIS_InteractiveObject)::DownCast (anIter.Key1());
2581       if (!aCtx->IsSelected (anIO))
2582       {
2583         continue;
2584       }
2585
2586       anIONameList.Append (anIter.Key2());
2587       continue;
2588     }
2589   }
2590
2591   // Unbind all removed objects from the map of displayed IO.
2592   for (NCollection_List<TCollection_AsciiString>::Iterator anIter (anIONameList);
2593        anIter.More(); anIter.Next())
2594   {
2595     const Handle(AIS_InteractiveObject) anIO  = Handle(AIS_InteractiveObject)::DownCast (GetMapOfAIS().Find2 (anIter.Value()));
2596     aCtx->Remove (anIO, Standard_False);
2597     if (toPrintInfo)
2598     {
2599       theDI << anIter.Value().ToCString() << " was removed\n";
2600     }
2601     if (!isContextOnly)
2602     {
2603       GetMapOfAIS().UnBind2 (anIter.Value());
2604     }
2605   }
2606
2607   // Close local context if it is empty
2608   TColStd_MapOfTransient aLocalIO;
2609   if (aCtx->HasOpenedContext()
2610    && !aCtx->LocalContext()->DisplayedObjects (aLocalIO))
2611   {
2612     aCtx->CloseAllContexts (Standard_False);
2613   }
2614
2615   return 0;
2616 }
2617
2618 //==============================================================================
2619 //function : VErase
2620 //purpose  : Erase some selected or named objects
2621 //           if there is no selected or named objects, the whole viewer is erased
2622 //==============================================================================
2623 int VErase (Draw_Interpretor& theDI,
2624             Standard_Integer  theArgNb,
2625             const char**      theArgVec)
2626 {
2627   const Handle(AIS_InteractiveContext)& aCtx  = ViewerTest::GetAISContext();
2628   const Handle(V3d_View)&               aView = ViewerTest::CurrentView();
2629   ViewerTest_AutoUpdater anUpdateTool (aCtx, aView);
2630   if (aCtx.IsNull())
2631   {
2632     std::cerr << "Error: no active view!\n";
2633     return 1;
2634   }
2635
2636   const Standard_Boolean toEraseAll = TCollection_AsciiString (theArgNb > 0 ? theArgVec[0] : "") == "veraseall";
2637
2638   Standard_Integer anArgIter = 1;
2639   Standard_Boolean toEraseLocal  = Standard_False;
2640   Standard_Boolean toEraseInView = Standard_False;
2641   TColStd_SequenceOfAsciiString aNamesOfEraseIO;
2642   for (; anArgIter < theArgNb; ++anArgIter)
2643   {
2644     TCollection_AsciiString anArgCase (theArgVec[anArgIter]);
2645     anArgCase.LowerCase();
2646     if (anUpdateTool.parseRedrawMode (anArgCase))
2647     {
2648       continue;
2649     }
2650     else if (anArgCase == "-local")
2651     {
2652       toEraseLocal = Standard_True;
2653     }
2654     else if (anArgCase == "-view"
2655           || anArgCase == "-inview")
2656     {
2657       toEraseInView = Standard_True;
2658     }
2659     else
2660     {
2661       aNamesOfEraseIO.Append (theArgVec[anArgIter]);
2662     }
2663   }
2664
2665   if (!aNamesOfEraseIO.IsEmpty() && toEraseAll)
2666   {
2667     std::cerr << "Error: wrong syntax, " << theArgVec[0] << " too much arguments.\n";
2668     return 1;
2669   }
2670
2671   if (toEraseLocal && !aCtx->HasOpenedContext())
2672   {
2673     std::cerr << "Error: local selection context is not open.\n";
2674     return 1;
2675   }
2676   else if (!toEraseLocal && aCtx->HasOpenedContext())
2677   {
2678     aCtx->CloseAllContexts (Standard_False);
2679   }
2680
2681   if (!aNamesOfEraseIO.IsEmpty())
2682   {
2683     // Erase named objects
2684     for (Standard_Integer anIter = 1; anIter <= aNamesOfEraseIO.Length(); ++anIter)
2685     {
2686       TCollection_AsciiString aName = aNamesOfEraseIO.Value (anIter);
2687       if (!GetMapOfAIS().IsBound2 (aName))
2688       {
2689         continue;
2690       }
2691
2692       const Handle(Standard_Transient)    anObj = GetMapOfAIS().Find2 (aName);
2693       const Handle(AIS_InteractiveObject) anIO  = Handle(AIS_InteractiveObject)::DownCast (anObj);
2694       theDI << aName.ToCString() << " ";
2695       if (!anIO.IsNull())
2696       {
2697         if (toEraseInView)
2698         {
2699           aCtx->SetViewAffinity (anIO, aView, Standard_False);
2700         }
2701         else
2702         {
2703           aCtx->Erase (anIO, Standard_False);
2704         }
2705       }
2706     }
2707   }
2708   else if (!toEraseAll && aCtx->NbSelected() > 0)
2709   {
2710     // Erase selected objects
2711     for (ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName anIter (GetMapOfAIS());
2712          anIter.More(); anIter.Next())
2713     {
2714       const Handle(AIS_InteractiveObject) anIO = Handle(AIS_InteractiveObject)::DownCast (anIter.Key1());
2715       if (!anIO.IsNull()
2716        && aCtx->IsSelected (anIO))
2717       {
2718         theDI << anIter.Key2().ToCString() << " ";
2719         if (toEraseInView)
2720         {
2721           aCtx->SetViewAffinity (anIO, aView, Standard_False);
2722         }
2723         else
2724         {
2725           aCtx->Erase (anIO, Standard_False);
2726         }
2727       }
2728     }
2729   }
2730   else
2731   {
2732     // Erase all objects
2733     for (ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName anIter (GetMapOfAIS());
2734          anIter.More(); anIter.Next())
2735     {
2736       const Handle(AIS_InteractiveObject) anIO = Handle(AIS_InteractiveObject)::DownCast (anIter.Key1());
2737       if (!anIO.IsNull())
2738       {
2739         if (toEraseInView)
2740         {
2741           aCtx->SetViewAffinity (anIO, aView, Standard_False);
2742         }
2743         else
2744         {
2745           aCtx->Erase (anIO, Standard_False);
2746         }
2747       }
2748     }
2749   }
2750
2751   return 0;
2752 }
2753
2754 //==============================================================================
2755 //function : VDisplayAll
2756 //author   : ege
2757 //purpose  : Display all the objects of the Map
2758 //==============================================================================
2759 static int VDisplayAll (Draw_Interpretor& ,
2760                         Standard_Integer  theArgNb,
2761                         const char**      theArgVec)
2762
2763 {
2764   const Handle(AIS_InteractiveContext)& aCtx = ViewerTest::GetAISContext();
2765   ViewerTest_AutoUpdater anUpdateTool (aCtx, ViewerTest::CurrentView());
2766   if (aCtx.IsNull())
2767   {
2768     std::cerr << "Error: no active view!\n";
2769     return 1;
2770   }
2771
2772   Standard_Integer anArgIter = 1;
2773   Standard_Boolean toDisplayLocal = Standard_False;
2774   for (; anArgIter < theArgNb; ++anArgIter)
2775   {
2776     TCollection_AsciiString anArgCase (theArgVec[anArgIter]);
2777     anArgCase.LowerCase();
2778     if (anArgCase == "-local")
2779     {
2780       toDisplayLocal = Standard_True;
2781     }
2782     else if (anUpdateTool.parseRedrawMode (anArgCase))
2783     {
2784       continue;
2785     }
2786     else
2787     {
2788       break;
2789     }
2790   }
2791   if (anArgIter < theArgNb)
2792   {
2793     std::cout << theArgVec[0] << "Error: wrong syntax\n";
2794     return 1;
2795   }
2796
2797   if (toDisplayLocal && !aCtx->HasOpenedContext())
2798   {
2799     std::cerr << "Error: local selection context is not open.\n";
2800     return 1;
2801   }
2802   else if (!toDisplayLocal && aCtx->HasOpenedContext())
2803   {
2804     aCtx->CloseLocalContext (Standard_False);
2805   }
2806
2807   for (ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName anIter (GetMapOfAIS());
2808        anIter.More(); anIter.Next())
2809   {
2810     const Handle(AIS_InteractiveObject) aShape = Handle(AIS_InteractiveObject)::DownCast (anIter.Key1());
2811     aCtx->Erase (aShape, Standard_False);
2812   }
2813
2814   for (ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName anIter (GetMapOfAIS());
2815        anIter.More(); anIter.Next())
2816   {
2817     const Handle(AIS_InteractiveObject) aShape = Handle(AIS_InteractiveObject)::DownCast (anIter.Key1());
2818     aCtx->Display (aShape, Standard_False);
2819   }
2820   return 0;
2821 }
2822
2823 //! Auxiliary method to find presentation
2824 inline Handle(PrsMgr_Presentation) findPresentation (const Handle(AIS_InteractiveContext)& theCtx,
2825                                                      const Handle(AIS_InteractiveObject)&  theIO,
2826                                                      const Standard_Integer                theMode)
2827 {
2828   if (theIO.IsNull())
2829   {
2830     return Handle(PrsMgr_Presentation)();
2831   }
2832
2833   if (theMode != -1)
2834   {
2835     if (theCtx->MainPrsMgr()->HasPresentation (theIO, theMode))
2836     {
2837       return theCtx->MainPrsMgr()->Presentation (theIO, theMode);
2838     }
2839   }
2840   else if (theCtx->MainPrsMgr()->HasPresentation (theIO, theIO->DisplayMode()))
2841   {
2842     return theCtx->MainPrsMgr()->Presentation (theIO, theIO->DisplayMode());
2843   }
2844   else if (theCtx->MainPrsMgr()->HasPresentation (theIO, theCtx->DisplayMode()))
2845   {
2846     return theCtx->MainPrsMgr()->Presentation (theIO, theCtx->DisplayMode());
2847   }
2848   return Handle(PrsMgr_Presentation)();
2849 }
2850
2851 enum ViewerTest_BndAction
2852 {
2853   BndAction_Hide,
2854   BndAction_Show,
2855   BndAction_Print
2856 };
2857
2858 //! Auxiliary method to print bounding box of presentation
2859 inline void bndPresentation (Draw_Interpretor&                  theDI,
2860                              const Handle(PrsMgr_Presentation)& thePrs,
2861                              const TCollection_AsciiString&     theName,
2862                              const ViewerTest_BndAction         theAction)
2863 {
2864   switch (theAction)
2865   {
2866     case BndAction_Hide:
2867     {
2868       thePrs->Presentation()->GraphicUnHighlight();
2869       break;
2870     }
2871     case BndAction_Show:
2872     {
2873       Handle(Graphic3d_Structure) aPrs (thePrs->Presentation());
2874       aPrs->CStructure()->HighlightColor.r = 0.988235f;
2875       aPrs->CStructure()->HighlightColor.g = 0.988235f;
2876       aPrs->CStructure()->HighlightColor.b = 0.988235f;
2877       aPrs->CStructure()->HighlightWithBndBox (aPrs, Standard_True);
2878       break;
2879     }
2880     case BndAction_Print:
2881     {
2882       Bnd_Box aBox = thePrs->Presentation()->MinMaxValues();
2883       gp_Pnt aMin = aBox.CornerMin();
2884       gp_Pnt aMax = aBox.CornerMax();
2885       theDI << theName  << "\n"
2886             << aMin.X() << " " << aMin.Y() << " " << aMin.Z() << " "
2887             << aMax.X() << " " << aMax.Y() << " " << aMax.Z() << "\n";
2888       break;
2889     }
2890   }
2891 }
2892
2893 //==============================================================================
2894 //function : VBounding
2895 //purpose  :
2896 //==============================================================================
2897 int VBounding (Draw_Interpretor& theDI,
2898                Standard_Integer  theArgNb,
2899                const char**      theArgVec)
2900 {
2901   Handle(AIS_InteractiveContext) aCtx = ViewerTest::GetAISContext();
2902   ViewerTest_AutoUpdater anUpdateTool (aCtx, ViewerTest::CurrentView());
2903   if (aCtx.IsNull())
2904   {
2905     std::cout << "Error: no active view!\n";
2906     return 1;
2907   }
2908
2909   ViewerTest_BndAction anAction = BndAction_Show;
2910   Standard_Integer     aMode    = -1;
2911
2912   Standard_Integer anArgIter = 1;
2913   for (; anArgIter < theArgNb; ++anArgIter)
2914   {
2915     TCollection_AsciiString anArg (theArgVec[anArgIter]);
2916     anArg.LowerCase();
2917     if (anArg == "-print")
2918     {
2919       anAction = BndAction_Print;
2920     }
2921     else if (anArg == "-show")
2922     {
2923       anAction = BndAction_Show;
2924     }
2925     else if (anArg == "-hide")
2926     {
2927       anAction = BndAction_Hide;
2928     }
2929     else if (anArg == "-mode")
2930     {
2931       if (++anArgIter >= theArgNb)
2932       {
2933         std::cout << "Error: wrong syntax at " << anArg << "\n";
2934         return 1;
2935       }
2936       aMode = Draw::Atoi (theArgVec[anArgIter]);
2937     }
2938     else if (!anUpdateTool.parseRedrawMode (anArg))
2939     {
2940       break;
2941     }
2942   }
2943
2944   if (anArgIter < theArgNb)
2945   {
2946     // has a list of names
2947     for (; anArgIter < theArgNb; ++anArgIter)
2948     {
2949       TCollection_AsciiString aName = theArgVec[anArgIter];
2950       if (!GetMapOfAIS().IsBound2 (aName))
2951       {
2952         std::cout << "Error: presentation " << aName << " does not exist\n";
2953         return 1;
2954       }
2955
2956       Handle(AIS_InteractiveObject) anIO = Handle(AIS_InteractiveObject)::DownCast (GetMapOfAIS().Find2 (aName));
2957       Handle(PrsMgr_Presentation)   aPrs = findPresentation (aCtx, anIO, aMode);
2958       if (aPrs.IsNull())
2959       {
2960         std::cout << "Error: presentation " << aName << " does not exist\n";
2961         return 1;
2962       }
2963       bndPresentation (theDI, aPrs, aName, anAction);
2964     }
2965   }
2966   else if (aCtx->NbSelected() > 0)
2967   {
2968     // remove all currently selected objects
2969     for (aCtx->InitSelected(); aCtx->MoreSelected(); aCtx->NextSelected())
2970     {
2971       Handle(AIS_InteractiveObject) anIO = aCtx->SelectedInteractive();
2972       Handle(PrsMgr_Presentation)   aPrs = findPresentation (aCtx, anIO, aMode);
2973       if (!aPrs.IsNull())
2974       {
2975         bndPresentation (theDI, aPrs, GetMapOfAIS().IsBound1 (anIO) ? GetMapOfAIS().Find1 (anIO) : "", anAction);
2976       }
2977     }
2978   }
2979   else
2980   {
2981     // all objects
2982     for (ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName anIter (GetMapOfAIS());
2983          anIter.More(); anIter.Next())
2984     {
2985       Handle(AIS_InteractiveObject) anIO = Handle(AIS_InteractiveObject)::DownCast (anIter.Key1());
2986       Handle(PrsMgr_Presentation)   aPrs = findPresentation (aCtx, anIO, aMode);
2987       if (!aPrs.IsNull())
2988       {
2989         bndPresentation (theDI, aPrs, anIter.Key2(), anAction);
2990       }
2991     }
2992   }
2993   return 0;
2994 }
2995
2996 //==============================================================================
2997 //function : VTexture
2998 //purpose  :
2999 //==============================================================================
3000 Standard_Integer VTexture (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const char** theArgv)
3001 {
3002   TCollection_AsciiString aCommandName (theArgv[0]);
3003
3004   NCollection_DataMap<TCollection_AsciiString, Handle(TColStd_HSequenceOfAsciiString)> aMapOfArgs;
3005   if (aCommandName == "vtexture")
3006   {
3007     if (theArgsNb < 2)
3008     {
3009       std::cout << theArgv[0] << ": " << " invalid arguments.\n";
3010       std::cout << "Type help for more information.\n";
3011       return 1;
3012     }
3013
3014     // look for options of vtexture command
3015     TCollection_AsciiString aParseKey;
3016     for (Standard_Integer anArgIt = 2; anArgIt < theArgsNb; ++anArgIt)
3017     {
3018       TCollection_AsciiString anArg (theArgv [anArgIt]);
3019
3020       anArg.UpperCase();
3021       if (anArg.Value (1) == '-' && !anArg.IsRealValue())
3022       {
3023         aParseKey = anArg;
3024         aParseKey.Remove (1);
3025         aParseKey.UpperCase();
3026         aMapOfArgs.Bind (aParseKey, new TColStd_HSequenceOfAsciiString);
3027         continue;
3028       }
3029
3030       if (aParseKey.IsEmpty())
3031       {
3032         continue;
3033       }
3034
3035       aMapOfArgs(aParseKey)->Append (anArg);
3036     }
3037   }
3038   else if (aCommandName == "vtexscale"
3039         || aCommandName == "vtexorigin"
3040         || aCommandName == "vtexrepeat")
3041   {
3042     // scan for parameters of vtexscale, vtexorigin, vtexrepeat commands
3043     // equal to -scale, -origin, -repeat options of vtexture command
3044     if (theArgsNb < 2 || theArgsNb > 4)
3045     {
3046       std::cout << theArgv[0] << ": " << " invalid arguments.\n";
3047       std::cout << "Type help for more information.\n";
3048       return 1;
3049     }
3050
3051     Handle(TColStd_HSequenceOfAsciiString) anArgs = new TColStd_HSequenceOfAsciiString;
3052     if (theArgsNb == 2)
3053     {
3054       anArgs->Append ("OFF");
3055     }
3056     else if (theArgsNb == 4)
3057     {
3058       anArgs->Append (TCollection_AsciiString (theArgv[2]));
3059       anArgs->Append (TCollection_AsciiString (theArgv[3]));
3060     }
3061
3062     TCollection_AsciiString anArgKey;
3063     if (aCommandName == "vtexscale")
3064     {
3065       anArgKey = "SCALE";
3066     }
3067     else if (aCommandName == "vtexorigin")
3068     {
3069       anArgKey = "ORIGIN";
3070     }
3071     else
3072     {
3073       anArgKey = "REPEAT";
3074     }
3075
3076     aMapOfArgs.Bind (anArgKey, anArgs);
3077   }
3078   else if (aCommandName == "vtexdefault")
3079   {
3080     // scan for parameters of vtexdefault command
3081     // equal to -default option of vtexture command
3082     aMapOfArgs.Bind ("DEFAULT", new TColStd_HSequenceOfAsciiString);
3083   }
3084
3085   // Check arguments for validity
3086   NCollection_DataMap<TCollection_AsciiString, Handle(TColStd_HSequenceOfAsciiString)>::Iterator aMapIt (aMapOfArgs);
3087   for (; aMapIt.More(); aMapIt.Next())
3088   {
3089     const TCollection_AsciiString& aKey = aMapIt.Key();
3090     const Handle(TColStd_HSequenceOfAsciiString)& anArgs = aMapIt.Value();
3091
3092     // -scale, -origin, -repeat: one argument "off", or two real values
3093     if ((aKey.IsEqual ("SCALE") || aKey.IsEqual ("ORIGIN") || aKey.IsEqual ("REPEAT"))
3094       && ((anArgs->Length() == 1 && anArgs->Value(1) == "OFF")
3095        || (anArgs->Length() == 2 && anArgs->Value(1).IsRealValue() && anArgs->Value(2).IsRealValue())))
3096     {
3097       continue;
3098     }
3099
3100     // -modulate: single argument "on" / "off"
3101     if (aKey.IsEqual ("MODULATE") && anArgs->Length() == 1 && (anArgs->Value(1) == "OFF" || anArgs->Value(1) == "ON"))
3102     {
3103       continue;
3104     }
3105
3106     // -default: no arguments
3107     if (aKey.IsEqual ("DEFAULT") && anArgs->IsEmpty())
3108     {
3109       continue;
3110     }
3111
3112     TCollection_AsciiString aLowerKey;
3113     aLowerKey  = "-";
3114     aLowerKey += aKey;
3115     aLowerKey.LowerCase();
3116     std::cout << theArgv[0] << ": " << aLowerKey << " is unknown option, or the arguments are unacceptable.\n";
3117     std::cout << "Type help for more information.\n";
3118     return 1;
3119   }
3120
3121   Handle(AIS_InteractiveContext) anAISContext = ViewerTest::GetAISContext();
3122   if (anAISContext.IsNull())
3123   {
3124     std::cout << aCommandName << ": " << " please use 'vinit' command to initialize view.\n";
3125     return 1;
3126   }
3127
3128   Standard_Integer aPreviousMode = 0;
3129
3130   ViewerTest::CurrentView()->SetSurfaceDetail (V3d_TEX_ALL);
3131
3132   TCollection_AsciiString aShapeName (theArgv[1]);
3133   Handle(AIS_InteractiveObject) anIO;
3134
3135   const ViewerTest_DoubleMapOfInteractiveAndName& aMapOfIO = GetMapOfAIS();
3136   if (aMapOfIO.IsBound2 (aShapeName))
3137   {
3138     anIO = Handle(AIS_InteractiveObject)::DownCast (aMapOfIO.Find2 (aShapeName));
3139   }
3140
3141   if (anIO.IsNull())
3142   {
3143     std::cout << aCommandName << ": shape " << aShapeName << " does not exists.\n";
3144     return 1;
3145   }
3146
3147   Handle(AIS_TexturedShape) aTexturedIO;
3148   if (anIO->IsKind (STANDARD_TYPE (AIS_TexturedShape)))
3149   {
3150     aTexturedIO = Handle(AIS_TexturedShape)::DownCast (anIO);
3151     aPreviousMode = aTexturedIO->DisplayMode();
3152   }
3153   else
3154   {
3155     anAISContext->Remove (anIO, Standard_False);
3156     aTexturedIO = new AIS_TexturedShape (DBRep::Get (theArgv[1]));
3157     GetMapOfAIS().UnBind1 (anIO);
3158     GetMapOfAIS().UnBind2 (aShapeName);
3159     GetMapOfAIS().Bind (aTexturedIO, aShapeName);
3160   }
3161
3162   // -------------------------------------------
3163   //  Turn texturing on/off - only for vtexture
3164   // -------------------------------------------
3165
3166   if (aCommandName == "vtexture")
3167   {
3168     TCollection_AsciiString aTextureArg (theArgsNb > 2 ? theArgv[2] : "");
3169
3170     if (aTextureArg.IsEmpty())
3171     {
3172       std::cout << aCommandName << ": " << " Texture mapping disabled.\n";
3173       std::cout << "To enable it, use 'vtexture NameOfShape NameOfTexture'\n" << "\n";
3174
3175       anAISContext->SetDisplayMode (aTexturedIO, AIS_Shaded, Standard_False);
3176       if (aPreviousMode == 3)
3177       {
3178         anAISContext->RecomputePrsOnly (aTexturedIO);
3179       }
3180
3181       anAISContext->Display (aTexturedIO, Standard_True);
3182       return 0;
3183     }
3184     else if (aTextureArg.Value(1) != '-') // "-option" on place of texture argument
3185     {
3186       if (aTextureArg == "?")
3187       {
3188         TCollection_AsciiString aTextureFolder = Graphic3d_TextureRoot::TexturesFolder();
3189
3190         theDi << "\n Files in current directory : \n" << "\n";
3191         theDi.Eval ("glob -nocomplain *");
3192
3193         TCollection_AsciiString aCmnd ("glob -nocomplain ");
3194         aCmnd += aTextureFolder;
3195         aCmnd += "/* ";
3196
3197         theDi << "Files in " << aTextureFolder.ToCString() << " : \n" << "\n";
3198         theDi.Eval (aCmnd.ToCString());
3199         return 0;
3200       }
3201       else
3202       {
3203         aTexturedIO->SetTextureFileName (aTextureArg);
3204       }
3205     }
3206   }
3207
3208   // ------------------------------------
3209   //  Process other options and commands
3210   // ------------------------------------
3211
3212   Handle(TColStd_HSequenceOfAsciiString) aValues;
3213   if (aMapOfArgs.Find ("DEFAULT", aValues))
3214   {
3215     aTexturedIO->SetTextureRepeat (Standard_False);
3216     aTexturedIO->SetTextureOrigin (Standard_False);
3217     aTexturedIO->SetTextureScale  (Standard_False);
3218     aTexturedIO->EnableTextureModulate();
3219   }
3220   else
3221   {
3222     if (aMapOfArgs.Find ("SCALE", aValues))
3223     {
3224       if (aValues->Value(1) != "OFF")
3225       {
3226         aTexturedIO->SetTextureScale (Standard_True, aValues->Value(1).RealValue(), aValues->Value(2).RealValue());
3227       }
3228       else
3229       {
3230         aTexturedIO->SetTextureScale (Standard_False);
3231       }
3232     }
3233
3234     if (aMapOfArgs.Find ("ORIGIN", aValues))
3235     {
3236       if (aValues->Value(1) != "OFF")
3237       {
3238         aTexturedIO->SetTextureOrigin (Standard_True, aValues->Value(1).RealValue(), aValues->Value(2).RealValue());
3239       }
3240       else
3241       {
3242         aTexturedIO->SetTextureOrigin (Standard_False);
3243       }
3244     }
3245
3246     if (aMapOfArgs.Find ("REPEAT", aValues))
3247     {
3248       if (aValues->Value(1) != "OFF")
3249       {
3250         aTexturedIO->SetTextureRepeat (Standard_True, aValues->Value(1).RealValue(), aValues->Value(2).RealValue());
3251       }
3252       else
3253       {
3254         aTexturedIO->SetTextureRepeat (Standard_False);
3255       }
3256     }
3257
3258     if (aMapOfArgs.Find ("MODULATE", aValues))
3259     {
3260       if (aValues->Value(1) == "ON")
3261       {
3262         aTexturedIO->EnableTextureModulate();
3263       }
3264       else
3265       {
3266         aTexturedIO->DisableTextureModulate();
3267       }
3268     }
3269   }
3270
3271   if (aTexturedIO->DisplayMode() == 3 || aPreviousMode == 3)
3272   {
3273     anAISContext->RecomputePrsOnly (aTexturedIO);
3274   }
3275   else
3276   {
3277     anAISContext->SetDisplayMode (aTexturedIO, 3, Standard_False);
3278     anAISContext->Display (aTexturedIO, Standard_True);
3279     anAISContext->Update (aTexturedIO,Standard_True);
3280   }
3281
3282   return 0;
3283 }
3284
3285 //! Auxiliary method to parse transformation persistence flags
3286 inline Standard_Boolean parseTrsfPersFlag (const TCollection_AsciiString& theFlagString,
3287                                            Standard_Integer&              theFlags)
3288 {
3289   if (theFlagString == "pan")
3290   {
3291     theFlags |= Graphic3d_TMF_PanPers;
3292   }
3293   else if (theFlagString == "zoom")
3294   {
3295     theFlags |= Graphic3d_TMF_ZoomPers;
3296   }
3297   else if (theFlagString == "rotate")
3298   {
3299     theFlags |= Graphic3d_TMF_RotatePers;
3300   }
3301   else if (theFlagString == "trihedron")
3302   {
3303     theFlags = Graphic3d_TMF_TriedronPers;
3304   }
3305   else if (theFlagString == "full")
3306   {
3307     theFlags = Graphic3d_TMF_FullPers;
3308   }
3309   else if (theFlagString == "none")
3310   {
3311     theFlags = Graphic3d_TMF_None;
3312   }
3313   else
3314   {
3315     return Standard_False;
3316   }
3317
3318   return Standard_True;
3319 }
3320
3321 //==============================================================================
3322 //function : VDisplay2
3323 //author   : ege
3324 //purpose  : Display an object from its name
3325 //==============================================================================
3326 static int VDisplay2 (Draw_Interpretor& theDI,
3327                       Standard_Integer  theArgNb,
3328                       const char**      theArgVec)
3329 {
3330   if (theArgNb < 2)
3331   {
3332     std::cerr << theArgVec[0] << "Error: wrong number of arguments.\n";
3333     return 1;
3334   }
3335
3336   Handle(AIS_InteractiveContext) aCtx = ViewerTest::GetAISContext();
3337   if (aCtx.IsNull())
3338   {
3339     ViewerTest::ViewerInit();
3340     aCtx = ViewerTest::GetAISContext();
3341   }
3342
3343   // Parse input arguments
3344   ViewerTest_AutoUpdater anUpdateTool (aCtx, ViewerTest::CurrentView());
3345   Standard_Integer   isMutable      = -1;
3346   Graphic3d_ZLayerId aZLayer        = Graphic3d_ZLayerId_UNKNOWN;
3347   Standard_Boolean   toDisplayLocal = Standard_False;
3348   Standard_Boolean   toReDisplay    = Standard_False;
3349   Standard_Integer   isSelectable   = -1;
3350   Standard_Integer   anObjDispMode  = -2;
3351   Standard_Integer   anObjHighMode  = -2;
3352   Standard_Boolean   toSetTrsfPers  = Standard_False;
3353   Graphic3d_TransModeFlags aTrsfPersFlags = Graphic3d_TMF_None;
3354   gp_Pnt aTPPosition;
3355   TColStd_SequenceOfAsciiString aNamesOfDisplayIO;
3356   AIS_DisplayStatus aDispStatus = AIS_DS_None;
3357   Standard_Integer toDisplayInView = Standard_False;
3358   for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
3359   {
3360     const TCollection_AsciiString aName     = theArgVec[anArgIter];
3361     TCollection_AsciiString       aNameCase = aName;
3362     aNameCase.LowerCase();
3363     if (anUpdateTool.parseRedrawMode (aName))
3364     {
3365       continue;
3366     }
3367     else if (aNameCase == "-mutable")
3368     {
3369       isMutable = 1;
3370     }
3371     else if (aNameCase == "-neutral")
3372     {
3373       aDispStatus = AIS_DS_Displayed;
3374     }
3375     else if (aNameCase == "-immediate"
3376           || aNameCase == "-top")
3377     {
3378       aZLayer = Graphic3d_ZLayerId_Top;
3379     }
3380     else if (aNameCase == "-topmost")
3381     {
3382       aZLayer = Graphic3d_ZLayerId_Topmost;
3383     }
3384     else if (aNameCase == "-osd"
3385           || aNameCase == "-toposd"
3386           || aNameCase == "-overlay")
3387     {
3388       aZLayer = Graphic3d_ZLayerId_TopOSD;
3389     }
3390     else if (aNameCase == "-botosd"
3391           || aNameCase == "-underlay")
3392     {
3393       aZLayer = Graphic3d_ZLayerId_BotOSD;
3394     }
3395     else if (aNameCase == "-select"
3396           || aNameCase == "-selectable")
3397     {
3398       isSelectable = 1;
3399     }
3400     else if (aNameCase == "-noselect"
3401           || aNameCase == "-noselection")
3402     {
3403       isSelectable = 0;
3404     }
3405     else if (aNameCase == "-dispmode"
3406           || aNameCase == "-displaymode")
3407     {
3408       if (++anArgIter >= theArgNb)
3409       {
3410         std::cerr << "Error: wrong syntax at " << aName << ".\n";
3411         return 1;
3412       }
3413
3414       anObjDispMode = Draw::Atoi (theArgVec [anArgIter]);
3415     }
3416     else if (aNameCase == "-highmode"
3417           || aNameCase == "-highlightmode")
3418     {
3419       if (++anArgIter >= theArgNb)
3420       {
3421         std::cerr << "Error: wrong syntax at " << aName << ".\n";
3422         return 1;
3423       }
3424
3425       anObjHighMode = Draw::Atoi (theArgVec [anArgIter]);
3426     }
3427     else if (aNameCase == "-3d")
3428     {
3429       toSetTrsfPers  = Standard_True;
3430       aTrsfPersFlags = Graphic3d_TMF_None;
3431     }
3432     else if (aNameCase == "-2d")
3433     {
3434       toSetTrsfPers  = Standard_True;
3435       aTrsfPersFlags = Graphic3d_TMF_2d;
3436     }
3437     else if (aNameCase == "-2dtopdown")
3438     {
3439       toSetTrsfPers  = Standard_True;
3440       aTrsfPersFlags = Graphic3d_TMF_2d | Graphic3d_TMF_2d_IsTopDown;
3441     }
3442     else if (aNameCase == "-trsfpers"
3443           || aNameCase == "-pers")
3444     {
3445       if (++anArgIter >= theArgNb)
3446       {
3447         std::cerr << "Error: wrong syntax at " << aName << ".\n";
3448         return 1;
3449       }
3450
3451       toSetTrsfPers  = Standard_True;
3452       aTrsfPersFlags = Graphic3d_TMF_None;
3453       TCollection_AsciiString aPersFlags (theArgVec [anArgIter]);
3454       aPersFlags.LowerCase();
3455       for (Standard_Integer aParserPos = aPersFlags.Search ("|");; aParserPos = aPersFlags.Search ("|"))
3456       {
3457         if (aParserPos == -1)
3458         {
3459           if (!parseTrsfPersFlag (aPersFlags, aTrsfPersFlags))
3460           {
3461             std::cerr << "Error: wrong transform persistence flags " << theArgVec [anArgIter] << ".\n";
3462             return 1;
3463           }
3464           break;
3465         }
3466
3467         TCollection_AsciiString anOtherFlags = aPersFlags.Split (aParserPos - 1);
3468         if (!parseTrsfPersFlag (aPersFlags, aTrsfPersFlags))
3469         {
3470           std::cerr << "Error: wrong transform persistence flags " << theArgVec [anArgIter] << ".\n";
3471           return 1;
3472         }
3473         aPersFlags = anOtherFlags;
3474       }
3475     }
3476     else if (aNameCase == "-trsfperspos"
3477           || aNameCase == "-perspos")
3478     {
3479       if (anArgIter + 2 >= theArgNb)
3480       {
3481         std::cerr << "Error: wrong syntax at " << aName << ".\n";
3482         return 1;
3483       }
3484
3485       TCollection_AsciiString aX (theArgVec[++anArgIter]);
3486       TCollection_AsciiString aY (theArgVec[++anArgIter]);
3487       TCollection_AsciiString aZ = "0";
3488       if (!aX.IsIntegerValue()
3489        || !aY.IsIntegerValue())
3490       {
3491         std::cerr << "Error: wrong syntax at " << aName << ".\n";
3492         return 1;
3493       }
3494       if (anArgIter + 1 < theArgNb)
3495       {
3496         TCollection_AsciiString aTemp = theArgVec[anArgIter + 1];
3497         if (aTemp.IsIntegerValue())
3498         {
3499           aZ = aTemp;
3500           ++anArgIter;
3501         }
3502       }
3503       aTPPosition.SetCoord (aX.IntegerValue(), aY.IntegerValue(), aZ.IntegerValue());
3504     }
3505     else if (aNameCase == "-layer")
3506     {
3507       if (++anArgIter >= theArgNb)
3508       {
3509         std::cerr << "Error: wrong syntax at " << aName << ".\n";
3510         return 1;
3511       }
3512
3513       TCollection_AsciiString aValue (theArgVec[anArgIter]);
3514       if (!aValue.IsIntegerValue())
3515       {
3516         std::cerr << "Error: wrong syntax at " << aName << ".\n";
3517         return 1;
3518       }
3519
3520       aZLayer = aValue.IntegerValue();
3521     }
3522     else if (aNameCase == "-view"
3523           || aNameCase == "-inview")
3524     {
3525       toDisplayInView = Standard_True;
3526     }
3527     else if (aNameCase == "-local")
3528     {
3529       aDispStatus = AIS_DS_Temporary;
3530       toDisplayLocal = Standard_True;
3531     }
3532     else if (aNameCase == "-redisplay")
3533     {
3534       toReDisplay = Standard_True;
3535     }
3536     else
3537     {
3538       aNamesOfDisplayIO.Append (aName);
3539     }
3540   }
3541
3542   if (aNamesOfDisplayIO.IsEmpty())
3543   {
3544     std::cerr << theArgVec[0] << "Error: wrong number of arguments.\n";
3545     return 1;
3546   }
3547
3548   // Prepare context for display
3549   if (toDisplayLocal && !aCtx->HasOpenedContext())
3550   {
3551     aCtx->OpenLocalContext (Standard_False);
3552   }
3553   else if (!toDisplayLocal && aCtx->HasOpenedContext())
3554   {
3555     aCtx->CloseAllContexts (Standard_False);
3556   }
3557
3558   // Display interactive objects
3559   for (Standard_Integer anIter = 1; anIter <= aNamesOfDisplayIO.Length(); ++anIter)
3560   {
3561     const TCollection_AsciiString& aName = aNamesOfDisplayIO.Value(anIter);
3562
3563     if (!GetMapOfAIS().IsBound2 (aName))
3564     {
3565       // create the AIS_Shape from a name
3566       const Handle(AIS_InteractiveObject) aShape = GetAISShapeFromName (aName.ToCString());
3567       if (!aShape.IsNull())
3568       {
3569         if (isMutable != -1)
3570         {
3571           aShape->SetMutable (isMutable == 1);
3572         }
3573         if (aZLayer != Graphic3d_ZLayerId_UNKNOWN)
3574         {
3575           aShape->SetZLayer (aZLayer);
3576         }
3577         if (toSetTrsfPers)
3578         {
3579           aShape->SetTransformPersistence (aTrsfPersFlags, aTPPosition);
3580         }
3581         if (anObjDispMode != -2)
3582         {
3583           aShape->SetDisplayMode (anObjDispMode);
3584         }
3585         if (anObjHighMode != -2)
3586         {
3587           aShape->SetHilightMode (anObjHighMode);
3588         }
3589         if (!toDisplayLocal)
3590           GetMapOfAIS().Bind (aShape, aName);
3591
3592         Standard_Integer aDispMode = aShape->HasDisplayMode()
3593                                    ? aShape->DisplayMode()
3594                                    : (aShape->AcceptDisplayMode (aCtx->DisplayMode())
3595                                     ? aCtx->DisplayMode()
3596                                     : 0);
3597         Standard_Integer aSelMode = -1;
3598         if (isSelectable ==  1 || (isSelectable == -1 && aCtx->GetAutoActivateSelection()))
3599         {
3600           aSelMode = aShape->GlobalSelectionMode();
3601         }
3602
3603         aCtx->Display (aShape, aDispMode, aSelMode,
3604                        Standard_False, aShape->AcceptShapeDecomposition(),
3605                        aDispStatus);
3606         if (toDisplayInView)
3607         {
3608           for (aCtx->CurrentViewer()->InitDefinedViews(); aCtx->CurrentViewer()->MoreDefinedViews(); aCtx->CurrentViewer()->NextDefinedViews())
3609           {
3610             aCtx->SetViewAffinity (aShape, aCtx->CurrentViewer()->DefinedView(), Standard_False);
3611           }
3612           aCtx->SetViewAffinity (aShape, ViewerTest::CurrentView(), Standard_True);
3613         }
3614       }
3615       else
3616       {
3617         std::cerr << "Error: object with name '" << aName << "' does not exist!\n";
3618       }
3619       continue;
3620     }
3621
3622     Handle(AIS_InteractiveObject) aShape = Handle(AIS_InteractiveObject)::DownCast (GetMapOfAIS().Find2 (aName));
3623     if (isMutable != -1)
3624     {
3625       aShape->SetMutable (isMutable == 1);
3626     }
3627     if (aZLayer != Graphic3d_ZLayerId_UNKNOWN)
3628     {
3629       aShape->SetZLayer (aZLayer);
3630     }
3631     if (toSetTrsfPers)
3632     {
3633       aShape->SetTransformPersistence (aTrsfPersFlags, aTPPosition);
3634     }
3635     if (anObjDispMode != -2)
3636     {
3637       aShape->SetDisplayMode (anObjDispMode);
3638     }
3639     if (anObjHighMode != -2)
3640     {
3641       aShape->SetHilightMode (anObjHighMode);
3642     }
3643     Standard_Integer aDispMode = aShape->HasDisplayMode()
3644                                 ? aShape->DisplayMode()
3645                                 : (aShape->AcceptDisplayMode (aCtx->DisplayMode())
3646                                 ? aCtx->DisplayMode()
3647                                 : 0);
3648     Standard_Integer aSelMode = -1;
3649     if (isSelectable ==  1 || (isSelectable == -1 && aCtx->GetAutoActivateSelection()))
3650     {
3651       aSelMode = aShape->GlobalSelectionMode();
3652     }
3653
3654     if (aShape->Type() == AIS_KOI_Datum)
3655     {
3656       aCtx->Display (aShape, Standard_False);
3657     }
3658     else
3659     {
3660       theDI << "Display " << aName.ToCString() << "\n";
3661
3662       // update the Shape in the AIS_Shape
3663       TopoDS_Shape      aNewShape = GetShapeFromName (aName.ToCString());
3664       Handle(AIS_Shape) aShapePrs = Handle(AIS_Shape)::DownCast(aShape);
3665       if (!aShapePrs.IsNull())
3666       {
3667         if (!aShapePrs->Shape().IsEqual (aNewShape))
3668         {
3669           toReDisplay = Standard_True;
3670         }
3671         aShapePrs->Set (aNewShape);
3672       }
3673       if (toReDisplay)
3674       {
3675         aCtx->Redisplay (aShape, Standard_False);
3676       }
3677
3678       if (aSelMode == -1)
3679       {
3680         aCtx->Erase (aShape);
3681       }
3682       aCtx->Display (aShape, aDispMode, aSelMode,
3683                      Standard_False, aShape->AcceptShapeDecomposition(),
3684                      aDispStatus);
3685       if (toDisplayInView)
3686       {
3687         aCtx->SetViewAffinity (aShape, ViewerTest::CurrentView(), Standard_True);
3688       }
3689     }
3690   }
3691
3692   return 0;
3693 }
3694
3695 //===============================================================================================
3696 //function : VUpdate
3697 //purpose  :
3698 //===============================================================================================
3699 static int VUpdate (Draw_Interpretor& /*theDi*/, Standard_Integer theArgsNb, const char** theArgVec)
3700 {
3701   Handle(AIS_InteractiveContext) aContextAIS = ViewerTest::GetAISContext();
3702   if (aContextAIS.IsNull())
3703   {
3704     std::cout << theArgVec[0] << "AIS context is not available.\n";
3705     return 1;
3706   }
3707
3708   if (theArgsNb < 2)
3709   {
3710     std::cout << theArgVec[0] << ": insufficient arguments. Type help for more information.\n";
3711     return 1;
3712   }
3713
3714   const ViewerTest_DoubleMapOfInteractiveAndName& anAISMap = GetMapOfAIS();
3715
3716   AIS_ListOfInteractive aListOfIO;
3717
3718   for (int anArgIt = 1; anArgIt < theArgsNb; ++anArgIt)
3719   {
3720     TCollection_AsciiString aName = TCollection_AsciiString (theArgVec[anArgIt]);
3721
3722     Handle(AIS_InteractiveObject) anAISObj;
3723     if (anAISMap.IsBound2 (aName))
3724     {
3725       anAISObj = Handle(AIS_InteractiveObject)::DownCast (anAISMap.Find2 (aName));
3726     }
3727
3728     if (anAISObj.IsNull())
3729     {
3730       std::cout << theArgVec[0] << ": no AIS interactive object named \"" << aName << "\".\n";
3731       return 1;
3732     }
3733
3734     aListOfIO.Append (anAISObj);
3735   }
3736
3737   AIS_ListIteratorOfListOfInteractive anIOIt (aListOfIO);
3738   for (; anIOIt.More(); anIOIt.Next())
3739   {
3740     aContextAIS->Update (anIOIt.Value(), Standard_False);
3741   }
3742
3743   aContextAIS->UpdateCurrentViewer();
3744
3745   return 0;
3746 }
3747
3748 //==============================================================================
3749 //function : VPerf
3750 //purpose  : Test the annimation of an object along a
3751 //           predifined trajectory
3752 //Draw arg : vperf ShapeName 1/0(Transfo/Location) 1/0(Primitives sensibles ON/OFF)
3753 //==============================================================================
3754
3755 static int VPerf(Draw_Interpretor& di, Standard_Integer , const char** argv) {
3756
3757   OSD_Timer myTimer;
3758   if (TheAISContext()->HasOpenedContext())
3759     TheAISContext()->CloseLocalContext();
3760
3761   Standard_Real Step=4*M_PI/180;
3762   Standard_Real Angle=0;
3763
3764   Handle(AIS_InteractiveObject) aIO;
3765   if (GetMapOfAIS().IsBound2(argv[1]))
3766     aIO = Handle(AIS_InteractiveObject)::DownCast(GetMapOfAIS().Find2(argv[1]));
3767   if (aIO.IsNull())
3768     return 1;
3769
3770   Handle(AIS_Shape) aShape = Handle(AIS_Shape)::DownCast(aIO);
3771
3772   myTimer.Start();
3773
3774   if (Draw::Atoi(argv[3])==1 ) {
3775     di<<" Primitives sensibles OFF"<<"\n";
3776     TheAISContext()->Deactivate(aIO);
3777   }
3778   else {
3779     di<<" Primitives sensibles ON"<<"\n";
3780   }
3781   // Movement par transformation
3782   if(Draw::Atoi(argv[2]) ==1) {
3783     di<<" Calcul par Transformation"<<"\n";
3784     for (Standard_Real myAngle=0;Angle<10*2*M_PI; myAngle++) {
3785
3786       Angle=Step*myAngle;
3787       gp_Trsf myTransfo;
3788       myTransfo.SetRotation(gp_Ax1(gp_Pnt(0,0,0),gp_Dir(0,0,1) ) ,Angle );
3789       TheAISContext()->SetLocation(aShape,myTransfo);
3790       TheAISContext() ->UpdateCurrentViewer();
3791
3792     }
3793   }
3794   else {
3795     di<<" Calcul par Locations"<<"\n";
3796     gp_Trsf myAngleTrsf;
3797     myAngleTrsf.SetRotation(gp_Ax1(gp_Pnt(0,0,0),gp_Dir(0,0,1) ), Step  );
3798     TopLoc_Location myDeltaAngle (myAngleTrsf);
3799     TopLoc_Location myTrueLoc;
3800
3801     for (Standard_Real myAngle=0;Angle<10*2*M_PI; myAngle++) {
3802
3803       Angle=Step*myAngle;
3804       myTrueLoc=myTrueLoc*myDeltaAngle;
3805       TheAISContext()->SetLocation(aShape,myTrueLoc );
3806       TheAISContext() ->UpdateCurrentViewer();
3807     }
3808   }
3809   if (Draw::Atoi(argv[3])==1 ){
3810     // On reactive la selection des primitives sensibles
3811     TheAISContext()->Activate(aIO,0);
3812   }
3813   a3DView() -> Redraw();
3814   myTimer.Stop();
3815   di<<" Temps ecoule "<<"\n";
3816   myTimer.Show();
3817   return 0;
3818 }
3819
3820
3821 //==================================================================================
3822 // Function : VAnimation
3823 //==================================================================================
3824 static int VAnimation (Draw_Interpretor& di, Standard_Integer argc, const char** argv) {
3825   if (argc != 5) {
3826     di<<"Use: "<<argv[0]<<" CrankArmFile CylinderHeadFile PropellerFile EngineBlockFile"<<"\n";
3827     return 1;
3828   }
3829
3830   Standard_Real thread = 4;
3831   Standard_Real angleA=0;
3832   Standard_Real angleB;
3833   Standard_Real X;
3834   gp_Ax1 Ax1(gp_Pnt(0,0,0),gp_Vec(0,0,1));
3835
3836   BRep_Builder B;
3837   TopoDS_Shape CrankArm;
3838   TopoDS_Shape CylinderHead;
3839   TopoDS_Shape Propeller;
3840   TopoDS_Shape EngineBlock;
3841
3842   //BRepTools::Read(CrankArm,"/dp_26/Indus/ege/assemblage/CrankArm.rle",B);
3843   //BRepTools::Read(CylinderHead,"/dp_26/Indus/ege/assemblage/CylinderHead.rle",B);
3844   //BRepTools::Read(Propeller,"/dp_26/Indus/ege/assemblage/Propeller.rle",B);
3845   //BRepTools::Read(EngineBlock,"/dp_26/Indus/ege/assemblage/EngineBlock.rle",B);
3846   BRepTools::Read(CrankArm,argv[1],B);
3847   BRepTools::Read(CylinderHead,argv[2],B);
3848   BRepTools::Read(Propeller,argv[3],B);
3849   BRepTools::Read(EngineBlock,argv[4],B);
3850
3851   if (CrankArm.IsNull() || CylinderHead.IsNull() || Propeller.IsNull() || EngineBlock.IsNull()) {di<<" Syntaxe error:loading failure."<<"\n";}
3852
3853
3854   OSD_Timer myTimer;
3855   myTimer.Start();
3856
3857   Handle(AIS_Shape) myAisCylinderHead = new AIS_Shape (CylinderHead);
3858   Handle(AIS_Shape) myAisEngineBlock  = new AIS_Shape (EngineBlock);
3859   Handle(AIS_Shape) myAisCrankArm     = new AIS_Shape (CrankArm);
3860   Handle(AIS_Shape) myAisPropeller    = new AIS_Shape (Propeller);
3861
3862   GetMapOfAIS().Bind(myAisCylinderHead,"a");
3863   GetMapOfAIS().Bind(myAisEngineBlock,"b");
3864   GetMapOfAIS().Bind(myAisCrankArm,"c");
3865   GetMapOfAIS().Bind(myAisPropeller,"d");
3866
3867   myAisCylinderHead->SetMutable (Standard_True);
3868   myAisEngineBlock ->SetMutable (Standard_True);
3869   myAisCrankArm    ->SetMutable (Standard_True);
3870   myAisPropeller   ->SetMutable (Standard_True);
3871
3872   TheAISContext()->SetColor (myAisCylinderHead, Quantity_NOC_INDIANRED);
3873   TheAISContext()->SetColor (myAisEngineBlock,  Quantity_NOC_RED);
3874   TheAISContext()->SetColor (myAisPropeller,    Quantity_NOC_GREEN);
3875
3876   TheAISContext()->Display (myAisCylinderHead, Standard_False);
3877   TheAISContext()->Display (myAisEngineBlock,  Standard_False);
3878   TheAISContext()->Display (myAisCrankArm,     Standard_False);
3879   TheAISContext()->Display (myAisPropeller,    Standard_False);
3880
3881   TheAISContext()->Deactivate(myAisCylinderHead);
3882   TheAISContext()->Deactivate(myAisEngineBlock );
3883   TheAISContext()->Deactivate(myAisCrankArm    );
3884   TheAISContext()->Deactivate(myAisPropeller   );
3885
3886   // Boucle de mouvement
3887   for (Standard_Real myAngle = 0;angleA<2*M_PI*10.175 ;myAngle++) {
3888
3889     angleA = thread*myAngle*M_PI/180;
3890     X = Sin(angleA)*3/8;
3891     angleB = atan(X / Sqrt(-X * X + 1));
3892     Standard_Real decal(25*0.6);
3893
3894
3895     //Build a transformation on the display
3896     gp_Trsf aPropellerTrsf;
3897     aPropellerTrsf.SetRotation(Ax1,angleA);
3898     TheAISContext()->SetLocation(myAisPropeller,aPropellerTrsf);
3899
3900     gp_Ax3 base(gp_Pnt(3*decal*(1-Cos(angleA)),-3*decal*Sin(angleA),0),gp_Vec(0,0,1),gp_Vec(1,0,0));
3901     gp_Trsf aCrankArmTrsf;
3902     aCrankArmTrsf.SetTransformation(   base.Rotated(gp_Ax1(gp_Pnt(3*decal,0,0),gp_Dir(0,0,1)),angleB));
3903     TheAISContext()->SetLocation(myAisCrankArm,aCrankArmTrsf);
3904
3905     TheAISContext()->UpdateCurrentViewer();
3906   }
3907
3908   TopoDS_Shape myNewCrankArm  =myAisCrankArm ->Shape().Located( myAisCrankArm ->Transformation() );
3909   TopoDS_Shape myNewPropeller =myAisPropeller->Shape().Located( myAisPropeller->Transformation() );
3910
3911   myAisCrankArm ->ResetTransformation();
3912   myAisPropeller->ResetTransformation();
3913
3914   myAisCrankArm  -> Set(myNewCrankArm );
3915   myAisPropeller -> Set(myNewPropeller);
3916
3917   TheAISContext()->Activate(myAisCylinderHead,0);
3918   TheAISContext()->Activate(myAisEngineBlock,0 );
3919   TheAISContext()->Activate(myAisCrankArm ,0   );
3920   TheAISContext()->Activate(myAisPropeller ,0  );
3921
3922   myTimer.Stop();
3923   myTimer.Show();
3924   myTimer.Start();
3925
3926   TheAISContext()->Redisplay(myAisCrankArm ,Standard_False);
3927   TheAISContext()->Redisplay(myAisPropeller,Standard_False);
3928
3929   TheAISContext()->UpdateCurrentViewer();
3930   a3DView()->Redraw();
3931
3932   myTimer.Stop();
3933   myTimer.Show();
3934
3935   return 0;
3936
3937 }
3938
3939 //==============================================================================
3940 //function : VShading
3941 //purpose  : Sharpen or roughten the quality of the shading
3942 //Draw arg : vshading ShapeName 0.1->0.00001  1 deg-> 30 deg
3943 //==============================================================================
3944 static int VShading(Draw_Interpretor& ,Standard_Integer argc, const char** argv)
3945 {
3946   Standard_Real    myDevCoef;
3947   Handle(AIS_InteractiveObject) TheAisIO;
3948
3949   // Verifications
3950   const Standard_Boolean HaveToSet = (strcasecmp(argv[0],"vsetshading") == 0);
3951
3952   if (TheAISContext()->HasOpenedContext())
3953     TheAISContext()->CloseLocalContext();
3954
3955   if (argc < 3) {
3956     myDevCoef  = 0.0008;
3957   } else {
3958     myDevCoef  =Draw::Atof(argv[2]);
3959   }
3960
3961   TCollection_AsciiString name=argv[1];
3962   if (GetMapOfAIS().IsBound2(name ))
3963     TheAisIO = Handle(AIS_InteractiveObject)::DownCast(GetMapOfAIS().Find2(name));
3964   if (TheAisIO.IsNull())
3965     TheAisIO=GetAISShapeFromName((const char *)name.ToCString());
3966
3967   if (HaveToSet)
3968     TheAISContext()->SetDeviationCoefficient(TheAisIO,myDevCoef,Standard_True);
3969   else
3970     TheAISContext()->SetDeviationCoefficient(TheAisIO,0.0008,Standard_True);
3971
3972   TheAISContext()->Redisplay(TheAisIO);
3973   return 0;
3974 }
3975 //==============================================================================
3976 //function : HaveMode
3977 //use      : VActivatedModes
3978 //==============================================================================
3979 #include <TColStd_ListIteratorOfListOfInteger.hxx>
3980
3981 Standard_Boolean  HaveMode(const Handle(AIS_InteractiveObject)& TheAisIO,const Standard_Integer mode  )
3982 {
3983   TColStd_ListOfInteger List;
3984   TheAISContext()->ActivatedModes (TheAisIO,List);
3985   TColStd_ListIteratorOfListOfInteger it;
3986   Standard_Boolean Found=Standard_False;
3987   for (it.Initialize(List); it.More()&&!Found; it.Next() ){
3988     if (it.Value()==mode ) Found=Standard_True;
3989   }
3990   return Found;
3991 }
3992
3993
3994
3995 //==============================================================================
3996 //function : VActivatedMode
3997 //author   : ege
3998 //purpose  : permet d'attribuer a chacune des shapes un mode d'activation
3999 //           (edges,vertex...)qui lui est propre et le mode de selection standard.
4000 //           La fonction s'applique aux shapes selectionnees(current ou selected dans le viewer)
4001 //             Dans le cas ou on veut psser la shape en argument, la fonction n'autorise
4002 //           qu'un nom et qu'un mode.
4003 //Draw arg : vsetam  [ShapeName] mode(0,1,2,3,4,5,6,7)
4004 //==============================================================================
4005 #include <AIS_ListIteratorOfListOfInteractive.hxx>
4006
4007 static int VActivatedMode (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
4008
4009 {
4010   Standard_Boolean ThereIsName = Standard_False ;
4011
4012   if(!a3DView().IsNull()){
4013
4014     const Standard_Boolean HaveToSet = (strcasecmp(argv[0],"vsetam") == 0);
4015     // verification des arguments
4016     if (HaveToSet) {
4017       if (argc<2||argc>3) { di<<" Syntaxe error"<<"\n";return 1;}
4018       ThereIsName = (argc == 3);
4019     }
4020     else {
4021       // vunsetam
4022       if (argc>1) {di<<" Syntaxe error"<<"\n";return 1;}
4023       else {
4024         di<<" R.A.Z de tous les modes de selecion"<<"\n";
4025         di<<" Fermeture du Context local"<<"\n";
4026         if (TheAISContext()->HasOpenedContext())
4027           TheAISContext()->CloseLocalContext();
4028       }
4029     }
4030
4031     // IL n'y a aps de nom de shape passe en argument
4032     if (HaveToSet && !ThereIsName){
4033       Standard_Integer aMode=Draw::Atoi(argv [1]);
4034
4035       const char *cmode="???";
4036       switch (aMode) {
4037       case 0: cmode = "Shape"; break;
4038       case 1: cmode = "Vertex"; break;
4039       case 2: cmode = "Edge"; break;
4040       case 3: cmode = "Wire"; break;
4041       case 4: cmode = "Face"; break;
4042       case 5: cmode = "Shell"; break;
4043       case 6: cmode = "Solid"; break;
4044       case 7: cmode = "Compound"; break;
4045       }
4046
4047       if( !TheAISContext()->HasOpenedContext() ) {
4048         // il n'y a pas de Context local d'ouvert
4049         // on en ouvre un et on charge toutes les shapes displayees
4050         // on load tous les objets displayees et on Activate les objets de la liste
4051         AIS_ListOfInteractive ListOfIO;
4052         // on sauve dans une AISListOfInteractive tous les objets currents
4053         if (TheAISContext()->NbSelected()>0 ){
4054           TheAISContext()->UnhilightSelected(Standard_False);
4055
4056           for (TheAISContext()->InitSelected(); TheAISContext()->MoreSelected(); TheAISContext()->NextSelected() ){
4057             ListOfIO.Append(TheAISContext()->SelectedInteractive() );
4058           }
4059         }
4060
4061         TheAISContext()->OpenLocalContext(Standard_False);
4062         ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName
4063           it (GetMapOfAIS());
4064         while(it.More()){
4065           Handle(AIS_InteractiveObject) aIO =
4066             Handle(AIS_InteractiveObject)::DownCast(it.Key1());
4067           if (!aIO.IsNull())
4068             TheAISContext()->Load(aIO,0,Standard_False);
4069           it.Next();
4070         }
4071         // traitement des objets qui etaient currents dans le Contexte global
4072         if (!ListOfIO.IsEmpty() ) {
4073           // il y avait des objets currents
4074           AIS_ListIteratorOfListOfInteractive iter;
4075           for (iter.Initialize(ListOfIO); iter.More() ; iter.Next() ) {
4076             Handle(AIS_InteractiveObject) aIO=iter.Value();
4077             TheAISContext()->Activate(aIO,aMode);
4078             di<<" Mode: "<<cmode<<" ON pour "<<GetMapOfAIS().Find1(aIO).ToCString()  <<"\n";
4079           }
4080         }
4081         else {
4082           // On applique le mode a tous les objets displayes
4083           ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName
4084             it2 (GetMapOfAIS());
4085           while(it2.More()){
4086             Handle(AIS_InteractiveObject) aIO =
4087               Handle(AIS_InteractiveObject)::DownCast(it2.Key1());
4088             if (!aIO.IsNull()) {
4089               di<<" Mode: "<<cmode<<" ON pour "<<it2.Key2().ToCString() <<"\n";
4090               TheAISContext()->Activate(aIO,aMode);
4091             }
4092             it2.Next();
4093           }
4094         }
4095
4096       }
4097
4098       else {
4099         // un Context local est deja ouvert
4100         // Traitement des objets du Context local
4101         if (TheAISContext()->NbSelected()>0 ){
4102           TheAISContext()->UnhilightSelected(Standard_False);
4103           // il y a des objets selected,on les parcourt
4104           for (TheAISContext()->InitSelected(); TheAISContext()->MoreSelected(); TheAISContext()->NextSelected() ){
4105             Handle(AIS_InteractiveObject) aIO=TheAISContext()->SelectedInteractive();
4106
4107
4108             if (HaveMode(aIO,aMode) ) {
4109               di<<" Mode: "<<cmode<<" OFF pour "<<GetMapOfAIS().Find1(aIO).ToCString() <<"\n";
4110               TheAISContext()->Deactivate(aIO,aMode);
4111             }
4112             else{
4113               di<<" Mode: "<<cmode<<" ON pour "<<GetMapOfAIS().Find1(aIO).ToCString() <<"\n";
4114               TheAISContext()->Activate(aIO,aMode);
4115             }
4116
4117           }
4118         }
4119         else{
4120           // il n'y a pas d'objets selected
4121           // tous les objets diplayes sont traites
4122           ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName
4123             it (GetMapOfAIS());
4124           while(it.More()){
4125             Handle(AIS_InteractiveObject) aIO =
4126               Handle(AIS_InteractiveObject)::DownCast(it.Key1());
4127             if (!aIO.IsNull()) {
4128               if (HaveMode(aIO,aMode) ) {
4129                 di<<" Mode: "<<cmode<<" OFF pour "
4130                   <<GetMapOfAIS().Find1(aIO).ToCString() <<"\n";
4131                 TheAISContext()->Deactivate(aIO,aMode);
4132               }
4133               else{
4134                 di<<" Mode: "<<cmode<<" ON pour"
4135                   <<GetMapOfAIS().Find1(aIO).ToCString() <<"\n";
4136                 TheAISContext()->Activate(aIO,aMode);
4137               }
4138             }
4139             it.Next();
4140           }
4141         }
4142       }
4143     }
4144     else if (HaveToSet && ThereIsName){
4145       Standard_Integer aMode=Draw::Atoi(argv [2]);
4146       Handle(AIS_InteractiveObject) aIO =
4147         Handle(AIS_InteractiveObject)::DownCast(GetMapOfAIS().Find2(argv[1]));
4148
4149       if (!aIO.IsNull()) {
4150         const char *cmode="???";
4151
4152         switch (aMode) {
4153         case 0: cmode = "Shape"; break;
4154         case 1: cmode = "Vertex"; break;
4155         case 2: cmode = "Edge"; break;
4156         case 3: cmode = "Wire"; break;
4157         case 4: cmode = "Face"; break;
4158         case 5: cmode = "Shell"; break;
4159         case 6: cmode = "Solid"; break;
4160         case 7: cmode = "Compound"; break;
4161         }
4162
4163         if( !TheAISContext()->HasOpenedContext() ) {
4164           TheAISContext()->OpenLocalContext(Standard_False);
4165           // On charge tous les objets de la map
4166           ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName it (GetMapOfAIS());
4167           while(it.More()){
4168             Handle(AIS_InteractiveObject) aShape=
4169               Handle(AIS_InteractiveObject)::DownCast(it.Key1());
4170             if (!aShape.IsNull())
4171               TheAISContext()->Load(aShape,0,Standard_False);
4172             it.Next();
4173           }
4174           TheAISContext()->Activate(aIO,aMode);
4175           di<<" Mode: "<<cmode<<" ON pour "<<argv[1]<<"\n";
4176         }
4177
4178         else {
4179           // un Context local est deja ouvert
4180           if (HaveMode(aIO,aMode) ) {
4181             di<<" Mode: "<<cmode<<" OFF pour "<<argv[1]<<"\n";
4182             TheAISContext()->Deactivate(aIO,aMode);
4183           }
4184           else{
4185             di<<" Mode: "<<cmode<<" ON pour "<<argv[1]<<"\n";
4186             TheAISContext()->Activate(aIO,aMode);
4187           }
4188         }
4189       }
4190     }
4191   }
4192   return 0;
4193 }
4194
4195 //! Auxiliary method to print Interactive Object information
4196 static void objInfo (const NCollection_Map<Handle(AIS_InteractiveObject)>& theDetected,
4197                      const Handle(Standard_Transient)&                     theObject,
4198                      Draw_Interpretor&                                     theDI)
4199 {
4200   const Handle(AIS_InteractiveObject) anObj = Handle(AIS_InteractiveObject)::DownCast (theObject);
4201   if (anObj.IsNull())
4202   {
4203     theDI << theObject->DynamicType()->Name() << " is not AIS presentation\n";
4204     return;
4205   }
4206
4207   theDI << (TheAISContext()->IsDisplayed  (anObj) ? "Displayed"  : "Hidden   ")
4208         << (TheAISContext()->IsSelected   (anObj) ? " Selected" : "         ")
4209         << (theDetected.Contains (anObj)          ? " Detected" : "         ")
4210         << " Type: ";
4211   if (anObj->Type() == AIS_KOI_Datum)
4212   {
4213     // AIS_Datum
4214     if      (anObj->Signature() == 3) { theDI << " AIS_Trihedron"; }
4215     else if (anObj->Signature() == 2) { theDI << " AIS_Axis"; }
4216     else if (anObj->Signature() == 6) { theDI << " AIS_Circle"; }
4217     else if (anObj->Signature() == 5) { theDI << " AIS_Line"; }
4218     else if (anObj->Signature() == 7) { theDI << " AIS_Plane"; }
4219     else if (anObj->Signature() == 1) { theDI << " AIS_Point"; }
4220     else if (anObj->Signature() == 4) { theDI << " AIS_PlaneTrihedron"; }
4221   }
4222   // AIS_Shape
4223   else if (anObj->Type()      == AIS_KOI_Shape
4224         && anObj->Signature() == 0)
4225   {
4226     theDI << " AIS_Shape";
4227   }
4228   else if (anObj->Type() == AIS_KOI_Relation)
4229   {
4230     // AIS_Dimention and AIS_Relation
4231     Handle(AIS_Relation) aRelation = Handle(AIS_Relation)::DownCast (anObj);
4232     switch (aRelation->KindOfDimension())
4233     {
4234       case AIS_KOD_PLANEANGLE:     theDI << " AIS_AngleDimension"; break;
4235       case AIS_KOD_LENGTH:         theDI << " AIS_Chamf2/3dDimension/AIS_LengthDimension"; break;
4236       case AIS_KOD_DIAMETER:       theDI << " AIS_DiameterDimension"; break;
4237       case AIS_KOD_ELLIPSERADIUS:  theDI << " AIS_EllipseRadiusDimension"; break;
4238       //case AIS_KOD_FILLETRADIUS:   theDI << " AIS_FilletRadiusDimension "; break;
4239       case AIS_KOD_OFFSET:         theDI << " AIS_OffsetDimension"; break;
4240       case AIS_KOD_RADIUS:         theDI << " AIS_RadiusDimension"; break;
4241       default:                     theDI << " UNKNOWN dimension"; break;
4242     }
4243   }
4244   else
4245   {
4246     theDI << " UserPrs";
4247   }
4248   theDI << " (" << theObject->DynamicType()->Name() << ")";
4249 }
4250
4251 //! Print information about locally selected sub-shapes
4252 static void localCtxInfo (Draw_Interpretor& theDI)
4253 {
4254   Handle(AIS_InteractiveContext) aCtx = TheAISContext();
4255   if (!aCtx->HasOpenedContext())
4256   {
4257     return;
4258   }
4259
4260   TCollection_AsciiString aPrevName;
4261   Handle(AIS_LocalContext) aCtxLoc = aCtx->LocalContext();
4262   for (aCtxLoc->InitSelected(); aCtxLoc->MoreSelected(); aCtxLoc->NextSelected())
4263   {
4264     const TopoDS_Shape      aSubShape = aCtxLoc->SelectedShape();
4265     const Handle(AIS_Shape) aShapeIO  = Handle(AIS_Shape)::DownCast (aCtxLoc->SelectedInteractive());
4266     if (aSubShape.IsNull()
4267       || aShapeIO.IsNull()
4268       || !GetMapOfAIS().IsBound1 (aShapeIO))
4269     {
4270       continue;
4271     }
4272
4273     const TCollection_AsciiString aParentName = GetMapOfAIS().Find1 (aShapeIO);
4274     TopTools_MapOfShape aFilter;
4275     Standard_Integer    aNumber = 0;
4276     const TopoDS_Shape  aShape  = aShapeIO->Shape();
4277     for (TopExp_Explorer anIter (aShape, aSubShape.ShapeType());
4278          anIter.More(); anIter.Next())
4279     {
4280       if (!aFilter.Add (anIter.Current()))
4281       {
4282         continue; // filter duplicates
4283       }
4284
4285       ++aNumber;
4286       if (!anIter.Current().IsSame (aSubShape))
4287       {
4288         continue;
4289       }
4290
4291       Standard_CString aShapeName = NULL;
4292       switch (aSubShape.ShapeType())
4293       {
4294         case TopAbs_COMPOUND:  aShapeName = " Compound"; break;
4295         case TopAbs_COMPSOLID: aShapeName = "CompSolid"; break;
4296         case TopAbs_SOLID:     aShapeName = "    Solid"; break;
4297         case TopAbs_SHELL:     aShapeName = "    Shell"; break;
4298         case TopAbs_FACE:      aShapeName = "     Face"; break;
4299         case TopAbs_WIRE:      aShapeName = "     Wire"; break;
4300         case TopAbs_EDGE:      aShapeName = "     Edge"; break;
4301         case TopAbs_VERTEX:    aShapeName = "   Vertex"; break;
4302         default:
4303         case TopAbs_SHAPE:     aShapeName = "    Shape"; break;
4304       }
4305
4306       if (aParentName != aPrevName)
4307       {
4308         theDI << "Locally selected sub-shapes within " << aParentName << ":\n";
4309         aPrevName = aParentName;
4310       }
4311       theDI << "  " << aShapeName << " #" << aNumber << "\n";
4312       break;
4313     }
4314   }
4315 }
4316
4317 //==============================================================================
4318 //function : VState
4319 //purpose  :
4320 //==============================================================================