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