0022898: IGES import fails in german environment
[occt.git] / src / DrawTrSurf / DrawTrSurf.cxx
1 // Created on: 1993-08-12
2 // Created by: Bruno DUMORTIER
3 // Copyright (c) 1993-1999 Matra Datavision
4 // Copyright (c) 1999-2012 OPEN CASCADE SAS
5 //
6 // The content of this file is subject to the Open CASCADE Technology Public
7 // License Version 6.5 (the "License"). You may not use the content of this file
8 // except in compliance with the License. Please obtain a copy of the License
9 // at http://www.opencascade.org and read it completely before using this file.
10 //
11 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
12 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
13 //
14 // The Original Code and all software distributed under the License is
15 // distributed on an "AS IS" basis, without warranty of any kind, and the
16 // Initial Developer hereby disclaims all such warranties, including without
17 // limitation, any warranties of merchantability, fitness for a particular
18 // purpose or non-infringement. Please see the License for the specific terms
19 // and conditions governing the rights and limitations under the License.
20
21
22 #ifdef HAVE_CONFIG_H
23 # include <config.h>
24 #endif
25
26 #ifdef HAVE_IOS
27 # include <ios>
28 #elif defined(HAVE_IOS_H)
29 # include <ios.h>
30 #endif
31
32 #ifdef HAVE_STRINGS_H
33 # include <strings.h>
34 #endif
35
36 #include <Standard_Stream.hxx>
37
38 #include <Draw_Color.hxx>
39 #include <DrawTrSurf.ixx>
40 #include <DrawTrSurf_Point.hxx>
41 #include <DrawTrSurf_BezierSurface.hxx>
42 #include <DrawTrSurf_BSplineSurface.hxx>
43 #include <DrawTrSurf_BezierCurve.hxx>
44 #include <DrawTrSurf_BSplineCurve.hxx>
45 #include <DrawTrSurf_BezierCurve2d.hxx>
46 #include <DrawTrSurf_BSplineCurve2d.hxx>
47 #include <DrawTrSurf_Triangulation.hxx>
48 #include <DrawTrSurf_Polygon3D.hxx>
49 #include <DrawTrSurf_Polygon2D.hxx>
50 #include <Draw_Appli.hxx>
51 #include <Draw.hxx>
52
53 #include <GeomTools_CurveSet.hxx>
54 #include <GeomTools_Curve2dSet.hxx>
55 #include <GeomTools_SurfaceSet.hxx>
56
57 #include <gp_Pln.hxx>
58 #include <gp_Ax2d.hxx>
59 #include <gp_Ax2.hxx>
60 #include <gp_Trsf2d.hxx>
61 #include <Poly.hxx>
62 #include <TCollection_AsciiString.hxx>
63
64 static Draw_Color       PntColor(Draw_rouge);
65 static Draw_Color       CurvColor(Draw_jaune);
66 static Draw_Color       BoundsColor(Draw_vert);
67 static Draw_Color       IsosColor(Draw_bleu);
68 static Draw_Color       PolesColor(Draw_rouge);
69 static Draw_Color       KnotsColor(Draw_violet);
70
71 static Draw_MarkerShape PntShape   = Draw_Plus;
72 static Draw_MarkerShape KnotsShape = Draw_Losange;
73 static Standard_Boolean ShowPoles  = Standard_True;
74 static Standard_Boolean ShowKnots  = Standard_True;
75 static Standard_Boolean knotsIsos  =Standard_True;
76 static Standard_Real    Deflection = 0.01;
77 static Standard_Integer KnotsSize  = 5;
78 static Standard_Integer Discret    = 30;
79 static Standard_Integer DrawMode   = 0;
80 static Standard_Integer NbUIsos    = 10;
81 static Standard_Integer NbVIsos    = 10;
82
83 static TCollection_AsciiString ColorsHint(
84 "The possible colors are: \n\
85   white, red, green, blue, cyan,\n\
86   golden, magenta, brown, orange, pink,\n\
87   salmon, violet, yellow, darkgreen, coral");
88
89 static TCollection_AsciiString MarkersHint(
90 "The possible markers are: \n\
91   square, diamond, x, plus, circle, circle_zoom");
92
93 //=======================================================================
94 //function : DrawTrSurf_CurveColor
95 //purpose  : Sets new color for rendering of curves. Returns the
96 //           previous one to keep possibility to restore the initial
97 //           state
98 //=======================================================================
99
100 Standard_EXPORT Draw_Color DrawTrSurf_CurveColor(const Draw_Color col)
101 {
102   Draw_Color c = CurvColor;
103   CurvColor = col;
104   return c;
105 }
106
107 //=======================================================================
108 //function : DrawTrSurf_PointColor
109 //purpose  : Sets new color for rendering of points. Returns the
110 //           previous one to keep possibility to restore the initial
111 //           state
112 //=======================================================================
113
114 Standard_EXPORT Draw_Color DrawTrSurf_PointColor(const Draw_Color col)
115 {
116   Draw_Color c = PntColor;
117   PntColor = col;
118   return c;
119 }
120
121 //=======================================================================
122 //function : DrawTrSurf_PointMarker
123 //purpose  : Sets new marker for rendering of points. Returns the
124 //           previous one to keep possibility to restore the initial
125 //           state
126 //=======================================================================
127
128 Standard_EXPORT Draw_MarkerShape DrawTrSurf_PointMarker(const Draw_MarkerShape marker)
129 {
130   Draw_MarkerShape prev = PntShape;
131   PntShape = marker;
132   return prev;
133 }
134
135 //=======================================================================
136 //function : GetDrawable
137 //purpose  : 
138 //=======================================================================
139 static Handle(DrawTrSurf_Drawable) GetDrawable(Standard_CString& Name)
140 {
141   Handle(Draw_Drawable3D) D = Draw::Get(Name);
142   Handle(DrawTrSurf_Drawable) Dr;
143   if (!D.IsNull()) 
144     Dr = Handle(DrawTrSurf_Drawable)::DownCast(D);
145   return Dr;
146 }
147
148 //=======================================================================
149 //function : GetSurface
150 //purpose  : 
151 //=======================================================================
152 static Handle(DrawTrSurf_Surface) GetSurface(Standard_CString& Name)
153 {
154   Handle(Draw_Drawable3D) D = Draw::Get(Name);
155   Handle(DrawTrSurf_Surface) Dr;
156   if (!D.IsNull()) 
157     Dr = Handle(DrawTrSurf_Surface)::DownCast(D);
158   return Dr;
159 }
160
161 //=======================================================================
162 //function : GetBezierSurface
163 //purpose  : 
164 //=======================================================================
165 static Handle(DrawTrSurf_BezierSurface) GetBezierSurface(Standard_CString& Name)
166 {
167   Handle(Draw_Drawable3D) D = Draw::Get(Name);
168   Handle(DrawTrSurf_BezierSurface) Dr;
169   if (!D.IsNull()) 
170     Dr = Handle(DrawTrSurf_BezierSurface)::DownCast(D);
171   return Dr;
172 }
173
174 //=======================================================================
175 //function : GetBSplineSurface
176 //purpose  : 
177 //=======================================================================
178 static Handle(DrawTrSurf_BSplineSurface) GetBSplineSurface(Standard_CString& Name)
179 {
180   Handle(Draw_Drawable3D) D = Draw::Get(Name);
181   Handle(DrawTrSurf_BSplineSurface) Dr;
182   if (!D.IsNull()) 
183     Dr = Handle(DrawTrSurf_BSplineSurface)::DownCast(D);
184   return Dr;
185 }
186
187 #ifdef DEB
188 //=======================================================================
189 //function : GetCurve
190 //purpose  : 
191 //=======================================================================
192 static Handle(DrawTrSurf_Curve) GetCurve(Standard_CString& Name)
193 {
194   Handle(Draw_Drawable3D) D = Draw::Get(Name);
195   Handle(DrawTrSurf_Curve) Dr;
196   if (!D.IsNull()) 
197     Dr = Handle(DrawTrSurf_Curve)::DownCast(D);
198   return Dr;
199 }
200 #endif
201
202 //=======================================================================
203 //function : GetBezierCurve
204 //purpose  : 
205 //=======================================================================
206 static Handle(DrawTrSurf_BezierCurve) GetBezierCurve(Standard_CString& Name)
207 {
208   Handle(Draw_Drawable3D) D = Draw::Get(Name);
209   Handle(DrawTrSurf_BezierCurve) Dr;
210   if (!D.IsNull()) 
211     Dr = Handle(DrawTrSurf_BezierCurve)::DownCast(D);
212   return Dr;
213 }
214
215 //=======================================================================
216 //function : GetBSplineCurve
217 //purpose  : 
218 //=======================================================================
219 static Handle(DrawTrSurf_BSplineCurve) GetBSplineCurve(Standard_CString& Name)
220 {
221   Handle(Draw_Drawable3D) D = Draw::Get(Name);
222   Handle(DrawTrSurf_BSplineCurve) Dr;
223   if (!D.IsNull()) 
224     Dr = Handle(DrawTrSurf_BSplineCurve)::DownCast(D);
225   return Dr;
226 }
227
228 //=======================================================================
229 //function : GetBezierCurve2d
230 //purpose  : 
231 //=======================================================================
232 static Handle(DrawTrSurf_BezierCurve2d) GetBezierCurve2d(Standard_CString& Name)
233 {
234   Handle(Draw_Drawable3D) D = Draw::Get(Name);
235   Handle(DrawTrSurf_BezierCurve2d) Dr;
236   if (!D.IsNull()) 
237     Dr = Handle(DrawTrSurf_BezierCurve2d)::DownCast(D);
238   return Dr;
239 }
240
241 //=======================================================================
242 //function : GetBSplineCurve2d
243 //purpose  : 
244 //=======================================================================
245 static Handle(DrawTrSurf_BSplineCurve2d) GetBSplineCurve2d(Standard_CString& Name)
246 {
247   Handle(Draw_Drawable3D) D = Draw::Get(Name);
248   Handle(DrawTrSurf_BSplineCurve2d) Dr;
249   if (!D.IsNull()) 
250     Dr = Handle(DrawTrSurf_BSplineCurve2d)::DownCast(D);
251   return Dr;
252 }
253
254
255 //=======================================================================
256 //function : nbiso
257 //purpose  : 
258 //=======================================================================
259 static Standard_Integer nbiso (Draw_Interpretor& di, Standard_Integer n, const char** a)
260 {
261   if (n < 4) {
262     if (n == 3) {
263       NbUIsos = Draw::Atoi(a[1]);
264       NbVIsos = Draw::Atoi(a[2]);
265     }
266     di << NbUIsos << " " << NbVIsos;
267   }
268   else {
269     for (Standard_Integer i = 1; i < n - 2; i++) {
270       Handle(DrawTrSurf_Surface) DS = GetSurface(a[i]);
271       if (!DS.IsNull()) {
272         DS->ShowIsos(Draw::Atoi(a[n-2]),Draw::Atoi(a[n-1]));
273         Draw::Repaint();
274       }
275     }
276   }
277   return 0;
278 }
279
280 //=======================================================================
281 //function : drawpoles
282 //purpose  : 
283 //=======================================================================
284
285 static Standard_Integer drawpoles(Draw_Interpretor&, 
286                                   Standard_Integer n,
287                                   const char** a)
288 {
289   if ( n == 1) {
290     if ( !strcmp(a[0],"shpoles")) {
291       ShowPoles = Standard_True;
292     }
293     else if ( !strcmp(a[0],"clpoles")) {
294       ShowPoles = Standard_False;
295     }
296     else if ( !strcmp(a[0],"shknots")) {
297       ShowKnots = Standard_True;
298     }
299     else if ( !strcmp(a[0],"clknots")) {
300       ShowKnots = Standard_False;
301     }
302   }
303
304   if ( n<2) return 1;
305
306   Handle(DrawTrSurf_BezierSurface) BZS;
307   BZS = GetBezierSurface(a[1]);
308   if ( !BZS.IsNull()) {
309     if ( !strcmp(a[0],"shpoles")) {
310       BZS->ShowPoles();
311     }
312     else if ( !strcmp(a[0],"clpoles")) {
313       BZS->ClearPoles();
314     }
315     else {
316       return 1;
317     }
318   }
319   else {
320     Handle(DrawTrSurf_BSplineSurface) BSS = GetBSplineSurface(a[1]);
321     if ( !BSS.IsNull()) {
322       if ( !strcmp(a[0],"shpoles")) {
323         BSS->ShowPoles();
324       }
325       else if ( !strcmp(a[0],"clpoles")) {
326         BSS->ClearPoles();
327       }
328       else if ( !strcmp(a[0],"shknots")) {
329         BSS->ShowKnots();
330       }
331       else if ( !strcmp(a[0],"clknots")) {
332         BSS->ClearKnots();
333       }
334     }
335     else {
336       Handle(DrawTrSurf_BezierCurve) BZC = GetBezierCurve(a[1]);
337       if ( !BZC.IsNull()) {
338         if ( !strcmp(a[0],"shpoles")) {
339           BZC->ShowPoles();
340         }
341         else if ( !strcmp(a[0],"clpoles")) {
342           BZC->ClearPoles();
343         }
344         else {
345           return 1;
346         }
347       }
348       else {
349         Handle(DrawTrSurf_BSplineCurve) BSC = GetBSplineCurve(a[1]);
350         if ( !BSC.IsNull()) {
351           if ( !strcmp(a[0],"shpoles")) {
352             BSC->ShowPoles();
353           }
354           else if ( !strcmp(a[0],"clpoles")) {
355             BSC->ClearPoles();
356           }
357           else if ( !strcmp(a[0],"shknots")) {
358             BSC->ShowKnots();
359           }
360           else if ( !strcmp(a[0],"clknots")) {
361             BSC->ClearKnots();
362           }
363         }
364         else {
365           Handle(DrawTrSurf_BezierCurve2d) BZ2 = GetBezierCurve2d(a[1]);
366           if ( !BZ2.IsNull()) {
367             if ( !strcmp(a[0],"shpoles")) {
368               BZ2->ShowPoles();
369             }
370             else if ( !strcmp(a[0],"clpoles")) {
371               BZ2->ClearPoles();
372             }
373             else {
374               return 1;
375             }
376           }
377           else {
378             Handle(DrawTrSurf_BSplineCurve2d) BS2 = GetBSplineCurve2d(a[1]);
379             if ( !BS2.IsNull()) {
380               if ( !strcmp(a[0],"shpoles")) {
381                 BS2->ShowPoles();
382               }
383               else if ( !strcmp(a[0],"clpoles")) {
384                 BS2->ClearPoles();
385               }
386               else if ( !strcmp(a[0],"shknots")) {
387                 BS2->ShowKnots();
388               }
389               else if ( !strcmp(a[0],"clknots")) {
390                 BS2->ClearKnots();
391               }
392             }
393             else {
394               return 1;
395             }
396           }
397         }
398       }
399     }
400   }
401   Draw::Repaint();
402   return 0;
403 }
404
405 //=======================================================================
406 //function : draw
407 //purpose  : 
408 //=======================================================================
409
410 static Standard_Integer draw (Draw_Interpretor& di, Standard_Integer n, const char** a)
411 {
412   if (n <= 2) {
413         if (!strcmp(a[0],"dmode")) {
414           if (n == 2) {
415             Standard_Integer mod = 0;
416             if ((*a[n-1] == 'U')||(*a[n-1] == 'u')) mod = 1;
417             DrawMode = 1;
418           }
419           if (DrawMode)
420             di << "u";
421           else
422             di << "d";
423         }
424         
425         else if (!strcmp(a[0],"discr")) {
426           if (n == 2)
427             Discret = Draw::Atoi(a[n-1]);
428           di << Discret;
429         }
430         
431         else if (!strcmp(a[0],"defle")) {
432           if (n == 2)
433             Deflection = Draw::Atof(a[n-1]);
434           di << Deflection;
435         }
436   }
437   else {
438     for (Standard_Integer i = 1; i < n - 1; i++) {
439       Handle(DrawTrSurf_Drawable) D = GetDrawable(a[1]);
440       if (!D.IsNull()) {
441         if (!strcmp(a[0],"dmode")) {
442           Standard_Integer mod = 0;
443           if ((*a[n-1] == 'U')||(*a[n-1] == 'u')) mod = 1;
444           D->SetDrawMode(mod);
445         }
446         
447         else if (!strcmp(a[0],"discr")) {
448           D->SetDiscretisation(Draw::Atoi(a[n-1]));
449         }
450         
451         else if (!strcmp(a[0],"defle")) {
452           D->SetDeflection(Draw::Atof(a[n-1]));
453         }
454         
455         Draw::Repaint();
456       }
457     }
458   }
459   return 0;
460 }
461
462 //=======================================================================
463 //function : transform
464 //purpose  : 
465 //=======================================================================
466
467 static Standard_Integer transform (Draw_Interpretor& di, Standard_Integer n, const char** a)
468 {
469   if (n < 5) return 1;
470   gp_Trsf T;
471   Standard_Integer i,last = n-1;
472   if (!strcmp(a[0],"pscale")) {
473     Standard_Real s = Draw::Atof(a[last]);
474     last--;
475     if (last < 4) return 1;
476     gp_Pnt P(Draw::Atof(a[last-2]),Draw::Atof(a[last-1]),Draw::Atof(a[last]));
477     T.SetScale(P,s);
478   }
479   else if (!strcmp(a[0]+1,"mirror")) {
480     if (last < 4) return 1;
481     gp_Pnt P(Draw::Atof(a[last-2]),Draw::Atof(a[last-1]),Draw::Atof(a[last]));
482     if (*a[0] == 'p') {
483       T.SetMirror(P);
484     }
485     else {
486       last -= 3;
487       if (last < 4) return 1;
488       gp_Pnt O(Draw::Atof(a[last-2]),Draw::Atof(a[last-1]),Draw::Atof(a[last]));
489       last -= 3;
490       gp_Dir D(P.X(),P.Y(),P.Z());
491       if (*a[0] == 'l') {
492         T.SetMirror(gp_Ax1(O,D));
493       }
494       else if (*a[0] == 's') {
495         gp_Pln Pl(O,D);
496         T.SetMirror(Pl.Position().Ax2());
497       }
498     }
499   }
500
501   else if (!strcmp(a[0],"translate")) {
502     if (last < 4) return 1;
503     gp_Vec V(Draw::Atof(a[last-2]),Draw::Atof(a[last-1]),Draw::Atof(a[last]));
504     last -= 3;
505     T.SetTranslation(V);
506   }
507
508   else if (!strcmp(a[0],"rotate")) {
509     if (last < 8) return 1;
510     Standard_Real ang = Draw::Atof(a[last]) * (M_PI / 180.0);
511     last --;
512     gp_Dir D(Draw::Atof(a[last-2]),Draw::Atof(a[last-1]),Draw::Atof(a[last]));
513     last -= 3;
514     gp_Pnt P(Draw::Atof(a[last-2]),Draw::Atof(a[last-1]),Draw::Atof(a[last]));
515     last -= 3;
516     T.SetRotation(gp_Ax1(P,D),ang);
517   }
518
519   for (i = 1; i <= last; i++) {
520     Handle(Geom_Geometry) G = DrawTrSurf::Get(a[i]);
521     if (!G.IsNull()) {
522       G->Transform(T);
523       Draw::Repaint();
524     }
525     else {
526       gp_Pnt P;
527       if (DrawTrSurf::GetPoint(a[i],P)) {
528         P.Transform(T);
529         DrawTrSurf::Set(a[i],P);
530       }
531     }
532     di << a[i] << " ";
533   }
534   return 0;
535 }
536
537 //=======================================================================
538 //function : d2transform
539 //purpose  : 
540 //=======================================================================
541
542 static Standard_Integer d2transform (Draw_Interpretor& di, Standard_Integer n, const char** a)
543 {
544   if (n < 4) return 1;
545   gp_Trsf2d T;
546   Standard_Integer i,last = n-1;
547   if (!strcmp(a[0],"2dpscale")) {
548     Standard_Real s = Draw::Atof(a[last]);
549     last--;
550     if (last < 3) return 1;
551     gp_Pnt2d P(Draw::Atof(a[last-1]),Draw::Atof(a[last]));
552     T.SetScale(P,s);
553   }
554   else if ( (!strcmp(a[0],"2dpmirror")) || 
555             (!strcmp(a[0],"2dlmirror"))   ) {
556     if (last < 3) return 1;
557     gp_Pnt2d P(Draw::Atof(a[last-1]),Draw::Atof(a[last]));
558     if (!strcmp(a[0],"2dpmirror")) {
559       T.SetMirror(P);
560     }
561     else {
562       last -= 2;
563       if (last < 3) return 1;
564       gp_Pnt2d O(Draw::Atof(a[last-1]),Draw::Atof(a[last]));
565       last -= 2;
566       gp_Dir2d D(P.X(),P.Y());
567       T.SetMirror(gp_Ax2d(O,D));
568     }
569   }
570
571   else if (!strcmp(a[0],"2dtranslate")) {
572     if (last < 3) return 1;
573     gp_Vec2d V(Draw::Atof(a[last-1]),Draw::Atof(a[last]));
574     last -= 2;
575     T.SetTranslation(V);
576   }
577
578   else if (!strcmp(a[0],"2drotate")) {
579     if (last < 4) return 1;
580     Standard_Real ang = Draw::Atof(a[last]) * (M_PI / 180.0);
581     last --;
582     gp_Pnt2d P(Draw::Atof(a[last-1]),Draw::Atof(a[last]));
583     last -= 2;
584     T.SetRotation(P,ang);
585   }
586
587   for (i = 1; i <= last; i++) {
588     Handle(Geom2d_Curve) G = DrawTrSurf::GetCurve2d(a[i]);
589     if (!G.IsNull()) {
590       G->Transform(T);
591       Draw::Repaint();
592     }
593     else {
594       gp_Pnt2d P;
595       if (DrawTrSurf::GetPoint2d(a[i],P)) {
596         P.Transform(T);
597         DrawTrSurf::Set(a[i],P);
598       }
599     }
600     di << a[i] << " ";
601   }
602   return 0;
603 }
604
605 //=======================================================================
606 //function : Set
607 //purpose  : point
608 //=======================================================================
609 void  DrawTrSurf::Set(const Standard_CString Name, 
610                       const gp_Pnt& P)
611 {
612   Handle(DrawTrSurf_Point) DP = new DrawTrSurf_Point(P,PntShape,PntColor);
613  Draw::Set(Name,DP);
614 }
615
616 //=======================================================================
617 //function : Set
618 //purpose  : point
619 //=======================================================================
620 void  DrawTrSurf::Set(const Standard_CString Name, 
621                       const gp_Pnt2d& P)
622 {
623   Handle(DrawTrSurf_Point) DP = new DrawTrSurf_Point(P,PntShape,PntColor);
624  Draw::Set(Name,DP);
625 }
626
627 //=======================================================================
628 //function : Set
629 //purpose  : Geometry from Geom
630 //=======================================================================
631 void  DrawTrSurf::Set(const Standard_CString Name, 
632                       const Handle(Geom_Geometry)& G,
633                       const Standard_Boolean isSenseMarker)
634 {
635   Handle(DrawTrSurf_Drawable) D;
636   if (!G.IsNull()) {
637
638     Handle(Geom_Curve) C = Handle(Geom_Curve)::DownCast(G);
639     if (!C.IsNull()) {
640       
641       Handle(Geom_BezierCurve) Bez = 
642         Handle(Geom_BezierCurve)::DownCast(C);
643       if (!Bez.IsNull()) {
644         Handle(DrawTrSurf_BezierCurve) DBez = 
645           new DrawTrSurf_BezierCurve(Bez,CurvColor,PolesColor,ShowPoles,
646                                      Discret,Deflection,DrawMode);
647         D = DBez;
648       }
649
650
651       Handle(Geom_BSplineCurve) BS = 
652         Handle(Geom_BSplineCurve)::DownCast(C);
653       if (!BS.IsNull()) {
654         Handle(DrawTrSurf_BSplineCurve) DBS = 
655           new DrawTrSurf_BSplineCurve(BS,
656                                       CurvColor,PolesColor,
657                                       KnotsColor,
658                                       KnotsShape,KnotsSize,
659                                       ShowPoles,ShowKnots,
660                                       Discret,Deflection,DrawMode);
661         D = DBS;
662       }
663
664       if (Bez.IsNull() && BS.IsNull()) {
665         Handle(DrawTrSurf_Curve) DC =
666           new DrawTrSurf_Curve(C,CurvColor,Discret,Deflection,DrawMode,isSenseMarker);
667         D = DC;
668       }
669     }
670
671
672     Handle(Geom_Surface) S = Handle(Geom_Surface)::DownCast(G);
673     if (!S.IsNull()) {
674       
675       Handle(Geom_BezierSurface) Bez = 
676         Handle(Geom_BezierSurface)::DownCast(S);
677       if (!Bez.IsNull()) {
678         Handle(DrawTrSurf_BezierSurface) DBez = 
679           new DrawTrSurf_BezierSurface(Bez,NbUIsos,NbVIsos,
680                                        BoundsColor,IsosColor,PolesColor,
681                                        ShowPoles,
682                                        Discret,Deflection,DrawMode);
683         D = DBez;
684       }
685
686
687       Handle(Geom_BSplineSurface) BS = 
688         Handle(Geom_BSplineSurface)::DownCast(S);
689       if (!BS.IsNull()) {
690         Handle(DrawTrSurf_BSplineSurface) DBS ;
691         if (!knotsIsos) 
692           DBS = new DrawTrSurf_BSplineSurface(BS,
693                                               NbUIsos,NbVIsos,
694                                               BoundsColor,IsosColor,
695                                               PolesColor,KnotsColor,
696                                               KnotsShape,KnotsSize,
697                                               ShowPoles,ShowKnots,
698                                               Discret,Deflection,DrawMode);
699         else
700           DBS = new DrawTrSurf_BSplineSurface(BS,
701                                               BoundsColor,IsosColor,
702                                               PolesColor,KnotsColor,
703                                               KnotsShape,KnotsSize,
704                                               ShowPoles,ShowKnots,
705                                               Discret,Deflection,DrawMode);
706         
707         D = DBS;
708       }
709
710       if (Bez.IsNull() && BS.IsNull()) {
711         Handle(DrawTrSurf_Surface) DS =
712           new DrawTrSurf_Surface(S,
713                                  NbUIsos,NbVIsos,
714                                  BoundsColor,IsosColor,
715                                  Discret,Deflection,DrawMode);
716         D = DS;
717       }
718     }
719
720   }
721   Draw::Set(Name,D);
722 }
723
724
725 //=======================================================================
726 //function : Set
727 //purpose  : Curve from Geom2d
728 //=======================================================================
729 void  DrawTrSurf::Set(const Standard_CString Name, 
730                       const Handle(Geom2d_Curve)& C,
731                       const Standard_Boolean isSenseMarker)
732 {
733   Handle(DrawTrSurf_Drawable) D;
734   if (!C.IsNull()) {
735
736       Handle(Geom2d_BezierCurve) Bez = 
737         Handle(Geom2d_BezierCurve)::DownCast(C);
738       if (!Bez.IsNull()) {
739         Handle(DrawTrSurf_BezierCurve2d) DBez = 
740           new DrawTrSurf_BezierCurve2d(Bez,CurvColor,PolesColor,ShowPoles,
741                                        Discret);
742         D = DBez;
743       }
744
745
746       Handle(Geom2d_BSplineCurve) BS = 
747         Handle(Geom2d_BSplineCurve)::DownCast(C);
748       if (!BS.IsNull()) {
749         Handle(DrawTrSurf_BSplineCurve2d) DBS = 
750           new DrawTrSurf_BSplineCurve2d(BS,
751                                         CurvColor,PolesColor,
752                                         KnotsColor,
753                                         KnotsShape,KnotsSize,
754                                         ShowPoles,ShowKnots,
755                                         Discret);
756         D = DBS;
757       }
758       
759       if (Bez.IsNull() && BS.IsNull()) {
760         Handle(DrawTrSurf_Curve2d) DC =
761           new DrawTrSurf_Curve2d(C,CurvColor,Discret,isSenseMarker);
762         D = DC;
763       }
764     }
765
766   Draw::Set(Name,D);
767 }
768
769 //=======================================================================
770 //function : Set
771 //purpose  : 
772 //=======================================================================
773 void DrawTrSurf::Set(const Standard_CString Name, 
774                      const Handle(Poly_Triangulation)& T)
775 {
776   Handle(DrawTrSurf_Triangulation) D = new DrawTrSurf_Triangulation(T);
777   Draw::Set(Name,D);
778 }
779 //=======================================================================
780 //function : Set
781 //purpose  : 
782 //=======================================================================
783 void DrawTrSurf::Set(const Standard_CString Name, 
784                      const Handle(Poly_Polygon3D)& P)
785 {
786   Handle(DrawTrSurf_Polygon3D) D = new DrawTrSurf_Polygon3D(P);
787   Draw::Set(Name,D);
788 }
789
790 //=======================================================================
791 //function : Set
792 //purpose  : 
793 //=======================================================================
794 void DrawTrSurf::Set(const Standard_CString Name, 
795                      const Handle(Poly_Polygon2D)& P)
796 {
797   Handle(DrawTrSurf_Polygon2D) D = new DrawTrSurf_Polygon2D(P);
798   Draw::Set(Name,D);
799 }
800
801 //=======================================================================
802 //function : Get
803 //purpose  : 
804 //=======================================================================
805 Handle(Geom_Geometry)  DrawTrSurf::Get(Standard_CString& Name)
806 {
807   Handle(Draw_Drawable3D) D = Draw::Get(Name);
808
809   Handle(DrawTrSurf_Curve) DC = 
810     Handle(DrawTrSurf_Curve)::DownCast(D);
811   if (!DC.IsNull())
812     return DC->GetCurve();
813
814   Handle(DrawTrSurf_Surface) DS = 
815     Handle(DrawTrSurf_Surface)::DownCast(D);
816   if (!DS.IsNull())
817     return DS->GetSurface();
818
819   return Handle(Geom_Geometry) ();
820 }
821
822
823 //=======================================================================
824 //function : GetPoint
825 //purpose  : 
826 //=======================================================================
827 Standard_Boolean DrawTrSurf::GetPoint(Standard_CString& Name,
828                                       gp_Pnt& P)
829 {
830   Handle(DrawTrSurf_Point) D = 
831     Handle(DrawTrSurf_Point)::DownCast(Draw::Get(Name));
832   if (D.IsNull())
833     return Standard_False;
834   else if (!D->Is3D())
835     return Standard_False;
836   else {
837     P = D->Point();
838     return Standard_True;
839   }
840 }
841
842 //=======================================================================
843 //function : GetPoint2d
844 //purpose  : 
845 //=======================================================================
846 Standard_Boolean DrawTrSurf::GetPoint2d(Standard_CString& Name,
847                                         gp_Pnt2d& P)
848 {
849   Handle(DrawTrSurf_Point) D = 
850     Handle(DrawTrSurf_Point)::DownCast(Draw::Get(Name));
851   if (D.IsNull())
852     return Standard_False;
853   else if (D->Is3D()) 
854     return Standard_False;
855   else {
856     P = D->Point2d();
857     return Standard_True;
858   }
859 }
860
861 //=======================================================================
862 //function : GetCurve
863 //purpose  : 
864 //=======================================================================
865 Handle(Geom_Curve)  DrawTrSurf::GetCurve(Standard_CString& Name)
866 {
867   Handle(DrawTrSurf_Curve) D = 
868     Handle(DrawTrSurf_Curve)::DownCast(Draw::Get(Name));
869   if (D.IsNull())
870     return Handle(Geom_Curve)();
871   else
872     return D->GetCurve();
873 }
874
875
876 //=======================================================================
877 //function : GetBezierCurve
878 //purpose  : 
879 //=======================================================================
880 Handle(Geom_BezierCurve)  DrawTrSurf::GetBezierCurve(Standard_CString& Name)
881 {
882   Handle(DrawTrSurf_BezierCurve) D = 
883     Handle(DrawTrSurf_BezierCurve)::DownCast(Draw::Get(Name));
884   if (D.IsNull())
885     return Handle(Geom_BezierCurve)();
886   else
887     return Handle(Geom_BezierCurve)::DownCast(D->GetCurve());
888 }
889
890
891 //=======================================================================
892 //function : GetBSplineCurve
893 //purpose  : 
894 //=======================================================================
895 Handle(Geom_BSplineCurve)  DrawTrSurf::GetBSplineCurve(Standard_CString& Name)
896 {
897   Handle(DrawTrSurf_BSplineCurve) D = 
898     Handle(DrawTrSurf_BSplineCurve)::DownCast(Draw::Get(Name));
899   if (D.IsNull())
900     return Handle(Geom_BSplineCurve)();
901   else
902     return Handle(Geom_BSplineCurve)::DownCast(D->GetCurve());
903 }
904 //=======================================================================
905 //function : GetCurve2d
906 //purpose  : 
907 //=======================================================================
908 Handle(Geom2d_Curve)  DrawTrSurf::GetCurve2d(Standard_CString& Name)
909 {
910   Handle(DrawTrSurf_Curve2d) D = 
911     Handle(DrawTrSurf_Curve2d)::DownCast(Draw::Get(Name));
912   if (D.IsNull())
913     return Handle(Geom2d_Curve)();
914   else
915     return D->GetCurve();
916 }
917 //=======================================================================
918 //function : GetBezierCurve2d
919 //purpose  : 
920 //=======================================================================
921 Handle(Geom2d_BezierCurve)  DrawTrSurf::GetBezierCurve2d(Standard_CString& Name)
922 {
923   Handle(DrawTrSurf_Curve2d) D = 
924     Handle(DrawTrSurf_Curve2d)::DownCast(Draw::Get(Name));
925   if (D.IsNull())
926     return Handle(Geom2d_BezierCurve)();
927   else
928     return Handle(Geom2d_BezierCurve)::DownCast(D->GetCurve());
929 }
930 //=======================================================================
931 //function : GetBSplineCurve2d
932 //purpose  : 
933 //=======================================================================
934 Handle(Geom2d_BSplineCurve)  DrawTrSurf::GetBSplineCurve2d
935        (Standard_CString& Name)
936 {
937   Handle(DrawTrSurf_Curve2d) D = 
938     Handle(DrawTrSurf_Curve2d)::DownCast(Draw::Get(Name));
939   if (D.IsNull())
940     return Handle(Geom2d_BSplineCurve)();
941   else
942     return Handle(Geom2d_BSplineCurve)::DownCast(D->GetCurve());
943 }
944 //=======================================================================
945 //function : GetSurface
946 //purpose  : 
947 //=======================================================================
948 Handle(Geom_Surface)  DrawTrSurf::GetSurface
949        (Standard_CString& Name)
950 {
951   Handle(DrawTrSurf_Surface) D = 
952     Handle(DrawTrSurf_Surface)::DownCast(Draw::Get(Name));
953   if (D.IsNull())
954     return Handle(Geom_Surface)();
955   else
956     return D->GetSurface();
957 }
958 //=======================================================================
959 //function : GetBezierSurface
960 //purpose  : 
961 //=======================================================================
962 Handle(Geom_BezierSurface)  DrawTrSurf::GetBezierSurface
963        (Standard_CString& Name)
964 {
965   Handle(DrawTrSurf_BezierSurface) D = 
966     Handle(DrawTrSurf_BezierSurface)::DownCast(Draw::Get(Name));
967   if (D.IsNull())
968     return Handle(Geom_BezierSurface)();
969   else
970     return Handle(Geom_BezierSurface)::DownCast(D->GetSurface());
971 }
972 //=======================================================================
973 //function : GetBSplineSurface
974 //purpose  : 
975 //=======================================================================
976 Handle(Geom_BSplineSurface) DrawTrSurf::GetBSplineSurface
977        (Standard_CString& Name)
978 {
979   Handle(DrawTrSurf_BSplineSurface) D = 
980     Handle(DrawTrSurf_BSplineSurface)::DownCast(Draw::Get(Name));
981   if (D.IsNull())
982     return Handle(Geom_BSplineSurface)();
983   else
984     return Handle(Geom_BSplineSurface)::DownCast(D->GetSurface());
985 }
986 //=======================================================================
987 //function : GetTriangulation
988 //purpose  : 
989 //=======================================================================
990 Handle(Poly_Triangulation) DrawTrSurf::GetTriangulation(Standard_CString& Name)
991 {
992   Handle(DrawTrSurf_Triangulation) D =
993     Handle(DrawTrSurf_Triangulation)::DownCast(Draw::Get(Name));
994   if (D.IsNull())
995     return Handle(Poly_Triangulation)();
996   else
997     return D->Triangulation();
998 }
999 //=======================================================================
1000 //function : GetPolygon3D
1001 //purpose  : 
1002 //=======================================================================
1003 Handle(Poly_Polygon3D) DrawTrSurf::GetPolygon3D(Standard_CString& Name)
1004 {
1005   Handle(DrawTrSurf_Polygon3D) D =
1006     Handle(DrawTrSurf_Polygon3D)::DownCast(Draw::Get(Name));
1007   if (D.IsNull())
1008     return Handle(Poly_Polygon3D)();
1009   else
1010     return D->Polygon3D();
1011 }
1012 //=======================================================================
1013 //function : GetPolygon2D
1014 //purpose  : 
1015 //=======================================================================
1016 Handle(Poly_Polygon2D) DrawTrSurf::GetPolygon2D(Standard_CString& Name)
1017 {
1018   Handle(DrawTrSurf_Polygon2D) D =
1019     Handle(DrawTrSurf_Polygon2D)::DownCast(Draw::Get(Name));
1020   if (D.IsNull())
1021     return Handle(Poly_Polygon2D)();
1022   else
1023     return D->Polygon2D();
1024 }
1025
1026 //=======================================================================
1027 //function : printColor
1028 //purpose  : 
1029 //=======================================================================
1030
1031 static void printColor(Draw_Interpretor& di, const Draw_Color& theColor)
1032 {
1033   switch ( theColor.ID() )
1034   {
1035     case Draw_blanc:   di << "white "            << "\n"; break;
1036     case Draw_rouge:   di << "red "              << "\n"; break;
1037     case Draw_vert:    di << "green "            << "\n"; break;
1038     case Draw_bleu:    di << "blue "             << "\n"; break;
1039     case Draw_cyan:    di << "cyan "             << "\n"; break;
1040     case Draw_or:      di << "golden "           << "\n"; break;
1041     case Draw_magenta: di << "magenta "          << "\n"; break;
1042     case Draw_marron:  di << "brown "            << "\n"; break;
1043     case Draw_orange:  di << "orange "           << "\n"; break;
1044     case Draw_rose:    di << "pink "             << "\n"; break;
1045     case Draw_saumon:  di << "salmon "           << "\n"; break;
1046     case Draw_violet:  di << "violet "           << "\n"; break;
1047     case Draw_jaune:   di << "yellow "           << "\n"; break;
1048     case Draw_kaki:    di << "dark-olive green " << "\n"; break;
1049     case Draw_corail:  di << "coral "            << "\n"; break;
1050   }
1051 }
1052
1053 //=======================================================================
1054 //function : recognizeColor
1055 //purpose  : 
1056 //=======================================================================
1057
1058 static Draw_Color recognizeColor(const char* theColorStr,
1059                                  const Draw_Color& theDefaultColor)
1060 {
1061   Draw_Color aResult = theDefaultColor;
1062
1063   if ( !strcasecmp(theColorStr,"white") )
1064     aResult = Draw_blanc;
1065   if ( !strcasecmp(theColorStr, "red") )
1066     aResult = Draw_rouge;
1067   if ( !strcasecmp(theColorStr, "green") )
1068     aResult = Draw_vert;
1069   if ( !strcasecmp(theColorStr, "blue") )
1070     aResult = Draw_bleu;
1071   if ( !strcasecmp(theColorStr, "cyan") )
1072     aResult = Draw_cyan;
1073   if ( !strcasecmp(theColorStr, "golden") )
1074     aResult = Draw_or;
1075   if ( !strcasecmp(theColorStr, "magenta") )
1076     aResult = Draw_magenta;
1077   if ( !strcasecmp(theColorStr, "brown") )
1078     aResult = Draw_marron;
1079   if ( !strcasecmp(theColorStr, "orange") )
1080     aResult = Draw_orange;
1081   if ( !strcasecmp(theColorStr, "pink") )
1082     aResult = Draw_rose;
1083   if ( !strcasecmp(theColorStr, "salmon") )
1084     aResult = Draw_saumon;
1085   if ( !strcasecmp(theColorStr, "violet") )
1086     aResult = Draw_violet;
1087   if ( !strcasecmp(theColorStr, "yellow") )
1088     aResult = Draw_jaune;
1089   if ( !strcasecmp(theColorStr, "darkgreen") )
1090     aResult = Draw_kaki;
1091   if ( !strcasecmp(theColorStr, "coral") )
1092     aResult = Draw_corail;
1093
1094   return aResult;
1095 }
1096
1097 //=======================================================================
1098 //function : setcurvcolor
1099 //purpose  : 
1100 //=======================================================================
1101
1102 static Standard_Integer setcurvcolor(Draw_Interpretor& di,
1103                                      Standard_Integer n, const char** a)
1104 {
1105   Draw_Color col, savecol;
1106
1107   savecol = DrawTrSurf_CurveColor(Draw_Color(Draw_jaune));
1108   DrawTrSurf_CurveColor(savecol);
1109
1110   if (n < 2)
1111   {
1112     printColor(di, savecol);
1113   }
1114   else {
1115     col = recognizeColor(a[1], savecol);
1116     DrawTrSurf_CurveColor(col);
1117   }
1118   return 0;
1119 }
1120
1121 //=======================================================================
1122 //function : changecurvcolor
1123 //purpose  : 
1124 //=======================================================================
1125
1126 static Standard_Integer changecurvcolor(Draw_Interpretor&,
1127                                         Standard_Integer n, const char** a)
1128 {
1129   Draw_Color col, savecol;
1130
1131   savecol = DrawTrSurf_CurveColor(Draw_Color(Draw_jaune));
1132   DrawTrSurf_CurveColor(savecol);
1133
1134   if ( n < 3 )
1135     return 1;
1136
1137   col = recognizeColor(a[1], savecol);
1138     
1139   Handle(DrawTrSurf_Curve) D = Handle(DrawTrSurf_Curve)::DownCast( Draw::Get(a[2]) );
1140   if ( !D.IsNull() )
1141   {
1142     D->SetColor(col);
1143     Draw::Repaint();
1144   }
1145
1146   return 0;
1147 }
1148
1149 //=======================================================================
1150 //function : setpointcolor
1151 //purpose  : 
1152 //=======================================================================
1153
1154 static Standard_Integer setpointcolor(Draw_Interpretor& di,
1155                                       Standard_Integer n, const char** a)
1156 {
1157   Draw_Color col, savecol;
1158
1159   savecol = DrawTrSurf_PointColor(Draw_Color(Draw_jaune));
1160   DrawTrSurf_PointColor(savecol);
1161
1162   if (n < 2)
1163   {
1164     printColor(di, savecol);
1165   }
1166   else {
1167     col = recognizeColor(a[1], savecol);
1168     DrawTrSurf_PointColor(col);
1169   }
1170   return 0;
1171 }
1172
1173 //=======================================================================
1174 //function : changepointcolor
1175 //purpose  : 
1176 //=======================================================================
1177
1178 static Standard_Integer changepointcolor(Draw_Interpretor&,
1179                                          Standard_Integer n, const char** a)
1180 {
1181   Draw_Color col, savecol;
1182
1183   savecol = DrawTrSurf_PointColor(Draw_Color(Draw_jaune));
1184   DrawTrSurf_PointColor(savecol);
1185
1186   if ( n < 3 )
1187     return 1;
1188
1189   col = recognizeColor(a[1], savecol);
1190     
1191   Handle(DrawTrSurf_Point) D = Handle(DrawTrSurf_Point)::DownCast( Draw::Get(a[2]) );
1192   if ( !D.IsNull() )
1193   {
1194     D->Color(col);
1195     Draw::Repaint();
1196   }
1197
1198   return 0;
1199 }
1200
1201 //=======================================================================
1202 //function : printMarker
1203 //purpose  : 
1204 //=======================================================================
1205
1206 static void printMarker(Draw_Interpretor& di, const Draw_MarkerShape& theMarker)
1207 {
1208   switch ( theMarker )
1209   {
1210     case Draw_Square:     di << "square "      << "\n"; break;
1211     case Draw_Losange:    di << "diamond "     << "\n"; break;
1212     case Draw_X:          di << "x "           << "\n"; break;
1213     case Draw_Plus:       di << "plus "        << "\n"; break;
1214     case Draw_Circle:     di << "circle "      << "\n"; break;
1215     case Draw_CircleZoom: di << "circle_zoom " << "\n"; break;
1216   }
1217 }
1218
1219 //=======================================================================
1220 //function : recognizeMarker
1221 //purpose  : 
1222 //=======================================================================
1223
1224 static Draw_MarkerShape recognizeMarker(const char* theMarkerStr,
1225                                         const Draw_MarkerShape& theDefaultMarker)
1226 {
1227   Draw_MarkerShape aResult = theDefaultMarker;
1228
1229   if ( !strcasecmp(theMarkerStr, "square") )
1230     aResult = Draw_Square;
1231   if ( !strcasecmp(theMarkerStr, "diamond") )
1232     aResult = Draw_Losange;
1233   if ( !strcasecmp(theMarkerStr, "x") )
1234     aResult = Draw_X;
1235   if ( !strcasecmp(theMarkerStr, "plus") )
1236     aResult = Draw_Plus;
1237   if ( !strcasecmp(theMarkerStr, "circle") )
1238     aResult = Draw_Circle;
1239   if ( !strcasecmp(theMarkerStr, "circle_zoom") )
1240     aResult = Draw_CircleZoom;
1241
1242   return aResult;
1243 }
1244
1245 //=======================================================================
1246 //function : setpointmarker
1247 //purpose  : 
1248 //=======================================================================
1249
1250 static Standard_Integer setpointmarker(Draw_Interpretor& di,
1251                                        Standard_Integer n, const char** a)
1252 {
1253   Draw_MarkerShape mark, savemark;
1254
1255   savemark = DrawTrSurf_PointMarker(Draw_MarkerShape(Draw_Plus));
1256   DrawTrSurf_PointMarker(savemark);
1257
1258   if ( n < 2 )
1259   {
1260     printMarker(di, savemark);
1261   }
1262   else {
1263     mark = recognizeMarker(a[1], savemark);
1264     DrawTrSurf_PointMarker(mark);
1265   }
1266   return 0;
1267 }
1268
1269 //=======================================================================
1270 //function : changepointmarker
1271 //purpose  : 
1272 //=======================================================================
1273
1274 static Standard_Integer changepointmarker(Draw_Interpretor&,
1275                                           Standard_Integer n, const char** a)
1276 {
1277   Draw_MarkerShape mark, savemark;
1278
1279   savemark = DrawTrSurf_PointMarker(Draw_MarkerShape(Draw_Plus));
1280   DrawTrSurf_PointMarker(savemark);
1281
1282   if ( n < 3 )
1283     return 1;
1284
1285   mark = recognizeMarker(a[1], savemark);
1286     
1287   Handle(DrawTrSurf_Point) D = Handle(DrawTrSurf_Point)::DownCast( Draw::Get(a[2]) );
1288   if ( !D.IsNull() )
1289   {
1290     D->Shape(mark);
1291     Draw::Repaint();
1292   }
1293
1294   return 0;
1295 }
1296
1297 //=======================================================================
1298 //function : BasicCommands
1299 //purpose  : 
1300 //=======================================================================
1301
1302 static Standard_Boolean done = Standard_False;
1303 void  DrawTrSurf::BasicCommands(Draw_Interpretor& theCommands)
1304 {
1305   if (done) return;
1306   done = Standard_True;
1307
1308   const char* g;
1309   g = "geometric display commands";
1310   
1311   theCommands.Add("nbiso",
1312                   "nbiso name [names...] nuiso nviso",
1313                   __FILE__,
1314                   nbiso,g);
1315   
1316   theCommands.Add("clpoles",
1317                   "clpoles [name], no args : modal ",
1318                   __FILE__,
1319                   drawpoles,g);
1320   
1321   theCommands.Add("shpoles",
1322                   "shpoles [name], no args : modal ",
1323                   __FILE__,
1324                   drawpoles,g);
1325   
1326   theCommands.Add("clknots",
1327                   "clknots [name], no args : modal ",
1328                   __FILE__,
1329                   drawpoles,g);
1330   
1331   theCommands.Add("shknots",
1332                   "shknots [name], no args : modal ",
1333                   __FILE__,
1334                   drawpoles,g);
1335   
1336   theCommands.Add("dmode",
1337                   "dmode [names...] Uniform/Discret",
1338                   __FILE__,
1339                   draw,g);
1340
1341   theCommands.Add("discr",
1342                   "discr [names...] nbintervals",
1343                   __FILE__,
1344                   draw,g);
1345
1346   theCommands.Add("defle",
1347                   "defle [names...] defle",
1348                   __FILE__,
1349                   draw,g);
1350
1351   theCommands.Add("setcurvcolor",
1352                   TCollection_AsciiString("setcurvcolor [color] : set curve color\
1353  by default, or print the current curve color if no argument (this does not modify\
1354  the color of the curve)\n\n").Cat(ColorsHint).ToCString(),
1355                   __FILE__,setcurvcolor,g);
1356
1357   theCommands.Add("changecurvcolor",
1358                   TCollection_AsciiString("changecurvcolor color curve: change\
1359  color of the curve\n\n").Cat(ColorsHint).ToCString(),
1360                   __FILE__,changecurvcolor,g);
1361
1362   theCommands.Add("setpointcolor",
1363                   TCollection_AsciiString("setpointcolor [color] : set point color\
1364  by default, or print the current point color if no argument (this does not modify\
1365  the color of the point)\n\n").Cat(ColorsHint).ToCString(),
1366                   __FILE__,setpointcolor,g);
1367
1368   theCommands.Add("changepointcolor",
1369                   TCollection_AsciiString("changepointcolor color point: change\
1370  color of the point\n\n").Cat(ColorsHint).ToCString(),
1371                   __FILE__,changepointcolor,g);
1372   
1373   theCommands.Add("setpointmarker",
1374                   TCollection_AsciiString("setpointmarker [marker] : set point marker\
1375  by default, or print the current point marker if no argument (this does not modify\
1376  the marker of the point)\n\n").Cat(MarkersHint).ToCString(),
1377                   __FILE__,setpointmarker,g);
1378
1379   theCommands.Add("changepointmarker",
1380                   TCollection_AsciiString("changepointmarker marker point: change\
1381  marker of the point\n\n").Cat(MarkersHint).ToCString(),
1382                   __FILE__,changepointmarker,g);
1383
1384   g = "Geometric tranformations";
1385   
1386   theCommands.Add("translate",
1387                   "translate name [names...] dx dy dz",
1388                   __FILE__,
1389                   transform,g);
1390
1391   theCommands.Add("rotate",
1392                   "rotate name [names...] x y z dx dy dz angle",
1393                   __FILE__,
1394                   transform,g);
1395
1396   theCommands.Add("pmirror",
1397                   "pmirror name [names...] x y z",
1398                   __FILE__,
1399                   transform,g);
1400
1401   theCommands.Add("lmirror",
1402                   "lmirror name [names...] x y z dx dy dz",
1403                   __FILE__,
1404                   transform,g);
1405
1406   theCommands.Add("smirror",
1407                   "smirror name [names...] x y z dx dy dz",
1408                   __FILE__,
1409                   transform,g);
1410
1411   theCommands.Add("pscale",
1412                   "pscale name [names...] x y z s",
1413                   __FILE__,
1414                   transform,g);
1415
1416   theCommands.Add("2dtranslate",
1417                   "translate name [names...] dx dy",
1418                   __FILE__,
1419                   d2transform,g);
1420
1421   theCommands.Add("2drotate",
1422                   "rotate name [names...] x y dx dy  angle",
1423                   __FILE__,
1424                   d2transform,g);
1425
1426   theCommands.Add("2dpmirror",
1427                   "pmirror name [names...] x y",
1428                   __FILE__,
1429                   d2transform,g);
1430
1431   theCommands.Add("2dlmirror",
1432                   "lmirror name [names...] x y dx dy",
1433                   __FILE__,
1434                   d2transform,g);
1435
1436   theCommands.Add("2dpscale",
1437                   "pscale name [names...] x y s",
1438                   __FILE__,
1439                   d2transform,g);
1440 }
1441
1442
1443 //=================================================================
1444 // save and restore curves
1445 //=================================================================
1446
1447 static Standard_Boolean ctest(const Handle(Draw_Drawable3D)& d) 
1448 {
1449   return d->IsInstance(STANDARD_TYPE(DrawTrSurf_Curve));
1450 }
1451
1452 static void csave(const Handle(Draw_Drawable3D)&d, ostream& OS)
1453 {
1454   Handle(DrawTrSurf_Curve) N = Handle(DrawTrSurf_Curve)::DownCast(d);
1455   GeomTools_CurveSet::PrintCurve(N->GetCurve(),OS,Standard_True);
1456 }
1457
1458 static Handle(Draw_Drawable3D) crestore (istream& is)
1459 {
1460   Handle(Geom_Curve) G;
1461   GeomTools_CurveSet::ReadCurve(is,G);
1462   Handle(DrawTrSurf_Curve) N = 
1463     new DrawTrSurf_Curve(G,CurvColor,Discret,Deflection,DrawMode);
1464   return N;
1465 }
1466
1467
1468 static Draw_SaveAndRestore csr("DrawTrSurf_Curve",
1469                                ctest,csave,crestore);
1470
1471
1472
1473
1474 //=================================================================
1475 // save and restore bezier curves
1476 //=================================================================
1477
1478 static Standard_Boolean bzctest(const Handle(Draw_Drawable3D)& d) 
1479 {
1480   return d->IsInstance(STANDARD_TYPE(DrawTrSurf_BezierCurve));
1481 }
1482
1483 static void bzcsave(const Handle(Draw_Drawable3D)&d, ostream& OS)
1484 {
1485   Handle(DrawTrSurf_BezierCurve) 
1486     N = Handle(DrawTrSurf_BezierCurve)::DownCast(d);
1487   GeomTools_CurveSet::PrintCurve(N->GetCurve(),OS,Standard_True);
1488 }
1489
1490 static Handle(Draw_Drawable3D) bzcrestore (istream& is)
1491 {
1492   Handle(Geom_BezierCurve) G;
1493   GeomTools_CurveSet::ReadCurve(is,G);
1494   Handle(DrawTrSurf_BezierCurve) N = 
1495     new DrawTrSurf_BezierCurve(G,CurvColor,PolesColor,ShowPoles,
1496                                Discret,Deflection,DrawMode);
1497   return N;
1498 }
1499
1500
1501 static Draw_SaveAndRestore bzcsr("DrawTrSurf_BezierCurve",
1502                                bzctest,bzcsave,bzcrestore);
1503
1504
1505
1506
1507 //=================================================================
1508 // save and restore bspline curves
1509 //=================================================================
1510
1511 static Standard_Boolean bsctest(const Handle(Draw_Drawable3D)& d) 
1512 {
1513   return d->IsInstance(STANDARD_TYPE(DrawTrSurf_BSplineCurve));
1514 }
1515
1516 static void bscsave(const Handle(Draw_Drawable3D)&d, ostream& OS)
1517 {
1518   Handle(DrawTrSurf_BSplineCurve) 
1519     N = Handle(DrawTrSurf_BSplineCurve)::DownCast(d);
1520   GeomTools_CurveSet::PrintCurve(N->GetCurve(),OS,Standard_True);
1521 }
1522
1523 static Handle(Draw_Drawable3D) bscrestore (istream& is)
1524 {
1525   Handle(Geom_BSplineCurve) G;
1526   GeomTools_CurveSet::ReadCurve(is,G);
1527   Handle(DrawTrSurf_BSplineCurve) N = 
1528     new DrawTrSurf_BSplineCurve(G, CurvColor,PolesColor,
1529                                 KnotsColor,
1530                                 KnotsShape,KnotsSize,
1531                                 ShowPoles,ShowKnots,
1532                                 Discret,Deflection,DrawMode);
1533   return N;
1534 }
1535
1536
1537 static Draw_SaveAndRestore bscsr("DrawTrSurf_BSplineCurve",
1538                                bsctest,bscsave,bscrestore);
1539
1540
1541 //=================================================================
1542 // save and restore curves 2d
1543 //=================================================================
1544
1545 static Standard_Boolean c2dtest(const Handle(Draw_Drawable3D)& d) 
1546 {
1547   return d->IsInstance(STANDARD_TYPE(DrawTrSurf_Curve2d));
1548 }
1549
1550 static void c2dsave(const Handle(Draw_Drawable3D)&d, ostream& OS)
1551 {
1552   Handle(DrawTrSurf_Curve2d) N = Handle(DrawTrSurf_Curve2d)::DownCast(d);
1553   GeomTools_Curve2dSet::PrintCurve2d(N->GetCurve(),OS,Standard_True);
1554 }
1555
1556 static Handle(Draw_Drawable3D) c2drestore (istream& is)
1557 {
1558   Handle(Geom2d_Curve) G;
1559   GeomTools_Curve2dSet::ReadCurve2d(is,G);
1560   Handle(DrawTrSurf_Curve2d) N = 
1561     new DrawTrSurf_Curve2d(G,CurvColor,Discret);
1562   return N;
1563 }
1564
1565
1566 static Draw_SaveAndRestore c2dsr("DrawTrSurf_Curve2d",
1567                                c2dtest,c2dsave,c2drestore);
1568
1569
1570
1571
1572 //=================================================================
1573 // save and restore bezier curves 2d
1574 //=================================================================
1575
1576 static Standard_Boolean bzc2dtest(const Handle(Draw_Drawable3D)& d) 
1577 {
1578   return d->IsInstance(STANDARD_TYPE(DrawTrSurf_BezierCurve2d));
1579 }
1580
1581 static void bzc2dsave(const Handle(Draw_Drawable3D)&d, ostream& OS)
1582 {
1583   Handle(DrawTrSurf_BezierCurve2d) 
1584     N = Handle(DrawTrSurf_BezierCurve2d)::DownCast(d);
1585   GeomTools_Curve2dSet::PrintCurve2d(N->GetCurve(),OS,Standard_True);
1586 }
1587
1588 static Handle(Draw_Drawable3D) bzc2drestore (istream& is)
1589 {
1590   Handle(Geom2d_BezierCurve) G;
1591   GeomTools_Curve2dSet::ReadCurve2d(is,G);
1592   Handle(DrawTrSurf_BezierCurve2d) N = 
1593     new DrawTrSurf_BezierCurve2d(G,CurvColor,PolesColor,ShowPoles,
1594                                Discret);
1595   return N;
1596 }
1597
1598
1599 static Draw_SaveAndRestore bzc2dsr("DrawTrSurf_BezierCurve2d",
1600                                bzc2dtest,bzc2dsave,bzc2drestore);
1601
1602
1603
1604
1605 //=================================================================
1606 // save and restore bspline curves 2d
1607 //=================================================================
1608
1609 static Standard_Boolean bsc2dtest(const Handle(Draw_Drawable3D)& d) 
1610 {
1611   return d->IsInstance(STANDARD_TYPE(DrawTrSurf_BSplineCurve2d));
1612 }
1613
1614 static void bsc2dsave(const Handle(Draw_Drawable3D)&d, ostream& OS)
1615 {
1616   Handle(DrawTrSurf_BSplineCurve2d) 
1617     N = Handle(DrawTrSurf_BSplineCurve2d)::DownCast(d);
1618   GeomTools_Curve2dSet::PrintCurve2d(N->GetCurve(),OS,Standard_True);
1619 }
1620
1621 static Handle(Draw_Drawable3D) bsc2drestore (istream& is)
1622 {
1623   Handle(Geom2d_BSplineCurve) G;
1624   GeomTools_Curve2dSet::ReadCurve2d(is,G);
1625   Handle(DrawTrSurf_BSplineCurve2d) N = 
1626     new DrawTrSurf_BSplineCurve2d(G, CurvColor,PolesColor,
1627                                 KnotsColor,
1628                                 KnotsShape,KnotsSize,
1629                                 ShowPoles,ShowKnots,
1630                                 Discret);
1631   return N;
1632 }
1633
1634
1635 static Draw_SaveAndRestore bsc2dsr("DrawTrSurf_BSplineCurve2d",
1636                                bsc2dtest,bsc2dsave,bsc2drestore);
1637
1638
1639 //=================================================================
1640 // save and restore surfaces
1641 //=================================================================
1642
1643 static Standard_Boolean stest(const Handle(Draw_Drawable3D)& d) 
1644 {
1645   return d->IsInstance(STANDARD_TYPE(DrawTrSurf_Surface));
1646 }
1647
1648 static void ssave(const Handle(Draw_Drawable3D)&d, ostream& OS)
1649 {
1650   Handle(DrawTrSurf_Surface) N = Handle(DrawTrSurf_Surface)::DownCast(d);
1651   GeomTools_SurfaceSet::PrintSurface(N->GetSurface(),OS,Standard_True);
1652 }
1653
1654 static Handle(Draw_Drawable3D) srestore (istream& is)
1655 {
1656   Handle(Geom_Surface) G;
1657   GeomTools_SurfaceSet::ReadSurface(is,G);
1658   Handle(DrawTrSurf_Surface) N = 
1659     new DrawTrSurf_Surface(G,
1660                            NbUIsos,NbVIsos,
1661                            BoundsColor,IsosColor,
1662                            Discret,Deflection,DrawMode);
1663   return N;
1664 }
1665
1666
1667 static Draw_SaveAndRestore ssr("DrawTrSurf_Surface",
1668                                stest,ssave,srestore);
1669
1670
1671
1672
1673 //=================================================================
1674 // save and restore bezier surfaces
1675 //=================================================================
1676
1677 static Standard_Boolean bzstest(const Handle(Draw_Drawable3D)& d) 
1678 {
1679   return d->IsInstance(STANDARD_TYPE(DrawTrSurf_BezierSurface));
1680 }
1681
1682 static void bzssave(const Handle(Draw_Drawable3D)&d, ostream& OS)
1683 {
1684   Handle(DrawTrSurf_BezierSurface) 
1685     N = Handle(DrawTrSurf_BezierSurface)::DownCast(d);
1686   GeomTools_SurfaceSet::PrintSurface(N->GetSurface(),OS,Standard_True);
1687 }
1688
1689 static Handle(Draw_Drawable3D) bzsrestore (istream& is)
1690 {
1691   Handle(Geom_BezierSurface) G;
1692   GeomTools_SurfaceSet::ReadSurface(is,G);
1693   Handle(DrawTrSurf_BezierSurface) N = 
1694     new DrawTrSurf_BezierSurface(G,NbUIsos,NbVIsos,
1695                                  BoundsColor,IsosColor,PolesColor,
1696                                  ShowPoles,
1697                                  Discret,Deflection,DrawMode);
1698   return N;
1699 }
1700
1701
1702 static Draw_SaveAndRestore bzssr("DrawTrSurf_BezierSurface",
1703                                bzstest,bzssave,bzsrestore);
1704
1705
1706
1707
1708 //=================================================================
1709 // save and restore bspline surfaces
1710 //=================================================================
1711
1712 static Standard_Boolean bsstest(const Handle(Draw_Drawable3D)& d) 
1713 {
1714   return d->IsInstance(STANDARD_TYPE(DrawTrSurf_BSplineSurface));
1715 }
1716
1717 static void bsssave(const Handle(Draw_Drawable3D)&d, ostream& OS)
1718 {
1719   Handle(DrawTrSurf_BSplineSurface) 
1720     N = Handle(DrawTrSurf_BSplineSurface)::DownCast(d);
1721   GeomTools_SurfaceSet::PrintSurface(N->GetSurface(),OS,Standard_True);
1722 }
1723
1724 static Handle(Draw_Drawable3D) bssrestore (istream& is)
1725 {
1726   Handle(Geom_BSplineSurface) G;
1727   GeomTools_SurfaceSet::ReadSurface(is,G);
1728   Handle(DrawTrSurf_BSplineSurface) N;
1729   if (!knotsIsos) 
1730     N   = new DrawTrSurf_BSplineSurface(G,
1731                                         NbUIsos,NbVIsos,
1732                                         BoundsColor,IsosColor,
1733                                         PolesColor,KnotsColor,
1734                                         KnotsShape,KnotsSize,
1735                                         ShowPoles,ShowKnots,
1736                                               Discret,Deflection,DrawMode);
1737   else
1738     N   = new DrawTrSurf_BSplineSurface(G,
1739                                         BoundsColor,IsosColor,
1740                                         PolesColor,KnotsColor,
1741                                         KnotsShape,KnotsSize,
1742                                         ShowPoles,ShowKnots,
1743                                         Discret,Deflection,DrawMode);
1744         
1745   return N;
1746 }
1747
1748
1749 static Draw_SaveAndRestore bsssr("DrawTrSurf_BSplineSurface",
1750                                bsstest,bsssave,bssrestore);
1751
1752
1753 //=================================================================
1754 // save and restore points
1755 //=================================================================
1756
1757 static Standard_Boolean pnttest(const Handle(Draw_Drawable3D)& d) 
1758 {
1759   return d->IsInstance(STANDARD_TYPE(DrawTrSurf_Point));
1760 }
1761
1762 static void pntsave(const Handle(Draw_Drawable3D)&d, ostream& OS)
1763 {
1764   Handle(DrawTrSurf_Point) 
1765     N = Handle(DrawTrSurf_Point)::DownCast(d);
1766 #if defined(HAVE_IOS) && !defined(__sgi) && !defined(IRIX)
1767   ios::fmtflags F = OS.flags();
1768   OS.setf(ios::scientific,ios::floatfield);
1769   OS.precision(15);
1770 #else
1771   long form = OS.setf(ios::scientific);
1772   std::streamsize prec = OS.precision(15);
1773 #endif
1774   gp_Pnt P = N->Point();
1775   if (N->Is3D()) {
1776     OS << "1 ";
1777     OS << P.X() << " " << P.Y() << " " << P.Z() << "\n";
1778   }
1779   else {
1780     OS << "0 ";
1781     OS << P.X() << " " << P.Y() << "\n";
1782   }
1783 #if defined(HAVE_IOS) && !defined(__sgi) && !defined(IRIX)
1784   OS.setf(F);
1785 #else
1786   OS.setf(form);
1787   OS.precision(prec);
1788 #endif
1789 }
1790
1791 static Handle(Draw_Drawable3D) pntrestore (istream& is)
1792 {
1793   Standard_Integer is3d;
1794   is >> is3d;
1795   Standard_Real x,y,z;
1796   if (is3d)
1797     is >> x >> y >> z;
1798   else
1799     is >> x >> y;
1800   Handle(DrawTrSurf_Point) N;
1801   if (is3d)
1802     N = new DrawTrSurf_Point(gp_Pnt(x,y,z),PntShape,PntColor);
1803   else
1804     N = new DrawTrSurf_Point(gp_Pnt2d(x,y),PntShape,PntColor);
1805     
1806   return N;
1807 }
1808
1809
1810 static Draw_SaveAndRestore pntsr("DrawTrSurf_Point",
1811                                pnttest,pntsave,pntrestore);
1812
1813
1814
1815 //=================================================================
1816 // save and restore triangulation
1817 //=================================================================
1818
1819 static Standard_Boolean triatest(const Handle(Draw_Drawable3D)& d) 
1820 {
1821   return d->IsInstance(STANDARD_TYPE(DrawTrSurf_Triangulation));
1822 }
1823
1824 static void triasave(const Handle(Draw_Drawable3D)&d, ostream& OS)
1825 {
1826   Handle(DrawTrSurf_Triangulation) 
1827     T = Handle(DrawTrSurf_Triangulation)::DownCast(d);
1828 #if defined(HAVE_IOS) && !defined(__sgi) && !defined(IRIX)
1829   ios::fmtflags F = OS.flags();
1830   OS.setf(ios::scientific,ios::floatfield);
1831   OS.precision(15);
1832 #else
1833   long form = OS.setf(ios::scientific);
1834   std::streamsize prec = OS.precision(15);
1835 #endif
1836   Poly::Write(T->Triangulation(),OS);
1837 #if defined(HAVE_IOS) && !defined(__sgi) && !defined(IRIX)
1838   OS.setf(F);
1839 #else
1840   OS.setf(form);
1841   OS.precision(prec);
1842 #endif
1843 }
1844
1845 static Handle(Draw_Drawable3D) triarestore (istream& is)
1846 {
1847   return new DrawTrSurf_Triangulation(Poly::ReadTriangulation(is));
1848 }
1849
1850
1851 static Draw_SaveAndRestore triasr("DrawTrSurf_Triangulation",
1852                                triatest,triasave,triarestore);
1853
1854
1855
1856 //=================================================================
1857 // save and restore polygon3d
1858 //=================================================================
1859
1860 static Standard_Boolean poly3dtest(const Handle(Draw_Drawable3D)& d) 
1861 {
1862   return d->IsInstance(STANDARD_TYPE(DrawTrSurf_Polygon3D));
1863 }
1864
1865 static void poly3dsave(const Handle(Draw_Drawable3D)&d, ostream& OS)
1866 {
1867   Handle(DrawTrSurf_Polygon3D) 
1868     T = Handle(DrawTrSurf_Polygon3D)::DownCast(d);
1869 #if defined(HAVE_IOS) && !defined(__sgi) && !defined(IRIX)
1870   ios::fmtflags F = OS.flags();
1871   OS.setf(ios::scientific,ios::floatfield);
1872   OS.precision(15);
1873 #else
1874   long form = OS.setf(ios::scientific);
1875   std::streamsize prec = OS.precision(15);
1876 #endif
1877   Poly::Write(T->Polygon3D(),OS);
1878 #if defined(HAVE_IOS) && !defined(__sgi) && !defined(IRIX)
1879   OS.setf(F);
1880 #else
1881   OS.setf(form);
1882   OS.precision(prec);
1883 #endif
1884 }
1885
1886 static Handle(Draw_Drawable3D) poly3drestore (istream& is)
1887 {
1888   return new DrawTrSurf_Polygon3D(Poly::ReadPolygon3D(is));
1889 }
1890
1891
1892 static Draw_SaveAndRestore poly3dsr("DrawTrSurf_Polygon3D",
1893                                poly3dtest,poly3dsave,poly3drestore);
1894
1895
1896 //=================================================================
1897 // save and restore polygon2d
1898 //=================================================================
1899
1900 static Standard_Boolean poly2dtest(const Handle(Draw_Drawable3D)& d) 
1901 {
1902   return d->IsInstance(STANDARD_TYPE(DrawTrSurf_Polygon2D));
1903 }
1904
1905 static void poly2dsave(const Handle(Draw_Drawable3D)&d, ostream& OS)
1906 {
1907   Handle(DrawTrSurf_Polygon2D) 
1908     T = Handle(DrawTrSurf_Polygon2D)::DownCast(d);
1909 #if defined(HAVE_IOS) && !defined(__sgi) && !defined(IRIX)
1910   ios::fmtflags F = OS.flags();
1911   OS.setf(ios::scientific, ios::floatfield);
1912   OS.precision(15);
1913 #else
1914   long form = OS.setf(ios::scientific);
1915   std::streamsize prec = OS.precision(15);
1916 #endif
1917   Poly::Write(T->Polygon2D(),OS);
1918 #if defined(HAVE_IOS) && !defined(__sgi) && !defined(IRIX)
1919   OS.setf(F);
1920 #else
1921   OS.setf(form);
1922   OS.precision(prec);
1923 #endif
1924 }
1925
1926 static Handle(Draw_Drawable3D) poly2drestore (istream& is)
1927 {
1928   return new DrawTrSurf_Polygon2D(Poly::ReadPolygon2D(is));
1929 }
1930
1931
1932 static Draw_SaveAndRestore poly2dsr("DrawTrSurf_Polygon2D",
1933                                poly2dtest,poly2dsave,poly2drestore);
1934