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