0022922: Clean up warnings on uninitialized / unused variables
[occt.git] / src / Viewer2dTest / Viewer2dTest_DisplayCommands.cxx
1 // File:      Viewer2dTest_DisplayCommands.cxx
2 // Created:   22.01.02 16:21:20
3 // Author:    Julia DOROVSKIKH
4 // Copyright: Open Cascade 2001
5
6 #include <Viewer2dTest.hxx>
7
8 #include <Viewer2dTest_EventManager.hxx>
9 #include <Viewer2dTest_DoubleMapOfInteractiveAndName.hxx>
10 #include <Viewer2dTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName.hxx>
11
12 #include <Draw_Interpretor.hxx>
13
14 #include <HLRAlgo_Projector.hxx>
15
16 #include <V2d_Viewer.hxx>
17 #include <V2d_View.hxx>
18
19 #include <Prs2d_AspectRoot.hxx>
20 #include <Prs2d_AspectLine.hxx>
21
22 #include <gp_Ax3.hxx>
23
24 #include <TopoDS.hxx>
25 #include <TopoDS_Shape.hxx>
26 #include <TopoDS_Vertex.hxx>
27
28 #include <BRep_Tool.hxx>
29
30 #include <TCollection_AsciiString.hxx>
31
32 #include <gp_Ax2.hxx>
33
34 #include <AIS2D_ProjShape.hxx>
35 #include <AIS2D_InteractiveContext.hxx>
36
37 #include <Quantity_NameOfColor.hxx>
38 #include <Quantity_Color.hxx>
39
40 #include <Graphic2d_Line.hxx>
41 #include <Graphic2d_Marker.hxx>
42 #include <Graphic2d_View.hxx>
43
44 #include <Graphic3d_NameOfMaterial.hxx>
45 #include <Prs2d_Arrow.hxx>
46 #include <GCE2d_MakeSegment.hxx>
47 #include <GGraphic2d_Curve.hxx>
48 #include <Graphic2d_Text.hxx>
49 #include <AIS2D_ListOfIO.hxx>
50 #include <Prs2d_ToleranceFrame.hxx>
51 #include <Prs2d_Length.hxx>
52 #include <gp_Ax22d.hxx>
53 #include <gp_Circ2d.hxx>
54 #include <Graphic2d_Circle.hxx>
55 #include <Prs2d_Diameter.hxx>
56 #include <Prs2d_Point.hxx>
57 #include <Prs2d_Axis.hxx>
58 #include <Geom2d_Line.hxx>
59 #include <Graphic2d_Segment.hxx>
60 #include <GCE2d_MakeArcOfCircle.hxx>
61 #include <Graphic2d_Polyline.hxx>
62 #include <Graphic2d_Array1OfVertex.hxx>
63 #include <TColgp_Array1OfPnt2d.hxx>
64 #include <Geom2d_BezierCurve.hxx>
65 #include <Geom2d_Ellipse.hxx>
66 #include <DrawTrSurf.hxx>
67 #include <GCE2d_MakeSegment.hxx>
68 #include <GGraphic2d_SetOfCurves.hxx>
69 #include <Prs2d_AspectText.hxx>
70 #include <gp_Lin2d.hxx>
71 #include <Prs2d_Angle.hxx>
72 #include <Prs2d_Radius.hxx>
73 #include <Prs2d_Circularity.hxx>
74 #include <Prs2d_Parallelism.hxx>
75
76 #define OCC190 // jfa 04/03/2002 // for vertices load
77 #define OCC154 // jfa 06/03/2002 // for correct erasing
78
79 #define DEFAULT_COLOR    Quantity_NOC_GOLDENROD
80 #define DEFAULT_MATERIAL Graphic3d_NOM_BRASS
81
82 Viewer2dTest_DoubleMapOfInteractiveAndName& GetMapOfAIS2D();
83 Handle(AIS2D_InteractiveContext)& TheAIS2DContext();
84 TopoDS_Shape GetShapeFromName2d (const char* name);
85
86 //==============================================================================
87 //function : GetAIS2DShapeFromName
88 //purpose  : Compute an AIS2D_ProjShape from a draw variable or a file name
89 //==============================================================================
90 Handle(AIS2D_InteractiveObject) GetAIS2DShapeFromName
91        (const char* name, gp_Ax2 anAx2 = gp::XOY())
92 {
93   Handle(AIS2D_InteractiveObject) retsh;
94
95   if (GetMapOfAIS2D().IsBound2(name))
96   {
97     Handle(AIS2D_InteractiveObject) IO = GetMapOfAIS2D().Find2(name);
98 //    if(IO->Type() == AIS2D_KOI_Shape)
99 //      if (IO->Signature() == 0){
100 //      retsh = *((Handle(AIS2D_ProjShape)*)&IO);
101 //      }
102 //    else
103     cout << "an Object which is not an AIS2D_ProjShape already has this name!!!" << endl;
104     return retsh;
105   }
106
107   TopoDS_Shape S = GetShapeFromName2d(name);
108   if (!S.IsNull())
109   {
110 #ifdef OCC190
111     if (S.ShapeType() == TopAbs_VERTEX)
112     {
113       TopoDS_Vertex aVert = TopoDS::Vertex(S);
114       gp_Pnt aPnt = BRep_Tool::Pnt(aVert);
115
116       gp_Trsf aTrsf;
117       gp_Ax3 aToSystem (anAx2);
118       aTrsf.SetTransformation(aToSystem);
119       aPnt.Transform(aTrsf);
120
121       Handle(V2d_View) V = Viewer2dTest::CurrentView();
122       retsh = new AIS2D_InteractiveObject();
123       retsh->SetView(V->View());
124
125 #define VERTEXMARKER 2
126 #define DEFAULTMARKERSIZE 3.0
127
128       Handle(Graphic2d_Marker) vertex = new Graphic2d_Marker
129         (retsh, VERTEXMARKER, aPnt.X(), aPnt.Y(), DEFAULTMARKERSIZE, DEFAULTMARKERSIZE, 0.0);
130     }
131     else
132 #endif
133     {
134       HLRAlgo_Projector aProjector (anAx2);
135       Handle(AIS2D_ProjShape) retprsh = new AIS2D_ProjShape(aProjector);
136       retprsh->Add(S);
137       retsh = retprsh;
138     }
139   }
140   return retsh; 
141 }
142
143 //=======================================================================
144 //function : GetColorFromName2d
145 //purpose  : get the Quantity_NameOfColor from a string
146 //=======================================================================
147 static Quantity_NameOfColor GetColorFromName2d (const char *name) 
148
149   Quantity_NameOfColor ret = DEFAULT_COLOR;
150   
151   Standard_Boolean Found = Standard_False;
152   Standard_CString colstring;
153   for (Standard_Integer i = 0; i <= 514 && !Found; i++)
154   {
155     colstring = Quantity_Color::StringName(Quantity_NameOfColor(i));
156     if (!strcasecmp(name,colstring))
157     {
158       ret = (Quantity_NameOfColor)i;
159       Found = Standard_True;
160     }
161   }
162
163   return ret;
164 }
165 #if 0
166 //=======================================================================
167 //function : GetMaterialFromName2d
168 //purpose  : get the Graphic3d_NameOfMaterial from a string
169 //=======================================================================
170 static Graphic3d_NameOfMaterial GetMaterialFromName2d (const char *name) 
171
172   Graphic3d_NameOfMaterial mat = DEFAULT_MATERIAL;
173   
174   if      ( !strcasecmp(name,"BRASS" ) )         mat = Graphic3d_NOM_BRASS;
175   else if ( !strcasecmp(name,"BRONZE" ) )        mat = Graphic3d_NOM_BRONZE;
176   else if ( !strcasecmp(name,"COPPER" ) )        mat = Graphic3d_NOM_COPPER;
177   else if ( !strcasecmp(name,"GOLD" ) )          mat = Graphic3d_NOM_GOLD;
178   else if ( !strcasecmp(name,"PEWTER" ) )        mat = Graphic3d_NOM_PEWTER;
179   else if ( !strcasecmp(name,"SILVER" ) )        mat = Graphic3d_NOM_SILVER;
180   else if ( !strcasecmp(name,"STEEL" ) )         mat = Graphic3d_NOM_STEEL;
181   else if ( !strcasecmp(name,"METALIZED" ) )     mat = Graphic3d_NOM_METALIZED;
182   else if ( !strcasecmp(name,"STONE" ) )         mat = Graphic3d_NOM_STONE;
183   else if ( !strcasecmp(name,"CHROME" ) )        mat = Graphic3d_NOM_CHROME;
184   else if ( !strcasecmp(name,"ALUMINIUM" ) )     mat = Graphic3d_NOM_ALUMINIUM;
185   else if ( !strcasecmp(name,"STONE" ) )         mat = Graphic3d_NOM_STONE;
186   else if ( !strcasecmp(name,"NEON_PHC" ) )      mat = Graphic3d_NOM_NEON_PHC;
187   else if ( !strcasecmp(name,"NEON_GNC" ) )      mat = Graphic3d_NOM_NEON_GNC;
188   else if ( !strcasecmp(name,"PLASTER" ) )       mat = Graphic3d_NOM_PLASTER;
189   else if ( !strcasecmp(name,"SHINY_PLASTIC" ) ) mat = Graphic3d_NOM_SHINY_PLASTIC;
190   else if ( !strcasecmp(name,"SATIN" ) )         mat = Graphic3d_NOM_SATIN;
191   else if ( !strcasecmp(name,"PLASTIC" ) )       mat = Graphic3d_NOM_PLASTIC;
192   else if ( !strcasecmp(name,"OBSIDIAN" ) )      mat = Graphic3d_NOM_OBSIDIAN;
193   else if ( !strcasecmp(name,"JADE" ) )          mat = Graphic3d_NOM_JADE;
194
195 #ifdef DEB
196   cout << " materiau" << name <<" "<<Standard_Integer(mat) << endl;
197 #endif
198   return mat;
199 }
200 #endif
201
202 //==============================================================================
203 //function : Select2d
204 //purpose  : pick / select an object from the last MoveTo() on a
205 //            ButtonPress event
206 //==============================================================================
207 Handle(AIS2D_InteractiveObject) Select2d (Standard_Integer /*argc*/,
208                                           const char** /*argv*/,
209                                           Standard_Boolean shift,
210                                           Standard_Boolean /*pick*/)
211 {
212   Handle(AIS2D_InteractiveObject) ret;
213   Handle (Viewer2dTest_EventManager) EM = Viewer2dTest::CurrentEventManager();
214   if (shift) EM->ShiftSelect();
215   else       EM->Select();
216
217   const Handle(AIS2D_InteractiveContext) aContext = EM->Context();
218   
219   if (!aContext->HasOpenedContext())
220   {
221 //    aContext->InitCurrent();
222 /*    while ( aContext->MoreCurrent() ) {
223       Handle(AIS2D_InteractiveObject) aisPickedShape = 
224         Handle(AIS2D_InteractiveObject)::DownCast(aContext->Current()); 
225       
226       const char *name = (GetMapOfAIS2D().IsBound1(aisPickedShape))? 
227         GetMapOfAIS2D().Find1(aisPickedShape).ToCString() : 
228           "????";
229       Handle(AIS2D_ProjShape) TheRealSh = Handle(AIS2D_ProjShape)::DownCast(aisPickedShape);
230       if(!TheRealSh.IsNull()){
231         cout << "Current is " << name 
232           << " (" << GetTypeNameFromShape2d(TheRealSh->Shape())
233             << ")" << endl;
234       }
235       ret = aisPickedShape;
236       if(!TheRealSh.IsNull()){
237         if ( pick && argc > 4 ) {
238           DBRep::Set(argv[4], TheRealSh->Shape());
239         }
240       }
241       aContext->NextCurrent();
242     }*/
243   }
244   else
245   {
246     // A LocalContext is opened, the use xxxxSelected() 
247     // to select an object and its SubShape
248 /*    aContext->InitSelected();
249     while ( aContext->MoreSelected() ) {
250       if ( !aContext->HasSelectedShape() ) {
251       }
252       else {      
253         TopoDS_Shape PickedShape = aContext->SelectedShape();
254         if ( pick && argc > 5 ) {
255           DBRep::Set(argv[5], PickedShape);
256         }
257       }
258       
259       if ( aContext->Interactive().IsNull() ) {
260         cout << "??? (No InteractiveObject selected)" << endl;
261       }
262       else {
263         Handle(AIS2D_InteractiveObject) aisPicked = 
264           Handle(AIS2D_InteractiveObject)::DownCast(aContext->Interactive());
265         ret = aisPicked;
266         Handle(AIS2D_ProjShape) aisPickedShape = Handle(AIS2D_ProjShape)::DownCast(aisPicked);
267         
268         // Get back its name
269         const char *name = ( GetMapOfAIS2D().IsBound1(aisPicked) )? 
270           GetMapOfAIS2D().Find1(aisPicked).ToCString() : 
271             "????";
272         
273         if(!aisPickedShape.IsNull()){
274           if ( pick && argc > 4 ) {
275             // Create a draw variable to store the wohole shape 
276             // for vpick command
277             DBRep::Set(argv[4], aisPickedShape->Shape());
278           }
279           
280           cout << name << " (" << GetTypeNameFromShape2d(aisPickedShape->Shape()) 
281             << ")" << endl  ;
282         }
283       }
284       // Goto the next selected object
285       aContext->NextSelected();
286     }*/
287   }
288   return ret;
289 }
290
291 //==============================================================================
292 //function : Displays,Erase...
293 //purpose  : 
294 //Draw arg : 
295 //==============================================================================
296 static int VwrTst_DispErase2d (const Handle(AIS2D_InteractiveObject)& IO,
297                                const Standard_Integer Mode,
298                                const Standard_Integer TypeOfOperation,
299                                const Standard_Boolean Upd)
300 {
301   Handle(AIS2D_InteractiveContext) Ctx = Viewer2dTest::GetAIS2DContext();
302   
303   switch (TypeOfOperation)
304   {
305   case 1:
306     Ctx->Display(IO,Mode,Upd);
307     break;
308   case 2:
309     Ctx->Erase(IO,Mode,Upd);
310     break;
311   case 3:
312 //    if(IO.IsNull())
313 //      Ctx->SetDisplayMode((AIS2D_DisplayMode)Mode,Upd);
314 //    else
315 //      Ctx->SetDisplayMode(IO,Mode,Upd);
316     break;
317   case 4:
318 //    if(IO.IsNull())
319 //      Ctx->SetDisplayMode(0,Upd);
320 //    else
321 //      Ctx->UnsetDisplayMode(IO,Upd);
322     break;
323   }
324
325   return 0;
326 }
327
328 #if 0
329 //=======================================================================
330 //function :V2dDispMode
331 //purpose  : 
332 //=======================================================================
333 static int V2dDispMode (Draw_Interpretor& , Standard_Integer argc, const char** argv)
334 {
335   TCollection_AsciiString name;
336   if (argc > 3) return 1;
337
338   // display others presentations
339   Standard_Integer TypeOfOperation = (strcasecmp(argv[0],"v2ddispmode") == 0)? 1:
340     (strcasecmp(argv[0],"v2derasemode") == 0) ? 2 :
341       (strcasecmp(argv[0],"v2dsetdispmode") == 0) ? 3 :
342         (strcasecmp(argv[0],"v2dunsetdispmode") == 0) ? 4 : -1;
343   
344   Handle(AIS2D_InteractiveContext) Ctx = Viewer2dTest::GetAIS2DContext();
345   
346   //unset displaymode.. comportement particulier...
347   if (TypeOfOperation == 4)
348   {
349     if (argc == 1)
350     {
351 /*      if(Ctx->NbCurrents()==0 ||
352          Ctx->NbSelected()==0){
353         Handle(AIS2D_InteractiveObject) IO;
354         VwrTst_DispErase2d(IO,-1,4,Standard_False);
355       }
356       else if(!Ctx->HasOpenedContext()){
357         for(Ctx->InitCurrent();Ctx->MoreCurrent();Ctx->NextCurrent())
358           VwrTst_DispErase2d(Ctx->Current(),-1,4,Standard_False);
359       }
360       else{
361         for(Ctx->InitSelected();Ctx->MoreSelected();Ctx->NextSelected())
362           VwrTst_DispErase2d(Ctx->Interactive(),-1,4,Standard_False);}*/
363       Ctx->UpdateCurrentViewer();
364     }
365     else
366     {
367       Handle(AIS2D_InteractiveObject) IO;
368       name = argv[1];
369       if (GetMapOfAIS2D().IsBound2(name))
370       {
371         IO = GetMapOfAIS2D().Find2(name);
372         VwrTst_DispErase2d(IO,-1,4,Standard_True);
373       }
374     }
375   }
376   else if (argc == 2)
377   {
378 //    Standard_Integer Dmode = atoi(argv[1]);
379 //    if(Ctx->NbCurrents()==0 && TypeOfOperation==3){
380 //      Handle(AIS2D_InteractiveObject) IO;
381 //      VwrTst_DispErase2d(IO,Dmode,TypeOfOperation,Standard_True);
382 //    }
383     if (!Ctx->HasOpenedContext())
384     {
385       // set/unset display mode sur le Contexte...
386 //      for(Ctx->InitCurrent();Ctx->MoreCurrent();Ctx->NextCurrent()){
387 //      VwrTst_DispErase2d(Ctx->Current(),Dmode,TypeOfOperation,Standard_False);
388 //      }
389       Ctx->UpdateCurrentViewer();
390     }
391     else
392     {
393 //      for(Ctx->InitSelected();Ctx->MoreSelected();Ctx->NextSelected())
394 //      Ctx->Display(Ctx->Interactive(),Dmode);
395     }
396   }
397   else
398   {
399     Handle(AIS2D_InteractiveObject) IO;
400     name = argv[1];
401     if (GetMapOfAIS2D().IsBound2(name))
402       IO = GetMapOfAIS2D().Find2(name);
403     VwrTst_DispErase2d(IO,atoi(argv[2]),TypeOfOperation,Standard_True);
404   }
405
406   return 0;
407 }
408 #endif
409
410 //==============================================================================
411 //function : V2dSetBGColor
412 //purpose  : v2dsetbgcolor colorname : change background color
413 //==============================================================================
414 static int V2dSetBGColor (Draw_Interpretor& , Standard_Integer argc, const char** argv)
415 {
416   if (argc != 2)
417   {
418     cout << "Usage : v2dsetbgcolor colorname" << endl;
419     return 1;
420   }
421   Handle(V2d_View) V = Viewer2dTest::CurrentView(); 
422   if (V.IsNull()) return 1;
423
424   V->SetBackground(GetColorFromName2d(argv[1]));
425   V->Viewer()->Update();
426   return 0;
427 }
428
429 //==============================================================================
430 //function : V2dColor
431 //purpose  : change the color of a selected or named or displayed shape 
432 //Draw arg : v2dsetcolor [name] color 
433 //==============================================================================
434 static int V2dSetUnsetColor (Handle(AIS2D_InteractiveObject) theShape,
435                              Standard_Boolean HaveToSet,
436                              Quantity_NameOfColor theColor = Quantity_NOC_WHITE)
437 {
438   theShape->SetContext(TheAIS2DContext());
439
440   Handle(Graphic2d_Primitive) aPrim;
441   Handle(Prs2d_AspectRoot)    anAspect;
442   Standard_Integer i = 1, n = theShape->Length();
443   for (; i <= n; i++)
444   {
445     aPrim = theShape->Primitive(i);
446     if (theShape->HasAspect(aPrim))
447     {
448       anAspect = theShape->GetAspect(aPrim);
449       if (anAspect->GetAspectName() == Prs2d_AN_LINE) break;
450       else anAspect = NULL;
451     }
452   }
453
454   if (HaveToSet)
455   {
456     if (anAspect.IsNull())
457     {
458       theShape->SetAspect
459         (new Prs2d_AspectLine(theColor, Aspect_TOL_SOLID, Aspect_WOL_THIN,
460                               theColor, Graphic2d_TOPF_FILLED));
461     }
462     else
463     {
464       Handle(Prs2d_AspectLine) anAspectLine = Handle(Prs2d_AspectLine)::DownCast(anAspect);
465       anAspectLine->SetTypeOfFill(Graphic2d_TOPF_FILLED);
466       anAspectLine->SetColor(theColor);
467       anAspectLine->SetInterColor(theColor);
468       theShape->SetAspect(anAspect);
469     }
470   }
471   else // unset color
472   {
473     Handle(Prs2d_AspectLine) anAspectLine;
474     if ( !anAspect.IsNull() )
475       anAspectLine = Handle(Prs2d_AspectLine)::DownCast(anAspect);
476     else
477       anAspectLine = new Prs2d_AspectLine();
478
479     anAspectLine->SetTypeOfFill(Graphic2d_TOPF_EMPTY);
480     if (theShape->IsKind(STANDARD_TYPE(AIS2D_ProjShape)))
481       {
482         anAspectLine->SetColor(Quantity_NOC_YELLOW);
483         anAspectLine->SetInterColor(Quantity_NOC_YELLOW);
484       }
485     else
486       {
487         anAspectLine->SetColor(Quantity_NOC_WHITE);
488         anAspectLine->SetInterColor(Quantity_NOC_WHITE);
489       }
490     theShape->SetAspect( anAspectLine );
491   }
492
493   return 0;
494 }
495
496 static int V2dColor (Draw_Interpretor& , Standard_Integer argc, const char** argv)
497 {
498   Standard_Boolean ThereIsArgument = Standard_False;
499   Standard_Boolean HaveToSet = Standard_False;
500
501   if (strcasecmp(argv[0],"v2dsetcolor") == 0) HaveToSet = Standard_True;
502
503   Quantity_NameOfColor aColor = Quantity_NOC_BLACK;
504   if (HaveToSet)
505   {
506     if (argc < 2 || argc > 3)
507     {
508       cout << "Usage: v2dsetcolor [name] color" << endl;
509       return 1;
510     }
511     if (argc == 3)
512     {
513       ThereIsArgument = Standard_True;
514       aColor = GetColorFromName2d(argv[2]);
515     }
516     else
517     {
518       aColor = GetColorFromName2d(argv[1]);
519     }
520   }
521   else
522   {
523     if (argc > 2)
524     {
525       cout << "Usage: v2dunsetcolor [name]" << endl;
526       return 1;
527     }
528     if (argc == 2) ThereIsArgument = Standard_True;
529   }
530   
531   if (Viewer2dTest::CurrentView().IsNull()) return -1;
532   TheAIS2DContext()->CloseLocalContext();
533
534   if (ThereIsArgument)
535   {
536     TCollection_AsciiString name = argv[1];
537
538     if (GetMapOfAIS2D().IsBound2(name))
539     {
540       Handle(AIS2D_InteractiveObject) aShape = GetMapOfAIS2D().Find2(name);
541       V2dSetUnsetColor(aShape, HaveToSet, aColor);
542     }
543   }
544   else
545   {
546     Standard_Boolean hasCurrent = Standard_False;
547     Viewer2dTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName it (GetMapOfAIS2D());
548     for (; it.More() && !hasCurrent; it.Next())
549     {
550       if (TheAIS2DContext()->IsCurrent(it.Key1())) hasCurrent = Standard_True;
551     }
552     for (it.Reset(); it.More(); it.Next())
553     {
554       Handle(AIS2D_InteractiveObject) aShape = it.Key1();
555       if ((hasCurrent && TheAIS2DContext()->IsCurrent(aShape)) || !hasCurrent)
556       {
557         V2dSetUnsetColor(aShape, HaveToSet, aColor);
558       }
559     }
560 //    TheAIS2DContext()->UpdateCurrentViewer();
561   }
562   return 0;
563 }
564
565 #if 0
566 //==============================================================================
567 //function : V2dTransparency
568 //purpose  : change the transparency of a selected or named or displayed shape 
569 //Draw arg : v2dsettransp [name] TransparencyCoeficient 
570 //==============================================================================
571 static int V2dTransparency (Draw_Interpretor& , Standard_Integer argc, const char** argv)
572
573   Standard_Boolean ThereIsArgument;
574   Standard_Boolean HaveToSet;
575
576   if (strcasecmp(argv[0], "v2dsettransp") == 0)
577     HaveToSet = Standard_True;
578   else 
579     HaveToSet = Standard_False;
580   
581   if (HaveToSet)
582   {
583     if (argc < 2 || argc > 3)
584     {
585       cout << "Usage: v2dsettransp [name] color" << endl;
586       return 1;
587     }
588     if (argc == 2) ThereIsArgument = Standard_False;
589     else ThereIsArgument = Standard_True;
590   }
591   else
592   {
593     if (argc > 2)
594     {
595       cout << "Usage: v2dunsettransp [name]" << endl;
596       return 1;
597     }
598     if (argc == 2) ThereIsArgument = Standard_True;
599     else ThereIsArgument = Standard_False;
600   }
601   
602   if (Viewer2dTest::CurrentView().IsNull()) return -1;
603   TheAIS2DContext()->CloseLocalContext();
604
605   if (ThereIsArgument)
606   {
607     TCollection_AsciiString name = argv[1];
608     if (GetMapOfAIS2D().IsBound2(name))
609     {
610       Handle(AIS2D_InteractiveObject) ashape = GetMapOfAIS2D().Find2(name);
611 //      if(HaveToSet)
612 //      TheAIS2DContext()->SetTransparency(ashape,atof(argv[2]) );
613 //      else 
614 //      TheAIS2DContext()->UnsetTransparency(ashape);
615     }
616   }
617   else
618   {
619 //    if (TheAIS2DContext()->NbCurrents() > 0)
620     {
621 /*      for (TheAIS2DContext()->InitCurrent(); TheAIS2DContext()->MoreCurrent();
622            TheAIS2DContext()->NextCurrent())
623       {
624         Handle(AIS2D_InteractiveObject) ashape = TheAIS2DContext()->Current();
625         if (HaveToSet)
626         {
627           TheAIS2DContext()->SetTransparency(ashape, atof(argv[1]), Standard_False);
628         }
629         else 
630           TheAIS2DContext()->UnsetTransparency(ashape, Standard_False);
631       }*/
632
633       TheAIS2DContext()->UpdateCurrentViewer();
634     }
635 //    else // shape not defined (neither current, nor named)
636     {
637       Viewer2dTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName it (GetMapOfAIS2D());
638       while (it.More())
639       {
640         Handle(AIS2D_InteractiveObject) ashape = it.Key1();
641 //      if(HaveToSet)
642 //        TheAIS2DContext()->SetTransparency(ashape,atof(argv[1]),Standard_False);
643 //      else 
644 //        TheAIS2DContext()->UnsetTransparency(ashape,Standard_False);
645         it.Next();
646       }
647       TheAIS2DContext()->UpdateCurrentViewer();
648     }
649   }
650   return 0;
651 }
652 #endif
653
654 #if 0
655 //==============================================================================
656 //function : V2dMaterial
657 //purpose  : change the Material of a selected or named or displayed shape 
658 //Draw arg : v2dmaterial  [Name] Material 
659 //==============================================================================
660 static int V2dMaterial (Draw_Interpretor& , Standard_Integer argc, const char** argv)
661
662   Standard_Boolean ThereIsName;
663   Standard_Boolean HaveToSet;
664
665   if (strcasecmp(argv[0], "v2dsetmaterial") == 0) HaveToSet = Standard_True;
666   else HaveToSet = Standard_False;
667
668   if (HaveToSet)
669   {
670     if (argc < 2 || argc > 3)
671     {
672       cout << "Usage: v2dsetmaterial [name] material" << endl;
673       return 1;
674     }
675     if (argc == 2) ThereIsName = Standard_False;
676     else ThereIsName = Standard_True;
677   }
678   else
679   {
680     if (argc > 2)
681     {
682       cout << "Usage: v2dunsetmaterial [name]" << endl;
683       return 1;
684     }
685     if (argc == 2) ThereIsName = Standard_True;
686     else ThereIsName = Standard_False;
687   }
688
689   if (Viewer2dTest::CurrentView().IsNull()) return -1;
690   TheAIS2DContext()->CloseLocalContext();
691
692   if (ThereIsName)
693   {
694     TCollection_AsciiString name = argv[1];
695     if (GetMapOfAIS2D().IsBound2(name))
696     {
697       Handle(AIS2D_InteractiveObject) ashape = GetMapOfAIS2D().Find2(name);
698       if (HaveToSet)
699       {
700 //      TheAIS2DContext()->SetMaterial (ashape,GetMaterialFromName2d (argv[2]) );
701       }
702       else
703       {
704 //      TheAIS2DContext()->UnsetMaterial(ashape);
705       }
706     }
707   }
708   else
709   {
710 //    if (TheAIS2DContext()->NbCurrents() > 0)
711     {
712 /*      for (TheAIS2DContext()->InitCurrent(); TheAIS2DContext()->MoreCurrent();
713            TheAIS2DContext()->NextCurrent())
714       {
715         Handle(AIS2D_InteractiveObject) ashape = TheAIS2DContext()->Current();
716         if (HaveToSet)
717         {
718           TheAIS2DContext()->SetMaterial(ashape, GetMaterialFromName2d(argv[1]), Standard_False);
719         }
720         else
721           TheAIS2DContext()->UnsetMaterial(ashape, Standard_False);
722       }*/
723       TheAIS2DContext()->UpdateCurrentViewer();
724     }
725 //    else // shape not defined (neither current, nor named)
726     {
727       Viewer2dTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName it (GetMapOfAIS2D());
728       while (it.More())
729       {
730         Handle(AIS2D_InteractiveObject) ashape = it.Key1();
731         
732 //      if (HaveToSet)
733 //        TheAIS2DContext()->SetMaterial(ashape,GetMaterialFromName2d(argv[1]),Standard_False);
734 //      else TheAIS2DContext()->UnsetMaterial(ashape,Standard_False);
735         it.Next();
736       }
737       TheAIS2DContext()->UpdateCurrentViewer();
738     }
739   }
740   return 0;
741 }
742 #endif
743
744 //==============================================================================
745 //function : V2dWidth
746 //purpose  : change the width of the edges of a selected or named or displayed shape 
747 //Draw arg : v2dsetwidth [Name] WidthEnum(THIN MEDIUM THICK VERYTHICK)
748 //==============================================================================
749 static int V2dSetUnsetWidth (Handle(AIS2D_InteractiveObject) theShape,
750                              Standard_Boolean HaveToSet,
751                              Aspect_WidthOfLine theWOL = Aspect_WOL_THIN)
752 {
753   theShape->SetContext(TheAIS2DContext());
754
755   Handle(Graphic2d_Primitive) aPrim;
756   Handle(Prs2d_AspectRoot)    anAspect;
757   Standard_Integer i = 1, n = theShape->Length();
758   for (; i <= n; i++)
759   {
760     aPrim = theShape->Primitive(i);
761     if (theShape->HasAspect(aPrim))
762     {
763       anAspect = theShape->GetAspect(aPrim);
764       if (anAspect->GetAspectName() == Prs2d_AN_LINE) break;
765       else anAspect = NULL;
766     }
767   }
768
769   if (HaveToSet)
770   {
771     if (anAspect.IsNull())
772     {
773       Quantity_NameOfColor aColor;
774       if (theShape->IsKind(STANDARD_TYPE(AIS2D_ProjShape)))
775       {
776         aColor = Quantity_NOC_YELLOW;
777       }
778       else
779       {
780         aColor = Quantity_NOC_WHITE;
781       }
782       anAspect = new Prs2d_AspectLine(aColor, Aspect_TOL_SOLID, theWOL,
783                                       aColor, Graphic2d_TOPF_EMPTY);
784     }
785     else
786     {
787       Handle(Prs2d_AspectLine) anAspectLine = Handle(Prs2d_AspectLine)::DownCast(anAspect);
788       anAspectLine->SetWidth(theWOL);
789     }
790
791     theShape->SetAspect(anAspect);
792   }
793   else // unset width
794   {
795     if (!anAspect.IsNull())
796     {
797       Handle(Prs2d_AspectLine) anAspectLine = Handle(Prs2d_AspectLine)::DownCast(anAspect);
798       anAspectLine->SetWidth(Aspect_WOL_THIN);
799 //          anAspectLine->SetWidthIndex(0);
800       theShape->SetAspect(anAspect);
801     }
802   }
803
804   return 0;
805 }
806
807 static int V2dWidth (Draw_Interpretor& , Standard_Integer argc, const char** argv)
808 {
809   Standard_Boolean ThereIsArgument = Standard_False;
810   Standard_Boolean HaveToSet = Standard_False;
811
812   if (strcasecmp(argv[0], "v2dsetwidth") == 0) HaveToSet = Standard_True;
813
814   const char* aStr;
815   if (HaveToSet)
816   {
817     if (argc < 2 || argc > 3)
818     {
819       cout << "Usage: v2dsetwidth [name] width" << endl;
820       return 1;
821     }
822     if (argc == 3)
823     {
824       ThereIsArgument = Standard_True;
825       aStr = argv[2];
826     }
827     else
828     {
829       aStr = argv[1];
830     }
831   }
832   else
833   {
834     if ( argc > 2 )
835     {
836       cout << "Usage: v2dunsetwidth [name]" << endl;
837       return 1;
838     }
839     if (argc == 2) ThereIsArgument = Standard_True;
840   }
841
842   if (Viewer2dTest::CurrentView().IsNull()) return -1;
843   TheAIS2DContext()->CloseLocalContext();
844
845   Aspect_WidthOfLine aWOL = Aspect_WOL_THIN;
846   if (HaveToSet)
847   {
848     if      (strcmp(aStr, "THIN"     ) == 0) aWOL = Aspect_WOL_THIN;
849     else if (strcmp(aStr, "MEDIUM"   ) == 0) aWOL = Aspect_WOL_MEDIUM;
850     else if (strcmp(aStr, "THICK"    ) == 0) aWOL = Aspect_WOL_THICK;
851     else if (strcmp(aStr, "VERYTHICK") == 0) aWOL = Aspect_WOL_VERYTHICK;
852     else aWOL = Aspect_WOL_USERDEFINED;
853   }
854
855   if (ThereIsArgument)
856   {
857     TCollection_AsciiString name = argv[1];
858
859     if (GetMapOfAIS2D().IsBound2(name))
860     {
861       Handle(AIS2D_InteractiveObject) aShape = GetMapOfAIS2D().Find2(name);
862       V2dSetUnsetWidth(aShape, HaveToSet, aWOL);
863     }
864   }
865   else
866   {
867     Standard_Boolean hasCurrent = Standard_False;
868     Viewer2dTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName it (GetMapOfAIS2D());
869     for (; it.More() && !hasCurrent; it.Next())
870     {
871       if (TheAIS2DContext()->IsCurrent(it.Key1())) hasCurrent = Standard_True;
872     }
873     for (it.Reset(); it.More(); it.Next())
874     {
875       Handle(AIS2D_InteractiveObject) aShape = it.Key1();
876       if ((hasCurrent && TheAIS2DContext()->IsCurrent(aShape)) || !hasCurrent)
877       {
878         V2dSetUnsetWidth(aShape, HaveToSet, aWOL);
879       }
880     }
881 //    TheAIS2DContext()->UpdateCurrentViewer();
882   }
883   return 0;
884 }
885
886 //==============================================================================
887 //function : V2dDisplay
888 //purpose  : Display an object from its name
889 //Draw arg : v2ddisplay name [projection (Origin(x y z) Normal(dx dy dz) DX(dx dy dz)]
890 //==============================================================================
891 static int V2dDisplay (Draw_Interpretor& , Standard_Integer argc, const char** argv)
892 {
893   // Verification des arguments
894   if (argc != 2 && argc != 11)
895   {
896     cout << "Usage: v2ddisplay name [x y z dx dy dz dx1 dy1 dz1]" << endl;
897     return 1;
898   }
899   
900   if (Viewer2dTest::CurrentView().IsNull())
901   { 
902     cout << "2D AIS Viewer Initialization ..." << endl;
903     Viewer2dTest::ViewerInit(); 
904     cout << "Done" << endl;
905   }
906   
907   TCollection_AsciiString name;
908   TheAIS2DContext()->CloseLocalContext();
909   
910   name = argv[1];
911   gp_Ax2 anAx2 = gp::XOY();
912   if (argc == 11)
913   {
914     Standard_Real x = atof(argv[2]);
915     Standard_Real y = atof(argv[3]);
916     Standard_Real z = atof(argv[4]);
917
918     Standard_Real dx = atof(argv[5]);
919     Standard_Real dy = atof(argv[6]);
920     Standard_Real dz = atof(argv[7]);
921
922     Standard_Real dx1 = atof(argv[8]);
923     Standard_Real dy1 = atof(argv[9]);
924     Standard_Real dz1 = atof(argv[10]);
925
926     gp_Pnt anOrigin (x, y, z);
927     gp_Dir aNormal  (dx, dy, dz);
928     gp_Dir aDX      (dx1, dy1, dz1);
929     anAx2 = gp_Ax2(anOrigin, aNormal, aDX);
930   }
931
932   Standard_Boolean IsBound = GetMapOfAIS2D().IsBound2(name);
933   Standard_Boolean IsDatum = Standard_False;
934   Handle(AIS2D_InteractiveObject) aShape;
935   if (IsBound)
936   {
937     aShape = GetMapOfAIS2D().Find2(name);
938 //    if (aShape->Type() == AIS2D_KOI_Datum)
939     {
940       IsDatum = Standard_True;
941       TheAIS2DContext()->Display(aShape, Standard_False);
942 #ifdef OCC154
943       TheAIS2DContext()->HighlightCurrent();
944 #endif
945     }
946     if (!IsDatum)
947     {     
948       cout << "Display " << name << endl;
949       // Get the Shape from a name
950       TopoDS_Shape NewShape = GetShapeFromName2d((const char *)name.ToCString());
951
952       // Update the Shape in the AIS2D_ProjShape                                
953       Handle(AIS2D_ProjShape) TheRealSh = Handle(AIS2D_ProjShape)::DownCast(aShape);
954 //    if(!TheRealSh.IsNull())   TheRealSh->Set(NewShape);
955       TheAIS2DContext()->Redisplay(aShape, Standard_False);
956       TheAIS2DContext()->Display(aShape, Standard_False);
957     }
958     aShape.Nullify();
959   }
960   else // Create the AIS2D_ProjShape from a name
961   {
962     aShape = GetAIS2DShapeFromName((const char *)name.ToCString(), anAx2);
963     if (!aShape.IsNull())
964     {
965       GetMapOfAIS2D().Bind(aShape, name);
966       TheAIS2DContext()->Display(aShape, Standard_False);
967     }
968   }
969
970   // Update the screen and redraw the view
971   TheAIS2DContext()->UpdateCurrentViewer();
972   return 0; 
973 }
974
975 //==============================================================================
976 //function : V2dDonly
977 //purpose  : Display only a selected or named  object
978 //           if there is no selected or named object s, the whole viewer is erased
979 //Draw arg : vdonly [name1] ... [name n]
980 //==============================================================================
981 static int V2dDonly (Draw_Interpretor& , Standard_Integer argc, const char** argv)
982 {
983   if (Viewer2dTest::CurrentView().IsNull()) return 1;
984   
985   Standard_Boolean ThereIsArgument = argc > 1;
986   
987   if (TheAIS2DContext()->HasOpenedContext()) TheAIS2DContext()->CloseLocalContext();
988
989   if (ThereIsArgument)
990   {
991     TheAIS2DContext()->EraseAll(Standard_True, Standard_False);            
992
993     for (int i = 1; i < argc; i++)
994     {
995       TCollection_AsciiString name = argv[i];
996       Standard_Boolean IsBound = GetMapOfAIS2D().IsBound2(name);
997       if (IsBound)
998       {
999         Handle(AIS2D_InteractiveObject) aShape = GetMapOfAIS2D().Find2(name);
1000         TheAIS2DContext()->Display(aShape, Standard_False);
1001       }
1002     }
1003     TheAIS2DContext()->CurrentViewer()->Update();
1004   }
1005   else
1006   {
1007     Standard_Boolean ThereIsCurrent = Standard_True/*= TheAIS2DContext()->NbCurrents() > 0*/;
1008     if (ThereIsCurrent)
1009     {
1010       Viewer2dTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName it (GetMapOfAIS2D());
1011       while (it.More())
1012       {
1013         Handle(AIS2D_InteractiveObject) aShape = it.Key1();
1014         if (!TheAIS2DContext()->IsCurrent(aShape))
1015           TheAIS2DContext()->Erase(aShape, Standard_False);        
1016         it.Next();
1017       }
1018       TheAIS2DContext()->CurrentViewer()->Update();
1019     }
1020   }
1021
1022   return 0; 
1023 }
1024
1025 //==============================================================================
1026 //function : V2dErase
1027 //purpose  : Erase some selected or named objects.
1028 //           If there is no selected or named objects, does nothing
1029 //Draw arg : v2derase [name1] ... [name n]
1030 //==============================================================================
1031 static int V2dErase (Draw_Interpretor& , Standard_Integer argc, const char** argv)
1032 {
1033   if (Viewer2dTest::CurrentView().IsNull()) return 1;
1034   
1035   if (TheAIS2DContext()->HasOpenedContext()) TheAIS2DContext()->CloseLocalContext();
1036
1037   if (argc > 1) // has arguments
1038   {
1039     for (int i = 1; i < argc; i++)
1040     {
1041       TCollection_AsciiString name = argv[i];
1042       Standard_Boolean IsBound = GetMapOfAIS2D().IsBound2(name);
1043       if (IsBound)
1044       {
1045         Handle(AIS2D_InteractiveObject) aShape = GetMapOfAIS2D().Find2(name);
1046         TheAIS2DContext()->Erase(aShape, Standard_False);  
1047       }
1048     }
1049 //    TheAIS2DContext()->UpdateCurrentViewer();
1050     TheAIS2DContext()->CurrentViewer()->Update();
1051   }
1052   else
1053   {
1054     Viewer2dTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName it (GetMapOfAIS2D());
1055     while (it.More())
1056     {
1057       Handle(AIS2D_InteractiveObject) aShape = it.Key1();
1058       if (TheAIS2DContext()->IsCurrent(aShape))
1059         TheAIS2DContext()->Erase(aShape, Standard_False);        
1060       it.Next();
1061     }
1062 //    TheAIS2DContext()->UpdateCurrentViewer();
1063     TheAIS2DContext()->CurrentViewer()->Update();
1064   }
1065
1066   return 0; 
1067 }
1068
1069 //==============================================================================
1070 //function : V2dEraseAll
1071 //purpose  : Erase all the objects displayed in the viewer
1072 //Draw arg : v2deraseall
1073 //==============================================================================
1074 static int V2dEraseAll (Draw_Interpretor& , Standard_Integer argc, const char** )
1075 {
1076   if (argc > 1)
1077   {
1078     cout << "Usage: v2deraseall" << endl;
1079     return 1;
1080   }
1081
1082   if (Viewer2dTest::CurrentView().IsNull())
1083   {
1084     cout << " Error: v2dinit hasn't been called." << endl;
1085     return 1;
1086   }
1087
1088   TheAIS2DContext()->CloseAllContext(Standard_False);
1089
1090   // EraseAll(Standard_True, Standard_True);            
1091   TheAIS2DContext()->EraseAll();
1092   return 0;
1093 }
1094
1095 //==============================================================================
1096 //function : V2dDisplayAll
1097 //purpose  : Display all the objects of the Map
1098 //Draw arg : v2ddisplayall
1099 //==============================================================================
1100 static int V2dDisplayAll (Draw_Interpretor& , Standard_Integer argc, const char** argv)
1101 {
1102   if (Viewer2dTest::CurrentView().IsNull()) return 1;
1103
1104   if (argc > 1)
1105   {
1106     cout << argv[0] << " Syntaxe error" << endl;
1107     return 1;
1108   }
1109   TheAIS2DContext()->CloseLocalContext();
1110   Viewer2dTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName it (GetMapOfAIS2D());
1111 //  while (it.More())
1112 //  {
1113 //    Handle(AIS2D_InteractiveObject) aShape = it.Key1();
1114 //    TheAIS2DContext()->Erase(aShape,Standard_False);        
1115 //    it.Next();
1116 //  }
1117 //  it.Reset();
1118   while (it.More())
1119   {
1120     Handle(AIS2D_InteractiveObject) aShape = it.Key1();
1121     TheAIS2DContext()->Display(aShape, Standard_False);        
1122     it.Next();
1123   }
1124 #ifdef OCC154
1125   TheAIS2DContext()->HighlightCurrent();
1126 #endif
1127   TheAIS2DContext()->UpdateCurrentViewer();
1128 //  TheAIS2DContext()->DisplayAll();
1129   return 0; 
1130 }
1131
1132 //==============================================================================
1133 //function : VTexture
1134 //purpose  : 
1135 //Draw arg : 
1136 //==============================================================================
1137 /*
1138 Standard_Integer VTexture (Draw_Interpretor& di,Standard_Integer argc, Standard_Character** argv )
1139 {
1140   Standard_Integer command = (strcasecmp(argv[0],"vtexture")==0)? 1:
1141     (strcasecmp(argv[0],"vtexscale")==0) ? 2 :
1142       (strcasecmp(argv[0],"vtexorigin")==0) ? 3 :
1143         (strcasecmp(argv[0],"vtexrepeat")==0) ? 4 :
1144           (strcasecmp(argv[0],"vtexdefault")==0) ? 5 : -1;
1145   
1146   Handle(AIS2D_InteractiveContext) myAIS2DContext = Viewer2dTest::GetAIS2DContext();
1147   if(myAIS2DContext.IsNull()) 
1148     { 
1149       cerr << "use 'vinit' command before " << argv[0] << endl;
1150       return 0;
1151     }
1152   
1153   Handle(AIS2D_InteractiveObject) TheAisIO;
1154   Handle(AIS2D_TexturedShape) myShape;
1155   Standard_Integer myPreviousMode = 0;
1156
1157   if (!argv[1])
1158     {
1159       cout << argv[0] <<" syntax error - Type 'help vtex'"<<endl;
1160       return 0;
1161     }
1162   
1163   TCollection_AsciiString name = argv[1];
1164   Viewer2dTest::CurrentView()->SetSurfaceDetail(V2d_TEX_ALL);
1165   
1166   if (GetMapOfAIS2D().IsBound2(name)) 
1167     TheAisIO = GetMapOfAIS2D().Find2(name);
1168   else
1169     {
1170       cout <<"shape "<<name<<" doesn\'t exist"<<endl;
1171       return 0;
1172     }
1173   
1174   if (TheAisIO->IsKind(STANDARD_TYPE(AIS2D_TexturedShape)) && !TheAisIO.IsNull())
1175     {
1176       myShape = Handle(AIS2D_TexturedShape)::DownCast(TheAisIO);
1177       myPreviousMode = myShape->DisplayMode() ;
1178     }
1179   else
1180     {
1181       myAIS2DContext->Erase(TheAisIO,Standard_False);
1182       myShape = new AIS2D_TexturedShape (DBRep::Get(argv[1]));
1183       GetMapOfAIS2D().UnBind1(TheAisIO);
1184       GetMapOfAIS2D().UnBind2(name);
1185       GetMapOfAIS2D().Bind(myShape, name);  
1186     }
1187   switch (command)
1188     {
1189     case 1: // vtexture : we only map a texture on the shape
1190       if(argc<=1)
1191         { 
1192           cerr << argv[0] <<" syntax error - Type 'help vtex'" << endl;
1193           return 0;
1194         }
1195       if (argv[2])
1196         {
1197           if(strcasecmp(argv[2],"?")==0)
1198             { 
1199               TCollection_AsciiString monPath = GetEnvir2d();
1200               
1201               cout<<"\n Files in current directory : \n"<<endl;
1202               TCollection_AsciiString Cmnd ("glob -nocomplain *");
1203               di.Eval(Cmnd.ToCString());
1204               
1205               Cmnd = TCollection_AsciiString("glob -nocomplain ") ;
1206               Cmnd += monPath ;
1207               Cmnd += "/" ;
1208               Cmnd += "* " ;
1209               cout<<"Files in "<<monPath<<" : \n"<<endl;
1210               di.Eval(Cmnd.ToCString());
1211               
1212               return 0;
1213             }
1214           else
1215             myShape->SetTextureFileName(argv[2]);
1216         }
1217       else
1218         {
1219           cout <<"Texture mapping disabled \n \
1220                   To enable it, use 'vtexture NameOfShape NameOfTexture' \n"<<endl;
1221
1222           myAIS2DContext->SetDisplayMode(myShape,1,Standard_False);
1223           if (myPreviousMode == 3 )
1224             myAIS2DContext->RecomputePrsOnly(myShape);
1225           myAIS2DContext->Display(myShape, Standard_True);
1226           return 0;
1227         }
1228       break;
1229       
1230     case 2: // vtexscale : we change the scaling factor of the texture
1231       
1232       if(argc<2) 
1233         { 
1234           cerr << argv[0] <<" syntax error - Type 'help vtex'" << endl;
1235           return 0;
1236         }
1237       
1238       myShape->SetTextureScale (( argv[2] ? Standard_True    : Standard_False ),
1239                                 ( argv[2] ? atof(argv[2])    : 1.0 ),
1240                                 ( argv[2] ? atof(argv[argc-1]) : 1.0 ) );
1241       break;
1242       
1243     case 3: // vtexorigin : we change the origin of the texture on the shape
1244       if(argc<2) 
1245         { 
1246           cerr << argv[0] <<" syntax error - Type 'help vtex'" << endl;
1247           return 0;
1248         }
1249       myShape->SetTextureOrigin (( argv[2] ? Standard_True    : Standard_False ),
1250                                  ( argv[2] ? atof(argv[2])    : 0.0 ),
1251                                  ( argv[2] ? atof(argv[argc-1]) : 0.0 ));
1252       break;
1253       
1254     case 4: // vtexrepeat : we change the number of occurences of the texture on the shape
1255       if(argc<2)
1256         { 
1257           cerr << argv[0] <<" syntax error - Type 'help vtex'" << endl;
1258           return 0;
1259         }
1260       if (argv[2])
1261         {
1262           cout <<"Texture repeat enabled"<<endl;
1263           myShape->SetTextureRepeat(Standard_True, atof(argv[2]), atof(argv[argc-1]) );
1264         }
1265       else
1266         {
1267           cout <<"Texture repeat disabled"<<endl;
1268           myShape->SetTextureRepeat(Standard_False);
1269         }
1270       break;
1271       
1272     case 5: // vtexdefault : default texture mapping
1273       // ScaleU = ScaleV = 100.0
1274       // URepeat = VRepeat = 1.0
1275       // Uorigin = VOrigin = 0.0
1276       
1277       if(argc<2)
1278         { 
1279           cerr << argv[0] <<" syntax error - Type 'help vtex'" << endl;
1280           return 0;
1281         }
1282       myShape->SetTextureRepeat(Standard_False);
1283       myShape->SetTextureOrigin(Standard_False);
1284       myShape->SetTextureScale (Standard_False);
1285       break;
1286     }
1287
1288   if ((myShape->DisplayMode() == 3) || (myPreviousMode == 3 ))
1289     myAIS2DContext->RecomputePrsOnly(myShape);
1290   else 
1291     {
1292       myAIS2DContext->SetDisplayMode(myShape,3,Standard_False);
1293       myAIS2DContext->Display(myShape, Standard_True);
1294       myAIS2DContext->Update(myShape,Standard_True);
1295     } 
1296   return 1;
1297 }
1298 */
1299
1300 #if 0
1301 //==============================================================================
1302 //function : V2dShading
1303 //purpose  : Sharpen or roughten the quality of the shading
1304 //Draw arg : vshading ShapeName 0.1->0.00001  1 deg-> 30 deg
1305 //==============================================================================
1306 static int V2dShading (Draw_Interpretor& ,Standard_Integer argc, const char** argv)
1307 {
1308   Standard_Boolean HaveToSet;
1309 //  Standard_Real    myDevAngle;
1310   Standard_Real    myDevCoef;
1311   Handle(AIS2D_InteractiveObject) TheAisIO;
1312   
1313   // Verifications
1314   if (!strcasecmp(argv[0],"vsetshading")) HaveToSet = Standard_True;
1315   else HaveToSet = Standard_False;
1316   TheAIS2DContext()->CloseLocalContext();
1317
1318   if (argc < 3)
1319   {
1320     myDevCoef = 0.0008;
1321   }
1322   else
1323   {
1324     myDevCoef = atof(argv[2]);
1325   }
1326
1327   TCollection_AsciiString name = argv[1];
1328   if (GetMapOfAIS2D().IsBound2(name)) TheAisIO = GetMapOfAIS2D().Find2(name);
1329   else
1330   { 
1331     TheAisIO = GetAIS2DShapeFromName(name.ToCString());
1332   }
1333   
1334   if (HaveToSet)
1335   {
1336 //    TheAIS2DContext()->SetDeviationCoefficient(TheAisIO,myDevCoef,Standard_True);
1337   }
1338   else
1339   {
1340 //    TheAIS2DContext()->SetDeviationCoefficient(TheAisIO,0.0008,Standard_True);
1341   }
1342   
1343   TheAIS2DContext()->Redisplay(TheAisIO);
1344   return 0;
1345 }
1346 #endif
1347
1348 //=======================================================================
1349 //function : VEraseType
1350 //purpose  : 
1351 //=======================================================================
1352 /*static int VEraseType (Draw_Interpretor& , Standard_Integer argc, const char** argv) 
1353 {
1354   if (argc!=2) return 1;
1355
1356   AIS2D_KindOfInteractive TheType;
1357   Standard_Integer TheSign(-1);
1358   GetTypeAndSignfromString2d(argv[1],TheType,TheSign);
1359   
1360   AIS2D_ListOfInteractive LIO;
1361
1362   // en attendant l'amelioration ais pour les dimensions...
1363   //
1364   Standard_Integer dimension_status(-1);
1365   if(TheType==AIS2D_KOI_Relation){
1366     dimension_status = TheSign ==1 ? 1 : 0;
1367     TheSign=-1;
1368   }
1369   
1370   TheAIS2DContext()->DisplayedObjects(TheType,TheSign,LIO);
1371   Handle(AIS2D_InteractiveObject) curio;
1372   for(AIS2D_ListIteratorOfListOfInteractive it(LIO);it.More();it.Next()){
1373     curio  = it.Value();
1374     
1375     if(dimension_status == -1)
1376       TheAIS2DContext()->Erase(curio,Standard_False);
1377     else {
1378       AIS2D_KindOfDimension KOD = (*((Handle(AIS2D_Relation)*)&curio))->KindOfDimension();
1379       if ((dimension_status==0 && KOD == AIS2D_KOD_NONE)||
1380           (dimension_status==1 && KOD != AIS2D_KOD_NONE))
1381         TheAIS2DContext()->Erase(curio,Standard_False);
1382     }
1383   }
1384   TheAIS2DContext()->UpdateCurrentViewer();
1385   return 0;
1386 }*/
1387
1388 //=======================================================================
1389 //function : V2dDisplayType
1390 //purpose  : 
1391 //=======================================================================
1392 /*static int V2dDisplayType (Draw_Interpretor& , Standard_Integer argc, const char** argv) 
1393 {
1394   if (argc!=2) return 1;
1395
1396   AIS2D_KindOfInteractive TheType;
1397   Standard_Integer TheSign(-1);
1398   GetTypeAndSignfromString2d(argv[1],TheType,TheSign);
1399
1400   // en attendant l'amelioration ais pour les dimensions...
1401   //
1402   Standard_Integer dimension_status(-1);
1403   if(TheType==AIS2D_KOI_Relation){
1404     dimension_status = TheSign ==1 ? 1 : 0;
1405     TheSign=-1;
1406   }
1407   
1408   AIS2D_ListOfInteractive LIO;
1409   TheAIS2DContext()->ObjectsInside(LIO,TheType,TheSign);
1410   Handle(AIS2D_InteractiveObject) curio;
1411   for(AIS2D_ListIteratorOfListOfInteractive it(LIO);it.More();it.Next()){
1412     curio  = it.Value();
1413     if(dimension_status == -1)
1414       TheAIS2DContext()->Display(curio,Standard_False);
1415     else {
1416       AIS2D_KindOfDimension KOD = (*((Handle(AIS2D_Relation)*)&curio))->KindOfDimension();
1417       if ((dimension_status==0 && KOD == AIS2D_KOD_NONE)||
1418           (dimension_status==1 && KOD != AIS2D_KOD_NONE))
1419         TheAIS2DContext()->Display(curio,Standard_False);
1420     }
1421
1422   }
1423   
1424   TheAIS2DContext()->UpdateCurrentViewer();
1425   return 0;
1426 }*/
1427
1428
1429 //Additional commands
1430
1431  //=======================================================================
1432 //function : GetMaterialFromName2d
1433 //purpose  : get the Graphic3d_NameOfMaterial from a string
1434 //=======================================================================
1435 static Aspect_TypeOfLine GetLineTypeFromName2d (const char *name) 
1436
1437
1438   Aspect_TypeOfLine aLT = Aspect_TOL_SOLID;
1439   if      ( !strcasecmp(name,"DASH" ) )          aLT = Aspect_TOL_DASH;
1440   else if ( !strcasecmp(name,"DOT" ) )           aLT = Aspect_TOL_DOT;
1441   else if ( !strcasecmp(name,"DOTDASH" ) )       aLT = Aspect_TOL_DOTDASH;
1442   return aLT;
1443 }
1444
1445
1446 //==============================================================================
1447 //function : V2dTypeofLine
1448 //purpose  : change the line type of a selected or named or displayed shape 
1449 //Draw arg : v2dsetlinetype [name] type 
1450 //==============================================================================
1451
1452 static int V2dSetUnsetTypeOfLine (Handle(AIS2D_InteractiveObject) theShape,
1453                                   Standard_Boolean HaveToSet,
1454                                   Aspect_TypeOfLine theType = Aspect_TOL_SOLID)
1455 {
1456   theShape->SetContext(TheAIS2DContext());
1457
1458   Handle(Graphic2d_Primitive) aPrim;
1459   Handle(Prs2d_AspectRoot)    anAspect;
1460   //get all primitives
1461   Standard_Integer i = 1, n = theShape->Length();
1462   for (; i <= n; i++)
1463   {
1464     aPrim = theShape->Primitive(i);
1465     if (theShape->HasAspect(aPrim))
1466     {
1467       anAspect = theShape->GetAspect(aPrim);
1468       if (anAspect->GetAspectName() == Prs2d_AN_LINE) break;
1469       else anAspect = NULL;
1470     }
1471   }
1472
1473   if (HaveToSet)
1474   {
1475     if (anAspect.IsNull())
1476     {
1477       theShape->SetAspect
1478         (new Prs2d_AspectLine(Quantity_NOC_YELLOW, theType, Aspect_WOL_THIN,
1479                               Quantity_NOC_YELLOW, Graphic2d_TOPF_FILLED));
1480     }
1481     else
1482     {
1483       Handle(Prs2d_AspectLine) anAspectLine = Handle(Prs2d_AspectLine)::DownCast(anAspect);
1484       anAspectLine->SetTypeOfFill(Graphic2d_TOPF_FILLED);
1485       anAspectLine->SetType( theType );
1486       theShape->SetAspect(anAspect);
1487     }
1488   }
1489   else // unset type line
1490   {
1491     Handle(Prs2d_AspectLine) anAspectLine;
1492     if ( !anAspect.IsNull() )
1493       anAspectLine = Handle(Prs2d_AspectLine)::DownCast(anAspect);
1494     else
1495       anAspectLine = new Prs2d_AspectLine();
1496
1497     anAspectLine->SetTypeOfFill(Graphic2d_TOPF_EMPTY);
1498     anAspectLine->SetType(Aspect_TOL_SOLID);
1499     theShape->SetAspect( anAspectLine );
1500   }
1501
1502   return 0;
1503 }
1504
1505 static int V2dTypeOfLine (Draw_Interpretor& , Standard_Integer argc, const char** argv)
1506 {
1507   Standard_Boolean ThereIsArgument = Standard_False;
1508   Standard_Boolean HaveToSet = Standard_False;
1509
1510   if (strcasecmp(argv[0],"v2dsetlinetype") == 0) HaveToSet = Standard_True;
1511
1512   Aspect_TypeOfLine aType = Aspect_TOL_SOLID;
1513   //Quantity_NameOfColor aColor = Quantity_NOC_BLACK;
1514   if (HaveToSet)
1515   {
1516     if (argc < 2 || argc > 3)
1517     {
1518       cout << "Usage: v2dsetlinetype [name] type" << endl;
1519       return 1;
1520     }
1521     if (argc == 3)
1522     {
1523       ThereIsArgument = Standard_True;
1524       aType = GetLineTypeFromName2d(argv[2]);
1525     }
1526     else
1527     {
1528       aType = GetLineTypeFromName2d(argv[1]);
1529     }
1530   }
1531   else
1532   {
1533     if (argc > 2)
1534     {
1535       cout << "Usage: v2dunsetlinetype [name]" << endl;
1536       return 1;
1537     }
1538     if (argc == 2) ThereIsArgument = Standard_True;
1539   }
1540   
1541   if (Viewer2dTest::CurrentView().IsNull()) return -1;
1542   TheAIS2DContext()->CloseLocalContext();
1543
1544   if (ThereIsArgument)
1545   {
1546     TCollection_AsciiString name = argv[1];
1547
1548     if (GetMapOfAIS2D().IsBound2(name))
1549     {
1550       Handle(AIS2D_InteractiveObject) aShape = GetMapOfAIS2D().Find2(name);
1551       V2dSetUnsetTypeOfLine(aShape, HaveToSet, aType);
1552     }
1553   }
1554   else
1555   {
1556     Standard_Boolean hasCurrent = Standard_False;
1557     Viewer2dTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName it (GetMapOfAIS2D());
1558     for (; it.More() && !hasCurrent; it.Next())
1559     {
1560       if (TheAIS2DContext()->IsCurrent(it.Key1())) hasCurrent = Standard_True;
1561     }
1562     for (it.Reset(); it.More(); it.Next())
1563     {
1564       Handle(AIS2D_InteractiveObject) aShape = it.Key1();
1565       if ((hasCurrent && TheAIS2DContext()->IsCurrent(aShape)) || !hasCurrent)
1566       {
1567         V2dSetUnsetTypeOfLine(aShape, HaveToSet, aType);
1568       }
1569     }
1570   }
1571   return 0;
1572 }
1573
1574
1575 static int drawPoint (Draw_Interpretor& , Standard_Integer argc, const char** argv)
1576 {
1577   if( argc < 1 ) {
1578     cout << argv[0] << " Syntaxe error" << endl;
1579     return 1;
1580   }
1581   
1582   if (Viewer2dTest::CurrentView().IsNull()) { 
1583     cout << "2D AIS Viewer Initialization ..." << endl;
1584     Viewer2dTest::ViewerInit(); 
1585     cout << "Done" << endl;
1586   }
1587   
1588   Standard_Real x = 24., y = 24.;
1589   if( argc >= 2 )
1590     x = atof( argv[1] );
1591   if( argc >= 3 )
1592     y = atof( argv[2] );
1593
1594   Handle(AIS2D_InteractiveObject) aIO = new AIS2D_InteractiveObject();
1595   Handle_Prs2d_Point origin = new Prs2d_Point(aIO, gp_Pnt2d( x, y ), 
1596                                               Aspect_TypeOfMarker(argc >= 4 ? atoi(argv[3]) : Aspect_TOM_PLUS), 2, 2, 0);
1597   TheAIS2DContext()->Display(aIO, Standard_True);
1598   return 0;
1599 }
1600 static int drawAxis (Draw_Interpretor& , Standard_Integer argc, const char** argv)
1601 {
1602   if( argc < 1 ) {
1603     cout << argv[0] << " Syntaxe error" << endl;
1604     return 1;
1605   }
1606   
1607   if (Viewer2dTest::CurrentView().IsNull()) { 
1608     cout << "2D AIS Viewer Initialization ..." << endl;
1609     Viewer2dTest::ViewerInit(); 
1610     cout << "Done" << endl;
1611   }
1612   Handle(AIS2D_InteractiveObject) aIO = new AIS2D_InteractiveObject();
1613   
1614   Standard_Real loc_x = 24., loc_y = 84.;
1615   if( argc >= 2 )
1616     loc_x = atof( argv[1] );
1617   if( argc >= 3 )
1618     loc_y = atof( argv[2] );
1619   gp_Pnt2d location(loc_x, loc_y);
1620   
1621   Standard_Real dir_x = 0., dir_y = 1.;
1622   if( argc >= 4 )
1623     dir_x = atof( argv[3] );
1624   if( argc >= 5 )
1625     dir_y = atof( argv[4] );
1626   gp_Dir2d direction(dir_x, dir_y);
1627   
1628   gp_Dir2d refdirection(0.0, 1.0);
1629   gp_Ax22d axis(location, direction, refdirection);
1630   Handle_Prs2d_Axis axis2 = new Prs2d_Axis(aIO, axis, 48, 24.0, 24.0, Prs2d_TOA_OPENED, 10.0); 
1631   TheAIS2DContext()->Display(aIO, Standard_True);
1632   return 0;
1633 }
1634
1635 static int drawLine (Draw_Interpretor& , Standard_Integer argc, const char** argv)
1636 {
1637   if( argc < 1 ) {
1638     cout << argv[0] << " Syntaxe error" << endl;
1639     return 1;
1640   }
1641   
1642   if (Viewer2dTest::CurrentView().IsNull()) { 
1643     cout << "2D AIS Viewer Initialization ..." << endl;
1644     Viewer2dTest::ViewerInit(); 
1645     cout << "Done" << endl;
1646   }
1647   Standard_Real x1 = -11., y1 = -250., d1 = 100., d2 = 200.;
1648    
1649   if( argc >= 2 )
1650     x1 = atof( argv[1] );
1651   if( argc >= 3 )
1652     y1 = atof( argv[2] );
1653   if( argc >= 4 )
1654     d1 = atof( argv[3] );
1655   if( argc == 5 )
1656     d2 = atof( argv[4] );
1657
1658   Handle(AIS2D_InteractiveObject) aIO = new AIS2D_InteractiveObject();
1659   gp_Pnt2d FirstPt(x1, y1);
1660   gp_Dir2d direction(d1, d2);
1661   Handle_Geom2d_Line line = new Geom2d_Line(FirstPt, direction);
1662   Handle(GGraphic2d_Curve) grCurve = new GGraphic2d_Curve(aIO, line);
1663
1664   TheAIS2DContext()->Display(aIO, Standard_True );
1665
1666   return 0;
1667 }
1668 static int drawSegment (Draw_Interpretor& , Standard_Integer argc, const char** argv)
1669 {
1670   if( argc < 1 ) {
1671     cout << argv[0] << " Syntaxe error" << endl;
1672     return 1;
1673   }
1674   
1675   if (Viewer2dTest::CurrentView().IsNull()) { 
1676     cout << "2D AIS Viewer Initialization ..." << endl;
1677     Viewer2dTest::ViewerInit(); 
1678     cout << "Done" << endl;
1679   }
1680
1681   Standard_Real x1 = 0., y1 = 20., x2 = 100., y2 = 200.;
1682    
1683   if( argc >= 2 )
1684     x1 = atof( argv[1] );
1685   if( argc >= 3 )
1686     y1 = atof( argv[2] );
1687   if( argc >= 4 )
1688     x2 = atof( argv[3] );
1689   if( argc == 5 )
1690     y2 = atof( argv[4] );
1691
1692   Handle(AIS2D_InteractiveObject) aIO = new AIS2D_InteractiveObject();
1693   Handle(Graphic2d_Segment) theSegment = new Graphic2d_Segment( aIO, x1, y1, x2, y2 );
1694   TheAIS2DContext()->Display(aIO, Standard_True);
1695   return 0;
1696 }
1697
1698 static int drawArrowLine (Draw_Interpretor& , Standard_Integer argc, const char** argv)
1699 {
1700   if( argc < 1 ) {
1701     cout << argv[0] << " Syntaxe error" << endl;
1702     return 1;
1703   }
1704   
1705   if (Viewer2dTest::CurrentView().IsNull()) { 
1706     cout << "2D AIS Viewer Initialization ..." << endl;
1707     Viewer2dTest::ViewerInit(); 
1708     cout << "Done" << endl;
1709   }
1710   
1711   Standard_Real x1 = 24, y1 = 24, x2 = 420, y2 = 420;
1712    
1713   if( argc >= 3 )
1714     x1 = atof( argv[2] );
1715   if( argc >= 4 )
1716     y1 = atof( argv[3] );
1717   if( argc >= 5 )
1718     x2 = atof( argv[4] );
1719   if( argc == 6 )
1720     y2 = atof( argv[5] );
1721
1722
1723   Handle(AIS2D_InteractiveObject) aIO = new AIS2D_InteractiveObject();
1724   gp_Pnt2d FirstPt(x1, y1);
1725   gp_Pnt2d LastPt(x2, y2);
1726   double arrow_angle = 24;
1727   double arrow_length = FirstPt.Distance(LastPt)/10.;
1728   int arrow_type = 1;
1729   
1730   gp_Ax2d ax;
1731   ax = gp_Ax2d(FirstPt, gp_Dir2d(gp_Vec2d(LastPt, FirstPt)));
1732   
1733   Handle(Prs2d_Arrow) h_arrow;
1734   h_arrow = new Prs2d_Arrow(aIO, ax, arrow_angle, arrow_length, Prs2d_TypeOfArrow(arrow_type));
1735   
1736   GCE2d_MakeSegment segment(FirstPt, LastPt);
1737   Handle(Geom2d_TrimmedCurve) trCur = segment.Value();
1738   Handle(GGraphic2d_Curve) grCurve = new GGraphic2d_Curve(aIO, trCur);
1739
1740   GetMapOfAIS2D().Bind(aIO, argv[1]);
1741   TheAIS2DContext()->Display(aIO, Standard_True );
1742   TheAIS2DContext()->UpdateCurrentViewer();
1743   return 0;
1744 }
1745
1746
1747 static int draw2DText (Draw_Interpretor& , Standard_Integer argc, const char** argv)
1748 {
1749  
1750   if( argc < 2 ) {
1751     cout << argv[0] << " Syntaxe error" << endl;
1752     return 1;
1753   }
1754   
1755   if (Viewer2dTest::CurrentView().IsNull())  { 
1756     cout << "2D AIS Viewer Initialization ..." << endl;
1757     Viewer2dTest::ViewerInit(); 
1758     cout << "Done" << endl;
1759   }
1760   
1761   Standard_Real x1 = 24, y1 = 24;
1762   Quantity_PlaneAngle anAngle = 0.0;
1763   Quantity_Factor     aScale = 1.0;
1764   Standard_Boolean isUnderline = Standard_False;
1765    
1766   if( argc >= 4 )
1767     x1 = atof( argv[3] );
1768   if( argc >= 5 )
1769     y1 = atof( argv[4] );
1770   if( argc >= 6 )
1771     anAngle = atof( argv[5] );
1772   if( argc >= 7 )
1773     aScale = atof( argv[6] );
1774   if( argc >= 8 )
1775     isUnderline = atoi( argv[7] );
1776   
1777     
1778
1779   Handle(AIS2D_InteractiveObject) aIO = new AIS2D_InteractiveObject();
1780   TCollection_ExtendedString aString(argv[2]);
1781   Handle(Graphic2d_Text) aText = new Graphic2d_Text(aIO,aString,x1,y1, anAngle, Aspect_TOT_SOLID, aScale);
1782   aText->SetUnderline(isUnderline);
1783   
1784   Handle(Prs2d_AspectText) aspect = new Prs2d_AspectText();
1785   aspect->SetFont(Aspect_TOF_HELVETICA);
1786   aspect->SetColor(Quantity_NOC_WHITE);
1787   aIO->SetAspect(aspect);
1788   
1789   Standard_Integer color_index = 2;
1790   aText->SetColorIndex(color_index);
1791    
1792   
1793   GetMapOfAIS2D().Bind(aIO, argv[1]);
1794   TheAIS2DContext()->Display(aIO, Standard_True );
1795   TheAIS2DContext()->UpdateCurrentViewer();
1796   return 0;
1797 }
1798
1799 static int drawToleanceFrame( Draw_Interpretor& , Standard_Integer argc, const char** argv )
1800 {
1801   if( argc < 1 )
1802   {
1803     cout << argv[0] << " Syntaxe error" << endl;
1804     return 1;
1805   }
1806   
1807   if (Viewer2dTest::CurrentView().IsNull())
1808   { 
1809     cout << "2D AIS Viewer Initialization ..." << endl;
1810     Viewer2dTest::ViewerInit(); 
1811     cout << "Done" << endl;
1812   }
1813
1814   Handle(AIS2D_InteractiveObject) aIO = new AIS2D_InteractiveObject();
1815   Standard_Real aX = 24, aY = 48;
1816   Standard_Real height = 24;
1817
1818   if( argc >= 2 )
1819     height = atof( argv[1] );
1820   
1821   if( argc >= 3 )
1822     aX = atof( argv[2] );
1823   if( argc >= 4 )
1824     aX = atof( argv[3] );
1825
1826   gp_Pnt2d location(aX, aY);
1827   
1828   int tol_type = 10;
1829   if( argc >= 5 )
1830    tol_type = atoi( argv[4] );
1831
1832   double angle = 0.0;
1833   double text_scale = 10.0;
1834   
1835   Handle(Prs2d_ToleranceFrame) symbol;
1836   symbol = new Prs2d_ToleranceFrame( aIO, location.X(), location.Y(), height,
1837                                     Prs2d_TypeOfTolerance(tol_type), "B", "-0.01", " A", angle, text_scale);
1838   
1839   TheAIS2DContext()->Display(aIO, Standard_True );
1840   TheAIS2DContext()->UpdateCurrentViewer();
1841   return 0;
1842 }
1843
1844 static int drawArc( Draw_Interpretor& , Standard_Integer argc, const char** argv )
1845 {
1846   if( argc < 1 )
1847   {
1848     cout << argv[0] << " Syntaxe error" << endl;
1849     return 1;
1850   }
1851   
1852   if (Viewer2dTest::CurrentView().IsNull())
1853   { 
1854     cout << "2D AIS Viewer Initialization ..." << endl;
1855     Viewer2dTest::ViewerInit(); 
1856     cout << "Done" << endl;
1857   }
1858
1859   Handle(AIS2D_InteractiveObject) aIO = new AIS2D_InteractiveObject();
1860         
1861   Standard_Real x1 = 0., y1 = 0., x2 = 24., y2 = 24., x3 = 12., y3 = 48.;
1862    
1863   if( argc >= 2 )
1864     x1 = atof( argv[1] );
1865   if( argc >= 3 )
1866     y1 = atof( argv[2] );
1867   if( argc >= 4 )
1868     x2 = atof( argv[3] );
1869   if( argc >= 5 )
1870     y2 = atof( argv[4] );
1871   if( argc >= 6)
1872     x3= atof( argv[5] );
1873   if( argc >= 7 )
1874     y3 = atof( argv[6] );
1875
1876   gp_Pnt2d point1(x1, y1);
1877   gp_Pnt2d point2(x2, y2);
1878   gp_Pnt2d point3(x3, y3);
1879   
1880   GCE2d_MakeArcOfCircle arc(point1, point2, point3);
1881   Handle_Geom2d_TrimmedCurve trCur = arc.Value();
1882   
1883   Handle_GGraphic2d_Curve grCurve = new GGraphic2d_Curve(aIO, trCur);
1884   TheAIS2DContext()->Display(aIO, Standard_True);
1885   return 0;
1886 }
1887
1888 static int drawFinishSymbol( Draw_Interpretor& , Standard_Integer argc, const char** argv )
1889 {
1890   if( argc < 1 )
1891   {
1892     cout << argv[0] << " Syntaxe error" << endl;
1893     return 1;
1894   }
1895   
1896   if (Viewer2dTest::CurrentView().IsNull())
1897   { 
1898     cout << "2D AIS Viewer Initialization ..." << endl;
1899     Viewer2dTest::ViewerInit(); 
1900     cout << "Done" << endl;
1901   }
1902
1903   gp_Pnt2d location(48, 84);
1904   double length = 10;
1905   double angle = 0;
1906
1907   Handle(AIS2D_InteractiveObject) aIO = new AIS2D_InteractiveObject();
1908   
1909   Handle(Graphic2d_Polyline) symbol;
1910   Handle(Graphic2d_Text) text;
1911   
1912   gp_Pnt2d startPoint(location.X() + length/4, location.Y() + length/2);
1913   gp_Pnt2d leftTopPoint(location.X() - length/4, location.Y() + length/2);
1914   gp_Pnt2d btCenPoint(location.X(), location.Y());
1915   gp_Pnt2d rightTopPoint(location.X() + length/2, location.Y() + length);
1916                                 
1917   gp_Trsf2d trsf;
1918   trsf.SetRotation(location, angle*M_PI/180);
1919   
1920   startPoint.Transform(trsf);
1921   leftTopPoint.Transform(trsf);
1922   btCenPoint.Transform(trsf);
1923   rightTopPoint.Transform(trsf);
1924   
1925   Graphic2d_Array1OfVertex vertex_arr(1, 4);
1926   vertex_arr.SetValue( 1, Graphic2d_Vertex(startPoint.X(), startPoint.Y()));
1927   vertex_arr.SetValue( 2, Graphic2d_Vertex(leftTopPoint.X(), leftTopPoint.Y()));
1928   vertex_arr.SetValue( 3, Graphic2d_Vertex(btCenPoint.X(), btCenPoint.Y()));
1929   vertex_arr.SetValue( 4, Graphic2d_Vertex(rightTopPoint.X(), rightTopPoint.Y()));
1930   
1931   symbol = new Graphic2d_Polyline(aIO, vertex_arr);
1932   TheAIS2DContext()->Display(aIO, Standard_True);
1933   return 0;
1934 }
1935 static int drawBezierCurve( Draw_Interpretor& , Standard_Integer argc, const char** argv )
1936 {
1937   if( argc < 1 )
1938   {
1939     cout << argv[0] << " Syntaxe error" << endl;
1940     return 1;
1941   }
1942   
1943   if (Viewer2dTest::CurrentView().IsNull())
1944   { 
1945     cout << "2D AIS Viewer Initialization ..." << endl;
1946     Viewer2dTest::ViewerInit(); 
1947     cout << "Done" << endl;
1948   }
1949
1950   Handle(AIS2D_InteractiveObject) aIO = new AIS2D_InteractiveObject();
1951   
1952   TColgp_Array1OfPnt2d ptarr(1, 5);
1953   gp_Pnt2d p1(24, 24);  
1954   gp_Pnt2d p2(-48, 42);  
1955   gp_Pnt2d p3(80, 82);  
1956   gp_Pnt2d p4(240, -24);  
1957   gp_Pnt2d p5(-24, -84);  
1958   
1959   ptarr.SetValue( 1, p1);
1960   ptarr.SetValue( 2, p2);
1961   ptarr.SetValue( 3, p3);
1962   ptarr.SetValue( 4, p4);
1963   ptarr.SetValue( 5, p5);
1964   
1965   Handle(Geom2d_BezierCurve) bezierCurve = 
1966     new Geom2d_BezierCurve(ptarr);
1967   Handle_GGraphic2d_Curve grCurve = new GGraphic2d_Curve(aIO, bezierCurve);
1968   TheAIS2DContext()->Display(aIO, Standard_True);
1969   return 0;
1970 }
1971
1972
1973 static int draw2DCurve( Draw_Interpretor& , Standard_Integer argc, const char** argv )
1974 {
1975   if( argc < 1 )
1976   {
1977     cout << argv[0] << " Syntaxe error" << endl;
1978     return 1;
1979   }
1980   
1981   if (Viewer2dTest::CurrentView().IsNull())
1982   { 
1983     cout << "2D AIS Viewer Initialization ..." << endl;
1984     Viewer2dTest::ViewerInit(); 
1985     cout << "Done" << endl;
1986   }
1987
1988   Handle(AIS2D_InteractiveObject) aIO = new AIS2D_InteractiveObject();
1989   Handle(Geom2d_Curve) aCurve = DrawTrSurf::GetCurve2d(argv[2]);
1990   Handle(GGraphic2d_Curve) grCurve = new GGraphic2d_Curve(aIO, aCurve);
1991   
1992   GetMapOfAIS2D().Bind(aIO, argv[1]);                                                     
1993   TheAIS2DContext()->Display(aIO, Standard_True);
1994   TheAIS2DContext()->UpdateCurrentViewer();
1995   return 0;
1996 }
1997
1998 static int v2dtransform( Draw_Interpretor& , Standard_Integer argc, const char** argv )
1999 {
2000   if( argc < 7 )
2001   {
2002     cout << argv[0] << " Syntaxe error" << endl;
2003     return 1;
2004   }
2005   
2006   if (Viewer2dTest::CurrentView().IsNull())
2007   { 
2008     cout << "2D AIS Viewer Initialization ..." << endl;
2009     Viewer2dTest::ViewerInit(); 
2010     cout << "Done" << endl;
2011   }
2012   
2013   if(!GetMapOfAIS2D().IsBound2(argv[1])) {
2014     cout<<"Object not found"<<endl;
2015     return 0;
2016   }
2017   
2018   Handle(AIS2D_InteractiveObject) aIO = GetMapOfAIS2D().Find2(argv[1]);
2019   gp_Trsf2d aTrans, aT1,aT2;
2020   gp_Pnt2d aP(atof(argv[2]),atof(argv[3]));
2021   Standard_Real anAngle = atof(argv[4]);
2022   gp_Pnt2d aP2(atof(argv[5]),atof(argv[6]));
2023   aT1.SetRotation(aP,anAngle);
2024   aT2.SetTranslation(aP2.XY());
2025   aTrans = aT1*aT2;
2026   
2027   aIO->SetTransform(gp_GTrsf2d(aTrans));
2028   TheAIS2DContext()->UpdateCurrentViewer();
2029   return 0;  
2030 }
2031
2032 static int v2dsetstyle( Draw_Interpretor& , Standard_Integer argc, const char** argv )
2033 {
2034   if( argc < 3 )
2035   {
2036     cout << argv[0] << " Syntaxe error" << endl;
2037     return 1;
2038   }
2039   
2040   if (Viewer2dTest::CurrentView().IsNull())
2041   { 
2042     cout << "2D AIS Viewer Initialization ..." << endl;
2043     Viewer2dTest::ViewerInit(); 
2044     cout << "Done" << endl;
2045   }
2046   
2047   if(!GetMapOfAIS2D().IsBound2(argv[1])) {
2048     cout<<"Object not found"<<endl;
2049     return 0;
2050   }
2051   
2052   Handle(AIS2D_InteractiveObject) aIO = GetMapOfAIS2D().Find2(argv[1]);
2053   
2054   Handle(Graphic2d_Primitive) grPrim = aIO->Primitive(1);
2055   if(aIO->HasAspect(grPrim)) {
2056     Handle(Prs2d_AspectRoot) aspRoot = aIO->GetAspect(grPrim);
2057     if(!aspRoot.IsNull() && aspRoot->GetAspectName() == Prs2d_AN_LINE) {
2058       Handle(Prs2d_AspectLine) aspLine = Handle(Prs2d_AspectLine)::DownCast(aspRoot);
2059       aspLine->SetType(Aspect_TypeOfLine(atoi(argv[2])));
2060     }   
2061   }
2062   
2063   TheAIS2DContext()->UpdateCurrentViewer();
2064   return 0;  
2065 }
2066
2067
2068
2069 static int v2dtest1 (Draw_Interpretor& , Standard_Integer argc, const char** argv)
2070 {
2071   
2072   if (Viewer2dTest::CurrentView().IsNull())
2073   { 
2074     cout << "2D AIS Viewer Initialization ..." << endl;
2075     Viewer2dTest::ViewerInit(); 
2076     cout << "Done" << endl;
2077   }
2078   
2079   Handle(AIS2D_InteractiveObject) aIO = new AIS2D_InteractiveObject();
2080   
2081   gp_Pnt2d firstPoint ( 911.84, 851.86);
2082   gp_Pnt2d newPoint (947.78, 847.375);
2083   
2084   Handle(Prs2d_Length) theLength;
2085   theLength = new Prs2d_Length( aIO, firstPoint, newPoint,"     -0.2", 3, 2, 
2086                                Prs2d_TypeOfDist(Prs2d_TOD_AUTOMATIC), 
2087                                20, 5, Prs2d_TypeOfArrow(Prs2d_TOA_FILLED), 
2088                                Prs2d_ArrowSide(Prs2d_AS_BOTHAR), Standard_True);
2089   
2090   TheAIS2DContext()->Display(aIO, Standard_True );
2091   
2092   
2093   aIO = new AIS2D_InteractiveObject();
2094   gp_Pnt2d pt1 ( 209.30, 1405.29 );
2095   gp_Pnt2d pt2 ( 409.3, 1396.79);
2096   gp_Pnt2d pt3 (209.3, 1205.278);
2097
2098   
2099   Handle(Prs2d_Angle) theAngle;
2100   theAngle = new Prs2d_Angle( aIO, pt1, pt2, pt3,100,"  ", 3, 20, 6, Prs2d_TypeOfArrow(Prs2d_TOA_FILLED),
2101                              Prs2d_ArrowSide(Prs2d_AS_BOTHAR), Standard_False);
2102   
2103   TheAIS2DContext()->Display(aIO, Standard_True );
2104   
2105   TheAIS2DContext()->UpdateCurrentViewer();
2106   return 0;  
2107 }
2108
2109 static int v2dtable (Draw_Interpretor& , Standard_Integer argc, const char** argv)
2110 {
2111  
2112   if( argc < 6 ) {
2113     cout << argv[0] << " Syntaxe error" << endl;
2114     return 1;
2115   }
2116   
2117   if (Viewer2dTest::CurrentView().IsNull())  { 
2118     cout << "2D AIS Viewer Initialization ..." << endl;
2119     Viewer2dTest::ViewerInit(); 
2120     cout << "Done" << endl;
2121   }
2122   
2123   Standard_Real x1 = 24, y1 = 24;
2124   Standard_Integer numberOfColumn = 1, numberOfRows = 1;
2125    
2126   if( argc >= 3 )
2127     x1 = atof( argv[2] );
2128   if( argc >= 4 )
2129     y1 = atof( argv[3] );
2130   if( argc >= 5 )
2131     numberOfColumn = atoi( argv[4] );
2132   if( argc >= 6 )
2133     numberOfRows = atoi( argv[5] );
2134   
2135   Handle(AIS2D_InteractiveObject) aisObj = new AIS2D_InteractiveObject();
2136
2137   Handle(GGraphic2d_SetOfCurves) setOfCurve = new GGraphic2d_SetOfCurves(aisObj);
2138
2139   gp_Pnt2d location(x1,y1);
2140   Standard_Real columnWidth = 100;
2141   Standard_Real rowHeight = 10;
2142   Standard_Integer i;
2143   
2144   Handle(Geom2d_Curve) trCur;
2145   
2146   for( i=0; i<=numberOfColumn; ++i) {
2147     GCE2d_MakeSegment segment(  gp_Pnt2d(location.X() + (columnWidth * i), location.Y()),
2148                                 gp_Pnt2d(location.X() + (columnWidth * i), location.Y() + (rowHeight * numberOfRows)) );
2149     
2150     trCur = segment.Value();
2151     setOfCurve->Add(trCur);
2152   }
2153
2154   for( i=0; i<=numberOfRows; ++i) {
2155     GCE2d_MakeSegment segment1( gp_Pnt2d(location.X(), location.Y() + (rowHeight * i)),
2156                                 gp_Pnt2d(location.X() + (numberOfColumn * columnWidth), location.Y() + (rowHeight * i)) );
2157     trCur = segment1.Value();
2158     setOfCurve->Add(trCur);
2159   }
2160
2161   Handle(Graphic2d_Text) text;
2162   Standard_Real locationX = (location.X() + (columnWidth / 2));
2163   Standard_Real locationY = (location.Y() + (rowHeight / 2));
2164   Handle(Prs2d_Point) point;
2165   
2166   Standard_Real text_scale = 2.0;
2167   
2168   for(Standard_Integer j=0,  k=0; j<numberOfRows; ++j) {
2169     for( i=0; i<numberOfColumn; ++i) {
2170       
2171       TCollection_ExtendedString str("TableCell");
2172       str+=i;
2173       str+=" ";
2174       str+=k;
2175       
2176       Standard_Integer str_len = str.Length();
2177       
2178       Standard_Real textLength = str_len * text_scale * 1.8;
2179       Standard_Real textHight = text_scale * 1.6;
2180
2181       text = new Graphic2d_Text(aisObj, str, locationX + (columnWidth * i) - (textLength /2 ),
2182                                 locationY + (rowHeight * j ) - (textHight / 2),
2183                                 0, Aspect_TypeOfText(Aspect_TOT_SOLID), text_scale);
2184       ++k;
2185     }
2186   }
2187   
2188   GetMapOfAIS2D().Bind(aisObj, argv[1]);
2189   TheAIS2DContext()->Display(aisObj, Standard_True );
2190   TheAIS2DContext()->UpdateCurrentViewer();
2191   return 0;
2192 }
2193
2194
2195
2196 static int drawEllipse( Draw_Interpretor& , Standard_Integer argc, const char** argv )
2197 {
2198   if( argc < 1 )
2199   {
2200     cout << argv[0] << " Syntaxe error" << endl;
2201     return 1;
2202   }
2203   
2204   if (Viewer2dTest::CurrentView().IsNull())
2205   { 
2206     cout << "2D AIS Viewer Initialization ..." << endl;
2207     Viewer2dTest::ViewerInit(); 
2208     cout << "Done" << endl;
2209   }
2210
2211   Handle(AIS2D_InteractiveObject) aIO = new AIS2D_InteractiveObject();
2212   Handle(Geom2d_Ellipse) ellipse ;
2213   gp_Ax2d axis(gp_Pnt2d(24, 42), gp_Dir2d(1, 0));
2214   ellipse = new Geom2d_Ellipse(axis, 420, 240, Standard_True);
2215   Handle_GGraphic2d_Curve grCurve = new GGraphic2d_Curve(aIO, ellipse);
2216   TheAIS2DContext()->Display(aIO, Standard_True);
2217   return 0;
2218 }
2219
2220 static int drawLengthDim( Draw_Interpretor& , Standard_Integer argc, const char** argv )
2221 {
2222   if( argc < 1 )
2223   {
2224     cout << argv[0] << " Syntaxe error" << endl;
2225     return 1;
2226   }
2227   
2228
2229   int distance_type = 0; 
2230   if (argc >= 2) {
2231     distance_type = atoi(argv[1]);
2232   }
2233   
2234   if (Viewer2dTest::CurrentView().IsNull())
2235   { 
2236     cout << "2D AIS Viewer Initialization ..." << endl;
2237     Viewer2dTest::ViewerInit(); 
2238     cout << "Done" << endl;
2239   }
2240
2241   gp_Pnt2d FirstPt(0, 0);
2242   gp_Pnt2d LastPt(240, 240);
2243   
2244   double text_scale = 5;
2245   double length = 100; 
2246   double arrow_angle = 24;
2247   double arrow_length = 24;
2248   int arrow_type = 2;
2249   int arrow_side = 3;
2250   Standard_Boolean isReverse = Standard_True;
2251   
2252   double distance = FirstPt.Distance(LastPt);
2253   
2254   char str_[10];
2255   sprintf(str_, "%.2f", distance);
2256   
2257   TCollection_ExtendedString str(str_);
2258   
2259   Handle(Prs2d_Length) theLength;                       
2260   Handle(AIS2D_InteractiveObject) aIO = new AIS2D_InteractiveObject();
2261   
2262   theLength = 
2263     new Prs2d_Length(aIO, FirstPt, LastPt, 
2264                      str, text_scale, length, Prs2d_TypeOfDist(distance_type), 
2265                      arrow_angle, arrow_length, Prs2d_TypeOfArrow(arrow_type), 
2266                      Prs2d_ArrowSide(arrow_side), isReverse);
2267   
2268   theLength->SetTextRelPos(.5, .5);
2269   
2270   TheAIS2DContext()->Display(aIO, Standard_True);
2271   TheAIS2DContext()->UpdateCurrentViewer();
2272   return 0;
2273 }
2274
2275 static int drawLengthDim1( Draw_Interpretor& , Standard_Integer argc, const char** argv )
2276 {
2277   if( argc < 1 )
2278   {
2279     cout << argv[0] << " Syntaxe error" << endl;
2280     return 1;
2281   }
2282   
2283   if (Viewer2dTest::CurrentView().IsNull())
2284   { 
2285     cout << "2D AIS Viewer Initialization ..." << endl;
2286     Viewer2dTest::ViewerInit(); 
2287     cout << "Done" << endl;
2288   }
2289
2290   gp_Pnt2d FirstPt(0, 0);
2291   gp_Pnt2d LastPt(2, 2);
2292   
2293   gp_Lin2d aL1(FirstPt,gp_Dir2d(0,1));
2294   gp_Lin2d aL2(LastPt,gp_Dir2d(0,1));
2295   
2296   double text_scale = 15;
2297   double length = 0; 
2298   //int distance_type = 0; 
2299   //double arrow_angle = 24;
2300   //double arrow_length = 24;
2301   //int arrow_type = 2;
2302   //int arrow_side = 3;
2303   
2304   double distance = FirstPt.Distance(LastPt);
2305   
2306   char str_[10];
2307   sprintf(str_, "%.2f", distance);
2308   
2309   TCollection_ExtendedString str(str_);
2310   
2311   Handle(Prs2d_Length) theLength;                       
2312   Handle(AIS2D_InteractiveObject) aIO = new AIS2D_InteractiveObject();
2313   
2314   
2315   theLength = 
2316     new Prs2d_Length(aIO, aL1, aL2, 
2317                      str, text_scale, length);
2318 //  theLength = 
2319 //    new Prs2d_Length(aIO, aL1, aL2, 
2320 //                     str, text_scale, length, arrow_angle,arrow_length,
2321 //                     Prs2d_TypeOfDist(distance_type), 
2322 //                     Prs2d_TypeOfArrow(arrow_type), 
2323 //                     Prs2d_ArrowSide(arrow_side), Standard_False);
2324   
2325   theLength->SetTextRelPos(.5, .5);
2326   
2327   TheAIS2DContext()->Display(aIO, Standard_True);
2328   TheAIS2DContext()->UpdateCurrentViewer();
2329   return 0;
2330 }
2331
2332
2333
2334 static int drawAngleDim( Draw_Interpretor& , Standard_Integer argc, const char** argv )
2335 {
2336   if( argc < 1 )
2337   {
2338     cout << argv[0] << " Syntaxe error" << endl;
2339     return 1;
2340   }
2341   Standard_Boolean isReverse = Standard_False;
2342
2343   if( argc >= 1 )
2344     isReverse = atoi(argv[1]);
2345   
2346   if (Viewer2dTest::CurrentView().IsNull())
2347   { 
2348     cout << "2D AIS Viewer Initialization ..." << endl;
2349     Viewer2dTest::ViewerInit(); 
2350     cout << "Done" << endl;
2351   }
2352
2353   gp_Pnt2d anAp1(0, 0);
2354   gp_Pnt2d anAp2(240, 240);
2355   gp_Pnt2d anAp3(0, 240);
2356   
2357   Quantity_Length aRadius = 100;
2358   TCollection_ExtendedString aText("Rad = 10%");
2359   
2360   Handle(Prs2d_Angle) theAngle;                 
2361   Handle(AIS2D_InteractiveObject) aIO = new AIS2D_InteractiveObject();
2362
2363   if(isReverse) {
2364     theAngle = new Prs2d_Angle(aIO, anAp1, anAp3, anAp2, aRadius, aText,1,10.,5.,Prs2d_TypeOfArrow(1),Prs2d_ArrowSide(2),isReverse);
2365   }
2366   else {
2367   theAngle = 
2368     new Prs2d_Angle(aIO, anAp1, anAp2, anAp3, aRadius, aText,1,10.,5.,Prs2d_TypeOfArrow(1),Prs2d_ArrowSide(2),isReverse);
2369   }
2370   
2371   theAngle->SetTextRelPos(.5, .5);
2372   
2373   TheAIS2DContext()->Display(aIO, Standard_True);
2374   TheAIS2DContext()->UpdateCurrentViewer();
2375   return 0;
2376 }  
2377
2378 static int drawRadiusDim( Draw_Interpretor& , Standard_Integer argc, const char** argv )
2379 {
2380   if( argc < 1 )
2381   {
2382     cout << argv[0] << " Syntaxe error" << endl;
2383     return 1;
2384   }
2385   Standard_Boolean isReverse = Standard_False;
2386
2387   if( argc >= 2 )
2388     isReverse = atoi(argv[1]);
2389   
2390   if (Viewer2dTest::CurrentView().IsNull())
2391   { 
2392     cout << "2D AIS Viewer Initialization ..." << endl;
2393     Viewer2dTest::ViewerInit(); 
2394     cout << "Done" << endl;
2395   }
2396
2397   gp_Pnt2d anAp1(0, 0);
2398   gp_Pnt2d anAp2(240, 240);
2399   gp_Circ2d aCirc(gp_Ax2d(anAp2,gp_Dir2d(0,1)),100.);
2400   
2401   TCollection_ExtendedString aText("Rad = 10%");
2402   
2403   Handle(Prs2d_Radius) theRadius;                       
2404   Handle(AIS2D_InteractiveObject) aIO = new AIS2D_InteractiveObject();
2405
2406   theRadius = new Prs2d_Radius(aIO, anAp1, aCirc,  aText,1,10.,5.,Prs2d_TypeOfArrow(1),Prs2d_AS_BOTHAR,isReverse);
2407   theRadius->SetTextRelPos(.5, .5);
2408   
2409   TheAIS2DContext()->Display(aIO, Standard_True);
2410   TheAIS2DContext()->UpdateCurrentViewer();
2411   return 0;
2412 }  
2413
2414
2415 static int drawSymbDim( Draw_Interpretor& , Standard_Integer argc, const char** argv )
2416 {
2417   if( argc < 1 )
2418   {
2419     cout << argv[0] << " Syntaxe error" << endl;
2420     return 1;
2421   }
2422   
2423   if (Viewer2dTest::CurrentView().IsNull())
2424   { 
2425     cout << "2D AIS Viewer Initialization ..." << endl;
2426     Viewer2dTest::ViewerInit(); 
2427     cout << "Done" << endl;
2428   }
2429
2430   gp_Pnt2d anAp1(0, 0);
2431   gp_Pnt2d anAp2(240, 240);
2432   gp_Circ2d aCirc(gp_Ax2d(anAp2,gp_Dir2d(0,1)),100.);
2433   
2434   TCollection_ExtendedString aText("Rad = 10%");
2435   
2436   Handle(AIS2D_InteractiveObject) aIO = new AIS2D_InteractiveObject();
2437   Handle(Prs2d_Circularity) symbol;
2438   
2439   Standard_Real length = 100;
2440   Standard_Real angle = 270;
2441   symbol = new Prs2d_Circularity( aIO, anAp2.X(), anAp2.Y(), length, angle);
2442
2443   
2444   TheAIS2DContext()->Display(aIO, Standard_True);
2445   
2446   aIO = new AIS2D_InteractiveObject();
2447   Handle(Prs2d_Parallelism) symbol1;
2448   symbol1 = new Prs2d_Parallelism( aIO, anAp2.X()+10, anAp2.Y()+10, length, angle); 
2449   TheAIS2DContext()->Display(aIO, Standard_True);
2450   
2451   TheAIS2DContext()->UpdateCurrentViewer();
2452   return 0;
2453 }  
2454
2455
2456 static int drawDiameter( Draw_Interpretor& , Standard_Integer argc, const char** argv )
2457 {
2458   if( argc < 2 )
2459   {
2460     cout << argv[0] << " Syntaxe error" << endl;
2461     return 1;
2462   }
2463   
2464   if (Viewer2dTest::CurrentView().IsNull())
2465   { 
2466     cout << "2D AIS Viewer Initialization ..." << endl;
2467     Viewer2dTest::ViewerInit(); 
2468     cout << "Done" << endl;
2469   }
2470
2471   Standard_Real aRadius = 240.;
2472   aRadius = atof( argv[1] );
2473
2474   Standard_Real aX = 0., aY = 0.;
2475   
2476   if( argc >= 3 )
2477     aX = atof( argv[2] );
2478   if( argc >= 4 )
2479     aY = atof( argv[3] );
2480     
2481   gp_Pnt2d cirLoc( aX, aY );
2482
2483   Handle(AIS2D_InteractiveObject) aIO = new AIS2D_InteractiveObject();
2484   gp_Dir2d xdir(1.0,0.0);
2485   gp_Dir2d ydir(0.0,1.0);
2486   gp_Ax22d ax2d(cirLoc, xdir, ydir);
2487   
2488   
2489   gp_Pnt2d attachPt(cirLoc.X()+aRadius, cirLoc.Y());
2490   gp_Trsf2d trsf;
2491   trsf.SetRotation(cirLoc, (3.142/180)*-60);
2492   attachPt.Transform(trsf);
2493   gp_Circ2d aCircle(ax2d, aRadius);
2494   Handle(Graphic2d_Circle) theCircle = new Graphic2d_Circle( aIO, 0., 0.,aRadius);
2495   Handle(Prs2d_Diameter) theDiam =
2496     new Prs2d_Diameter(aIO, attachPt, aCircle, TCollection_ExtendedString( aRadius*2. ), 
2497                        24.0, 24.0, 24.0, Prs2d_TOA_CLOSED, Prs2d_AS_BOTHAR, Standard_False);
2498   theDiam->DrawSymbol(Standard_True); 
2499   theDiam->SetSymbolCode(233);
2500   
2501   TheAIS2DContext()->Display(aIO, Standard_True);
2502   TheAIS2DContext()->UpdateCurrentViewer();
2503   
2504   return 0;
2505 }
2506
2507 static int NbAllObjects (Draw_Interpretor& , Standard_Integer argc, const char** argv)
2508 {
2509   if (argc > 1)  {
2510     cout << argv[0] << " Syntaxe error" << endl;
2511     return 1;
2512   }
2513
2514   if (Viewer2dTest::CurrentView().IsNull()) return 1;
2515   
2516   AIS2D_ListOfIO aListObj;
2517   TheAIS2DContext()->DisplayedObjects( aListObj );
2518   int aNb = aListObj.Extent();
2519
2520   cout << " Number all objects = " << aNb << endl;
2521   return 0;
2522 }
2523
2524
2525
2526 //==============================================================================
2527 //function : Viewer2dTest::Commands
2528 //purpose  : Add all the viewer command in the Draw_Interpretor
2529 //==============================================================================
2530 void Viewer2dTest::DisplayCommands (Draw_Interpretor& theCommands)
2531 {
2532   const char *group = "2D AIS Viewer - Display Commands";
2533
2534   theCommands.Add("v2ddisplay",
2535                   "v2ddisplay name [projection(Origin(x y z) Normal(dx dy dz) DX(dx dy dz)]",
2536                   __FILE__, V2dDisplay, group);
2537
2538   theCommands.Add("v2derase",
2539                   "v2derase [name1] ...  [name n]",
2540                   __FILE__, V2dErase, group);
2541
2542   theCommands.Add("v2ddonly",
2543                   "v2ddonly [name1] ...  [name n]",
2544                   __FILE__, V2dDonly, group);
2545
2546   theCommands.Add("v2ddisplayall",
2547                   "v2ddisplayall",
2548                   __FILE__, V2dDisplayAll, group);
2549
2550   theCommands.Add("v2deraseall",
2551                   "v2deraseall",
2552                   __FILE__, V2dEraseAll, group);
2553
2554 //  theCommands.Add("v2derasetype",
2555 //                "v2derasetype <Type> : erase all the displayed objects of one given kind (see vtypes)",
2556 //                __FILE__, V2dEraseType, group);
2557
2558 //  theCommands.Add("v2ddisplaytype",
2559 //                "v2ddisplaytype <Type> <Signature> : display all the objects of one given kind (see vtypes) which are stored the AIS2DContext",
2560 //                __FILE__, V2dDisplayType, group);
2561   
2562 /*
2563   theCommands.Add("v2ddisplaymode",
2564                   "v2ddispmode [name] mode(1,2,..) : no name -> on selected objects",
2565                   __FILE__, V2dDispMode, group);
2566
2567   theCommands.Add("v2derasemode",
2568                   "v2derasemode [name] mode(1,2,..) : no name -> on selected objects",
2569                   __FILE__, V2dDispMode, group);
2570
2571   theCommands.Add("v2dsetdispmode",
2572                   "v2dsetdispmode [name] mode(1,2,..) : no name -> on selected objects",
2573                   __FILE__, V2dDispMode, group);
2574
2575   theCommands.Add("v2dunsetdispmode",
2576                   "v2dunsetdispmode [name] mode(1,2,..) : no name -> on selected objects",
2577                   __FILE__, V2dDispMode, group);
2578 */
2579   theCommands.Add("v2dsetcolor",
2580                   "v2dsetcolor [name of shape] ColorName",
2581                   __FILE__, V2dColor, group);
2582
2583   theCommands.Add("v2dunsetcolor",
2584                   "v2dunsetcolor [name of shape]",
2585                   __FILE__, V2dColor, group);
2586
2587   theCommands.Add("v2dsetbgcolor",
2588                   "v2dsetbgcolor colorname       : Change background color",
2589                   __FILE__, V2dSetBGColor, group);
2590
2591  /*
2592  theCommands.Add("v2dsettransparency",
2593                   "v2dsettransparency [name of shape] TransparencyCoef(0 -> 1)",
2594                   __FILE__, V2dTransparency, group);
2595
2596   theCommands.Add("v2dunsettransparency",
2597                   "v2dunsettransparency [name of shape]",
2598                   __FILE__, V2dTransparency, group);
2599
2600   theCommands.Add("v2dsetmaterial",
2601                   "v2dsetmaterial [name of shape] MaterialName",
2602                   __FILE__, V2dMaterial, group);
2603
2604   theCommands.Add("v2dunsetmaterial",
2605                   "v2dunsetmaterial [name of shape]",
2606                   __FILE__, V2dMaterial, group);
2607 */
2608   theCommands.Add("v2dsetwidth",
2609                   "v2dsetwidth [name_of_shape] width(THIN, MEDIUM, THICK, VERYTHICK)",
2610                   __FILE__, V2dWidth, group);
2611
2612   theCommands.Add("v2dunsetwidth",
2613                   "v2dunsetwidth [name of shape]",
2614                   __FILE__, V2dWidth, group);
2615 /*
2616   theCommands.Add("v2dsetshading",
2617                   "v2dsetshading name Quality(default=0.0008)",
2618                   __FILE__, V2dShading, group);
2619
2620   theCommands.Add("v2dunsetshading",
2621                   "v2dunsetshading name",
2622                   __FILE__, V2dShading, group);
2623 */
2624 /*  theCommands.Add("v2dtexture",
2625                   "'v2dtexture NameOfShape TextureFile' \n \
2626                   or 'vtexture NameOfShape' if you want to disable texture mapping \n \
2627                   or 'vtexture NameOfShape ?' to list available textures\n \
2628                   or 'vtexture NameOfShape IdOfTexture' (0<=IdOfTexture<=20)' to use predefined textures\n",
2629                   __FILE__, VTexture, group);*/
2630   
2631   //Additional commands for primitives
2632   theCommands.Add("v2dsetlinetype",
2633                   "v2dsetlinetype [name of shape] LineType(SOLID, DASH, DOT, DOTDASH )",
2634                   __FILE__, V2dTypeOfLine, group);
2635
2636   theCommands.Add("v2dunsetlinetype",
2637                   "v2dunsetlinetype [name of shape]",
2638                   __FILE__, V2dTypeOfLine, group);
2639
2640   
2641   theCommands.Add("v2dpoint",
2642                   "v2dpoint [x y marker_type( 0(TOM_POINT),\n \
2643                                         1(TOM_PLUS),\n \
2644                                         2(TOM_STAR),\n \
2645                                         3(TOM_O),\n \
2646                                         4(TOM_X),\n \
2647                                         5(TOM_O_POINT),\n \
2648                                         6(TOM_O_PLUS),\n \
2649                                         7(TOM_O_STAR),\n \
2650                                         8(TOM_O_X) )]",
2651                   __FILE__, drawPoint, group);
2652   
2653   theCommands.Add("v2ddrawaxis",
2654                   "v2ddrawaxis[loc_x loc_y dir_x dir_y]",
2655                   __FILE__, drawAxis, group);
2656   
2657   theCommands.Add("v2dline",
2658                   "v2dline [ x y dir_x dir_y ]",
2659                   __FILE__, drawLine, group);
2660   
2661   theCommands.Add("v2dsegment",
2662                   "v2dsegment [ x1 y1 x2 y2 ]",
2663                   __FILE__, drawSegment, group);
2664
2665   theCommands.Add("v2darrow",
2666                   "v2ddrawArrowLine name [ x1 y1 x2 y2 ]",
2667                   __FILE__, drawArrowLine, group);
2668
2669   theCommands.Add("v2ddrawArc",
2670                   "v2ddrawArc [ x1 y1 x2 y2 x3 y3]",
2671                   __FILE__, drawArc, group);
2672   
2673   theCommands.Add("v2dFinishSymbol",
2674                   "v2dFinishSymbol",
2675                   __FILE__, drawFinishSymbol, group);
2676   
2677   theCommands.Add("v2dBezierCurve",
2678                   "v2dBezierCurve",
2679                   __FILE__, drawBezierCurve, group);
2680   
2681   theCommands.Add("v2dEllipse",
2682                   "v2dEllipse",
2683                   __FILE__, drawEllipse, group);
2684     
2685   theCommands.Add("v2daistext",
2686                   "v2daistext atextname text_str x1 y1 [angle scale]",
2687                   __FILE__, draw2DText, group);
2688
2689   theCommands.Add("v2dtoleranceframe",
2690                   "v2dtoleranceframe [ height loc_x loc_y tol_type( 0(Prs2d_TOT_TAPER),\n \
2691                                                                     1(Prs2d_TOT_SYMTOTAL),\n \
2692                                                                     2(Prs2d_TOT_SYMCIRCULAR),\n \
2693                                                                     3(Prs2d_TOT_SYMMETRY),\n \
2694                                                                     4(Prs2d_TOT_CONCENTRIC),\n \
2695                                                                     5(Prs2d_TOT_POSITION),\n \
2696                                                                     6(Prs2d_TOT_ANGULARITY),\n \
2697                                                                     7(Prs2d_TOT_PERPENDIC),\n \
2698                                                                     8(Prs2d_TOT_PARALLELISM),\n \
2699                                                                     9(Prs2d_TOT_SURFACEPROF),\n \
2700                                                                     10(Prs2d_TOT_LINEPROF),\n \
2701                                                                     11(Prs2d_TOT_CYLINDRIC),\n \
2702                                                                     12(Prs2d_TOT_CIRCULARITY),\n \
2703                                                                     13(Prs2d_TOT_FLATNESS),\n \
2704                                                                     14(Prs2d_TOT_STRAIGHTNESS) )]",
2705                   __FILE__, drawToleanceFrame, group);
2706
2707   theCommands.Add("v2dlengthdim",
2708                   "v2dlengthdim ",
2709                   __FILE__, drawLengthDim, group);
2710   
2711   theCommands.Add("v2dangledim",
2712                   "v2dangledim",
2713                   __FILE__, drawAngleDim, group);
2714   
2715   theCommands.Add("v2dradiusdim",
2716                   "v2dradiusdim",
2717                   __FILE__, drawRadiusDim, group);
2718   
2719   theCommands.Add("v2dsymbols",
2720                   "v2dsymbols",
2721                   __FILE__, drawSymbDim, group);
2722   
2723
2724   
2725   theCommands.Add("v2dlen1",
2726                   "v2dlengthdim ",
2727                   __FILE__, drawLengthDim1, group);
2728
2729
2730   theCommands.Add("v2ddiameter",
2731                   "v2ddiameter radius [ circle_x_coord  circle_y_coord ]",
2732                   __FILE__, drawDiameter, group);
2733   
2734   theCommands.Add("v2dcurve",
2735                   "v2dcurve name name",
2736                   __FILE__,draw2DCurve, group);
2737   
2738   theCommands.Add("v2dtransform",
2739                   "v2dtransform name a11 a12 a21 a22 s1 s2",
2740                   __FILE__, v2dtransform, group);
2741   
2742   theCommands.Add("v2dtable",
2743                   "v2dtable name xSt ySt nbR nbC",
2744                   __FILE__, v2dtable, group);
2745   
2746   theCommands.Add("v2dsetsyle",
2747                   "v2dsetsyle name style",
2748                    __FILE__, v2dsetstyle, group);
2749   
2750   theCommands.Add("v2dtest1",
2751                   "v2dtest1",
2752                    __FILE__, v2dtest1, group);
2753
2754
2755   theCommands.Add("v2dcount",
2756                   "v2dcount",
2757                   __FILE__, NbAllObjects, group);
2758 }
2759