7792e6125775b754d2493e6bd6ebd68205a95ef0
[occt.git] / src / Draw / Draw_Viewer.cxx
1 // Created on: 1992-04-06
2 // Created by: Remi LEQUETTE
3 // Copyright (c) 1992-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 // Updated by GG Tue Oct 22 16:22:10 1996
22 //              reason : Try to compress the pixel image
23 //                       in PseudoColor 8 planes format
24 //              see : SaveView(filename)
25
26 #include <Draw_Viewer.hxx>
27
28 #include <gp_Pnt.hxx>
29 #include <gp_Pnt2d.hxx>
30 #include <Draw_Window.hxx>
31 #include <Draw_Display.hxx>
32
33
34 #define precpers 0.95
35 #define ButtonPress 4
36 #define MotionNotify 6
37 static const Standard_Real DRAWINFINITE = 1e50;
38 Standard_EXPORT Standard_Boolean Draw_Bounds = Standard_True;
39 extern Standard_Boolean Draw_Batch;
40 const Standard_Integer MAXSEGMENT = 1000;
41 Segment segm[MAXSEGMENT];
42 static int nbseg=0;
43 static Draw_View* curview = NULL;
44 static Standard_Integer curviewId = 0;
45 static char blank[2] = "";
46 static Standard_Real xmin,xmax,ymin,ymax;
47 static Standard_Boolean found = Standard_False;
48 static Standard_Integer  xpick, ypick, precpick;
49 static gp_Pnt lastPickP1;
50 static gp_Pnt lastPickP2;
51 static Standard_Real   lastPickParam;
52 static Draw_Color highlightcol;
53 static Draw_Color currentcolor;
54 static Standard_Boolean highlight = Standard_False;
55 static Standard_Integer ps_vx, ps_vy;
56 static Standard_Real ps_kx, ps_ky;
57 static Standard_Integer ps_px, ps_py;
58 static ostream* ps_stream;
59 static Standard_Integer ps_width[MAXCOLOR];
60 static Standard_Real    ps_gray[MAXCOLOR];
61
62 enum DrawingMode {DRAW, PICK, POSTSCRIPT};
63 static DrawingMode CurrentMode = DRAW;
64
65 /* local window class */
66
67 //=======================================================================
68 // class View
69 //=======================================================================
70
71 class Draw_View : public Draw_Window {
72   public :
73     Draw_View(Standard_Integer i,
74               Draw_Viewer* v,
75               Standard_Integer X,
76               Standard_Integer Y,
77               Standard_Integer W,
78               Standard_Integer H);
79
80 #if defined(_WIN32) || defined(__WIN32__)
81     Draw_View(Standard_Integer i,
82               Draw_Viewer* v,
83               Standard_Integer X,
84               Standard_Integer Y,
85               Standard_Integer W,
86               Standard_Integer H,
87         HWND win);
88 #elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
89   Draw_View(Standard_Integer i,
90             Draw_Viewer* v,
91             Standard_Integer X,
92             Standard_Integer Y,
93             Standard_Integer W,
94             Standard_Integer H,
95             NSWindow* theWindow);
96 #endif
97
98   Draw_View(Standard_Integer i,
99             Draw_Viewer* v,
100             const char *w);
101
102   void WExpose();
103
104   Standard_Boolean Init(const char* typ);
105   ~Draw_View() {Destroy();}
106
107   void ResetFrame() { Framex0=Framey0=Framex1=Framey1=0; }
108
109   void GetFrame(Standard_Integer& x0,Standard_Integer& y0,
110                 Standard_Integer& x1,Standard_Integer& y1) {
111     if(Framex0==Framex1) {
112       viewer->GetFrame(id,x0,y0,x1,y1);
113       Framex0=x0; Framex1=x1; Framey0=y0; Framey1=y1;
114     }
115     else {
116       x0=Framex0; x1=Framex1;
117       y0=Framey0; y1=Framey1;
118     }
119   }
120
121   Standard_Integer       id;
122   Draw_Viewer*           viewer;
123   char                   type[5];
124   Standard_Integer       FlagPers;
125   Standard_Integer       Flag2d;
126   Standard_Real          FocalDist;
127   Standard_Real          Zoom;
128   gp_Trsf                Matrix;
129   Standard_Integer       dX;
130   Standard_Integer       dY;
131   Standard_Integer       lastX;
132   Standard_Integer       lastY;
133   Standard_Integer       Framex0,Framey0,Framex1,Framey1;
134 };
135
136 //=======================================================================
137 //function : Draw_View
138 //purpose  :
139 //=======================================================================
140 Draw_View::Draw_View(Standard_Integer i, Draw_Viewer* v,
141                         Standard_Integer X,
142                         Standard_Integer Y,
143                         Standard_Integer W,
144                         Standard_Integer H) :
145      Draw_Window("Win", X, Y, W, H), id(i), viewer(v)
146 {
147   Framex0=Framey0=Framex1=Framey1=0;
148 }
149
150 #if defined(_WIN32) || defined(__WIN32__)
151 //=======================================================================
152 //function : Draw_View
153 //purpose  :
154 //=======================================================================
155 Draw_View::Draw_View(Standard_Integer i, Draw_Viewer* v,
156                         Standard_Integer X,
157                         Standard_Integer Y,
158                         Standard_Integer W,
159                         Standard_Integer H,
160       HWND win) :
161      Draw_Window("Win", X, Y, W, H, win), id(i), viewer(v)
162 {
163   Framex0=Framey0=Framex1=Framey1=0;
164 }
165 #elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
166 Draw_View::Draw_View(Standard_Integer i, Draw_Viewer* v,
167                      Standard_Integer X,
168                      Standard_Integer Y,
169                      Standard_Integer W,
170                      Standard_Integer H,
171                      NSWindow* theWindow) :
172 Draw_Window(theWindow, "Win", X, Y, W, H), id(i), viewer(v)
173 {
174   Framex0=Framey0=Framex1=Framey1=0;
175 }
176 #endif
177
178 //=======================================================================
179 //function : Draw_View
180 //purpose  :
181 //=======================================================================
182 #if defined(_WIN32) || defined (__WIN32__) || (defined(__APPLE__) && !defined(MACOSX_USE_GLX))
183 Draw_View::Draw_View(Standard_Integer /*i*/, Draw_Viewer* /*v*/, const char* /*w*/)
184 #else
185 Draw_View::Draw_View(Standard_Integer i, Draw_Viewer* v, const char* w) :
186      Draw_Window(w), id(i), viewer(v)
187 #endif
188 {
189
190 }
191
192 //=======================================================================
193 //function : Init
194 //purpose  :
195 //=======================================================================
196
197 Standard_Boolean Draw_View::Init (const char* typ)
198 {
199   // default fields
200
201   Framex0=Framey0=Framex1=Framey1=0;
202   FocalDist = 500.;
203   FlagPers  = 0;
204   Flag2d    = !strcmp("-2D-",typ);
205   Zoom      = 1;
206   gp_Trsf T;
207   gp_Pnt Pvise(0,0,0);
208   if (!strcmp("+X+Y",typ) || Flag2d)
209     {
210       Matrix = T;
211     }
212   else if (!strcmp("-Y+X",typ))
213     {
214       Matrix.SetRotation(gp_Ax1(Pvise,gp_Dir(0,0,1)),M_PI/2);
215     }
216   else if (!strcmp("-X-Y",typ))
217     {
218       Matrix.SetRotation(gp_Ax1(Pvise,gp_Dir(0,0,1)),M_PI);
219     }
220   else if (!strcmp("+Y-X",typ))
221     {
222       Matrix.SetRotation(gp_Ax1(Pvise,gp_Dir(0,0,1)),-M_PI/2);
223     }
224   else if (!strcmp("+Y+X",typ))
225     {
226       Matrix.SetRotation(gp_Ax1(Pvise,gp_Dir(0,0,1)),-M_PI/2);
227       T.SetRotation(gp_Ax1(Pvise,gp_Dir(0,1,0)),M_PI);
228       Matrix.Multiply(T);
229     }
230   else if (!strcmp("-X+Y",typ))
231     {
232       Matrix.SetRotation(gp_Ax1(Pvise,gp_Dir(0,1,0)),M_PI);
233     }
234   else if (!strcmp("-Y-X",typ))
235     {
236       Matrix.SetRotation(gp_Ax1(Pvise,gp_Dir(0,0,1)),-M_PI/2);
237       T.SetRotation(gp_Ax1(Pvise,gp_Dir(1,0,0)),M_PI);
238       Matrix.Multiply(T);
239     }
240   else if (!strcmp("+X-Y",typ))
241     {
242       Matrix.SetRotation(gp_Ax1(Pvise,gp_Dir(1,0,0)),M_PI);
243     }
244   else if (!strcmp("+X+Z",typ))
245     {
246       Matrix.SetRotation(gp_Ax1(Pvise,gp_Dir(1,0,0)),-M_PI/2);
247     }
248   else if (!strcmp("-Z+X",typ))
249     {
250       Matrix.SetRotation(gp_Ax1(Pvise,gp_Dir(1,0,0)),-M_PI/2);
251       T.SetRotation(gp_Ax1(Pvise,gp_Dir(0,1,0)),-M_PI/2);
252       Matrix.Multiply(T);
253     }
254   else if (!strcmp("-X-Z",typ))
255     {
256       Matrix.SetRotation(gp_Ax1(Pvise,gp_Dir(1,0,0)),-M_PI/2);
257       T.SetRotation(gp_Ax1(Pvise,gp_Dir(0,1,0)),-M_PI);
258       Matrix.Multiply(T);
259     }
260   else if (!strcmp("+Z-X",typ))
261     {
262       Matrix.SetRotation(gp_Ax1(Pvise,gp_Dir(1,0,0)),-M_PI/2);
263       T.SetRotation(gp_Ax1(Pvise,gp_Dir(0,1,0)),M_PI/2);
264       Matrix.Multiply(T);
265     }
266   else if (!strcmp("+Z+X",typ))
267     {
268       Matrix.SetRotation(gp_Ax1(Pvise,gp_Dir(1,0,0)),M_PI/2);
269       T.SetRotation(gp_Ax1(Pvise,gp_Dir(0,1,0)),M_PI/2);
270       Matrix.Multiply(T);
271     }
272   else if (!strcmp("-X+Z",typ))
273     {
274       Matrix.SetRotation(gp_Ax1(Pvise,gp_Dir(1,0,0)),M_PI/2);
275       T.SetRotation(gp_Ax1(Pvise,gp_Dir(0,1,0)),M_PI);
276       Matrix.Multiply(T);
277     }
278   else if (!strcmp("-Z-X",typ))
279     {
280       Matrix.SetRotation(gp_Ax1(Pvise,gp_Dir(1,0,0)),M_PI/2);
281       T.SetRotation(gp_Ax1(Pvise,gp_Dir(0,1,0)),-M_PI/2);
282       Matrix.Multiply(T);
283     }
284   else if (!strcmp("+X-Z",typ))
285     {
286       Matrix.SetRotation(gp_Ax1(Pvise,gp_Dir(1,0,0)),M_PI/2);
287     }
288   else if (!strcmp("+Y+Z",typ))
289     {
290       Matrix.SetRotation(gp_Ax1(Pvise,gp_Dir(0,1,0)),-M_PI/2);
291       T.SetRotation(gp_Ax1(Pvise,gp_Dir(1,0,0)),-M_PI/2);
292       Matrix.Multiply(T);
293     }
294   else if (!strcmp("-Z+Y",typ))
295     {
296       Matrix.SetRotation(gp_Ax1(Pvise,gp_Dir(0,1,0)),-M_PI/2);
297     }
298   else if (!strcmp("-Y-Z",typ))
299     {
300       Matrix.SetRotation(gp_Ax1(Pvise,gp_Dir(0,1,0)),-M_PI/2);
301       T.SetRotation(gp_Ax1(Pvise,gp_Dir(1,0,0)),M_PI/2);
302       Matrix.Multiply(T);
303     }
304   else if (!strcmp("+Z-Y",typ))
305     {
306       Matrix.SetRotation(gp_Ax1(Pvise,gp_Dir(0,1,0)),-M_PI/2);
307       T.SetRotation(gp_Ax1(Pvise,gp_Dir(1,0,0)),M_PI);
308       Matrix.Multiply(T);
309     }
310   else if (!strcmp("+Z+Y",typ))
311     {
312       Matrix.SetRotation(gp_Ax1(Pvise,gp_Dir(0,1,0)),M_PI/2);
313     }
314   else if (!strcmp("-Y+Z",typ))
315     {
316       Matrix.SetRotation(gp_Ax1(Pvise,gp_Dir(0,1,0)),M_PI/2);
317       T.SetRotation(gp_Ax1(Pvise,gp_Dir(1,0,0)),-M_PI/2);
318       Matrix.Multiply(T);
319     }
320   else if (!strcmp("-Z-Y",typ))
321     {
322       Matrix.SetRotation(gp_Ax1(Pvise,gp_Dir(0,1,0)),M_PI/2);
323       T.SetRotation(gp_Ax1(Pvise,gp_Dir(1,0,0)),M_PI);
324       Matrix.Multiply(T);
325     }
326   else if (!strcmp("+Y-Z",typ))
327     {
328       Matrix.SetRotation(gp_Ax1(Pvise,gp_Dir(0,1,0)),M_PI/2);
329       T.SetRotation(gp_Ax1(Pvise,gp_Dir(1,0,0)),M_PI/2);
330       Matrix.Multiply(T);
331     }
332   else if (!strcmp("AXON",typ))
333     {
334       Matrix.SetRotation(gp_Ax1(Pvise,gp_Dir(1,0,0)),-M_PI/4);
335       T.SetRotation(gp_Ax1(Pvise,gp_Dir(0,0,1)),-M_PI/4);
336       Matrix.Multiply(T);
337     }
338   else if (!strcmp("PERS",typ))
339     {
340       FlagPers =1;
341       Matrix.SetRotation(gp_Ax1(Pvise,gp_Dir(1,0,0)),-M_PI/4);
342       T.SetRotation(gp_Ax1(Pvise,gp_Dir(0,0,1)),-M_PI/4);
343       Matrix.Multiply(T);
344     }
345   else {
346     return Standard_False;
347   }
348   strcpy(type,typ);
349   return Standard_True;
350 }
351
352 //=======================================================================
353 //function : WExpose
354 //purpose  :
355 //=======================================================================
356
357 void Draw_View::WExpose()
358 {
359   Framex0=Framey0=Framex1=Framey1=0;
360   viewer->RepaintView(id);
361 }
362
363 //=======================================================================
364 //function : Create
365 //purpose  :
366 //=======================================================================
367
368 Draw_Viewer::Draw_Viewer()
369 {
370   if (Draw_Batch) return;
371   Standard_Integer i;
372   for ( i = 0; i < MAXVIEW; i++) myViews[i] = NULL;
373   for (i = 0; i < MAXCOLOR; i++) {
374     ps_width[i] = 1;
375     ps_gray[i]  = 0;
376   }
377 }
378
379 //=======================================================================
380 //function : DefineColor
381 //purpose  :
382 //=======================================================================
383
384 Standard_Boolean Draw_Viewer::DefineColor (const Standard_Integer i, const char* colname)
385 {
386   if (Draw_Batch) return 1;
387   return Draw_Window::DefineColor(i,colname);
388 }
389
390
391 //=======================================================================
392 //function : MakeView
393 //purpose  :
394 //=======================================================================
395
396 void Draw_Viewer::MakeView(const Standard_Integer id,
397                            const char* typ,
398                            const Standard_Integer X, const Standard_Integer Y,
399                            const Standard_Integer W, const Standard_Integer H)
400 {
401   if (Draw_Batch) return;
402   if (id < MAXVIEW) {
403
404     DeleteView(id);
405     myViews[id] = new Draw_View(id,this,X , Y, W, H);
406
407     // View fields
408     myViews[id]->dX =   W / 2;
409     myViews[id]->dY = - H / 2;
410
411     if (!myViews[id]->Init(typ))
412       DeleteView(id);
413
414     RepaintView(id);
415   }
416 }
417
418 #ifdef WNT
419 //=======================================================================
420 //function : MakeView
421 //purpose  :
422 //=======================================================================
423
424 void Draw_Viewer::MakeView(const Standard_Integer id,
425                            const char* typ,
426                            const Standard_Integer X, const Standard_Integer Y,
427                            const Standard_Integer W, const Standard_Integer H,
428          HWND win, Standard_Boolean useBuffer)
429 {
430   if (Draw_Batch) return;
431   if (id < MAXVIEW) {
432
433     DeleteView(id);
434     myViews[id] = new Draw_View(id, this, X, Y, W, H, win);
435     myViews[id]->SetUseBuffer(useBuffer);
436
437     // View fields
438     myViews[id]->dX =   W / 2;
439     myViews[id]->dY = - H / 2;
440
441     if (!myViews[id]->Init(typ))
442       DeleteView(id);
443     RepaintView(id);
444   }
445 }
446 #endif
447
448 //=======================================================================
449 //function : MakeView
450 //purpose  :
451 //=======================================================================
452
453 void Draw_Viewer::MakeView    (const Standard_Integer id,
454                                const char*  typ,
455                                const char*  window)
456 {
457   if (Draw_Batch) return;
458   if (id < MAXVIEW) {
459
460     DeleteView(id);
461     myViews[id] = new Draw_View(id,this,window);
462
463
464     myViews[id]->dX =   myViews[id]->WidthWin() / 2;
465     myViews[id]->dY = - myViews[id]->HeightWin() / 2;
466
467     if (!myViews[id]->Init(typ))
468       DeleteView(id);
469
470     RepaintView(id);
471   }
472 }
473
474
475 //=======================================================================
476 //function : SetTitle
477 //purpose  :
478 //=======================================================================
479
480 void Draw_Viewer::SetTitle (const Standard_Integer id, const char* name)
481 {
482   if (Draw_Batch) return;
483   if(myViews[id]) myViews[id]->SetTitle((char*)name);
484 }
485
486 //=======================================================================
487 //function : ResetView
488 //purpose  : reset view zoom and axes
489 //=======================================================================
490
491 void Draw_Viewer::ResetView(const Standard_Integer id)
492 {
493   if (Draw_Batch) return;
494   if (myViews[id]) {
495     myViews[id]->Init(myViews[id]->type);
496     ConfigView(id);
497   }
498 }
499
500 //=======================================================================
501 //function : SetZoom
502 //purpose  :
503 //=======================================================================
504
505 void Draw_Viewer::SetZoom (const Standard_Integer id, const Standard_Real z)
506 {
507   if (Draw_Batch) return;
508   if (myViews[id]) {
509     Standard_Real zz = z / myViews[id]->Zoom;
510     myViews[id]->Zoom = z;
511     Standard_Integer X,Y,W,H;
512     GetPosSize(id,X,Y,W,H);
513     Standard_Real w = W;
514     myViews[id]->dX = (Standard_Integer )(   w / 2 - zz * (w/2 - myViews[id]->dX));
515     Standard_Real h = H;
516     myViews[id]->dY = (Standard_Integer )( - h / 2 + zz * (h/2 + myViews[id]->dY));
517   }
518 }
519
520 //=======================================================================
521 //function : RotateView
522 //purpose  :
523 //=======================================================================
524
525 void   Draw_Viewer::RotateView  (const Standard_Integer id,
526                                  const gp_Dir2d& D,
527                                  const Standard_Real A)
528 {
529   if (Draw_Batch) return;
530   if (myViews[id]) {
531     gp_Trsf T = myViews[id]->Matrix;
532
533     T.Invert();
534     gp_Pnt PP(0,0,0);
535     gp_Dir DD(D.X(),D.Y(),0);
536     PP.Transform(T);
537     DD.Transform(T);
538     RotateView(id,PP,DD,A);
539   }
540 }
541
542 //=======================================================================
543 //function : RotateView
544 //purpose  :
545 //=======================================================================
546
547 void   Draw_Viewer::RotateView  (const Standard_Integer id,
548                                  const gp_Pnt& P,
549                                  const gp_Dir& D,
550                                  const Standard_Real A)
551 {
552   if (Draw_Batch) return;
553   if (myViews[id]) {
554     gp_Trsf T;
555     T.SetRotation(gp_Ax1(P,D),A);
556     myViews[id]->Matrix.Multiply(T);
557   }
558 }
559
560
561 //=======================================================================
562 //function : SetFocal
563 //purpose  :
564 //=======================================================================
565
566 void Draw_Viewer::SetFocal (const Standard_Integer id, const Standard_Real F)
567 {
568   if (Draw_Batch) return;
569   if (myViews[id])
570     myViews[id]->FocalDist = F;
571 }
572
573 //=======================================================================
574 //function : GetType
575 //purpose  :
576 //=======================================================================
577
578 char* Draw_Viewer::GetType (const Standard_Integer id) const
579 {
580   if (Draw_Batch) return blank;
581   if (myViews[id])
582     return myViews[id]->type;
583   else
584     return blank;
585 }
586
587 //=======================================================================
588 //function : Zoom
589 //purpose  :
590 //=======================================================================
591
592 Standard_Real Draw_Viewer::Zoom (const Standard_Integer id) const
593 {
594   if (Draw_Batch) return Standard_False;
595   if (myViews[id])
596     return myViews[id]->Zoom;
597   else
598     return 0;
599 }
600
601 //=======================================================================
602 //function : Focal
603 //purpose  :
604 //=======================================================================
605
606 Standard_Real Draw_Viewer::Focal (const Standard_Integer id) const
607 {
608   if (Draw_Batch) return 1.;
609   if (myViews[id])
610     return myViews[id]->FocalDist;
611   else
612     return 0;
613 }
614
615 //=======================================================================
616 //function : GetTrsf
617 //purpose  :
618 //=======================================================================
619
620 void Draw_Viewer::GetTrsf (const Standard_Integer id,gp_Trsf& T) const
621 {
622   if (Draw_Batch) return;
623   if (myViews[id])
624     T = myViews[id]->Matrix;
625 }
626
627 //=======================================================================
628 //function : Is3D
629 //purpose  :
630 //=======================================================================
631
632 Standard_Boolean Draw_Viewer::Is3D (const Standard_Integer id) const
633 {
634   if (Draw_Batch) return Standard_False;
635   if (myViews[id])
636     return !myViews[id]->Flag2d;
637   else
638     return Standard_False;
639 }
640
641 //=======================================================================
642 //function : SetTrsf
643 //purpose  :
644 //=======================================================================
645
646 void Draw_Viewer::SetTrsf (const Standard_Integer id,gp_Trsf& T)
647 {
648   if (Draw_Batch) return;
649   if (myViews[id])
650     myViews[id]->Matrix = T;
651 }
652
653 //=======================================================================
654 //function : GetPosSize
655 //purpose  :
656 //=======================================================================
657
658 void Draw_Viewer::GetPosSize(const Standard_Integer id,
659                              Standard_Integer& X, Standard_Integer& Y,
660                              Standard_Integer& W, Standard_Integer& H)
661 {
662   if (Draw_Batch) return;
663   if (myViews[id] != NULL) {
664     myViews[id]->GetPosition(X, Y);
665     W = myViews[id]->WidthWin();
666     H = myViews[id]->HeightWin();
667   }
668 }
669
670 //=======================================================================
671 //function : GetFrame
672 //purpose  :
673 //=======================================================================
674
675 void Draw_Viewer::GetFrame(const Standard_Integer id,
676                            Standard_Integer& xminf, Standard_Integer& yminf,
677                            Standard_Integer& xmaxf, Standard_Integer& ymaxf)
678 {
679   if (Draw_Batch) return;
680   if (myViews[id]) {
681     Standard_Integer X,Y,H,W;
682     GetPosSize(id,X,Y,W,H);
683     xminf = - myViews[id]->dX;
684     xmaxf = W - myViews[id]->dX;
685     yminf = - myViews[id]->dY - H;
686     ymaxf = - myViews[id]->dY;
687   }
688 }
689
690 //=======================================================================
691 //function : FitView
692 //purpose  :
693 //=======================================================================
694
695 void Draw_Viewer::FitView(const Standard_Integer id, const Standard_Integer frame)
696 {
697   if (Draw_Batch) return;
698   if (myViews[id]) {
699
700     // is this the only view in its category
701     Standard_Integer is2d = myViews[id]->Flag2d;
702     Standard_Integer i,nbviews = 0;
703     for (i = 1; i < MAXVIEW; i++) {
704       if (myViews[i]) {
705         if (myViews[i]->Flag2d == is2d) nbviews++;
706       }
707     }
708     Standard_Boolean only = (nbviews == 1);
709
710     Standard_Integer X,Y,H,W;
711     GetPosSize(id,X,Y,W,H);
712     // compute the min max
713     Standard_Integer n = myDrawables.Length();
714     if (n == 0) return;
715 //    Draw_Display DF;
716     curview = myViews[id];
717     Standard_Real umin,umax,vmin,vmax;
718     Standard_Real u1,u2,v1,v2;
719     umin = vmin = DRAWINFINITE;
720     umax = vmax = -DRAWINFINITE;
721
722     for (i = 1; i <= n; i++) {
723       Standard_Boolean d3d = myDrawables(i)->Is3D();
724       if ((d3d && !is2d) || (!d3d && is2d)) {
725         // if this is not the only view recompute...
726         if (!only)
727           DrawOnView(id,myDrawables(i));
728         myDrawables(i)->Bounds(u1,u2,v1,v2);
729         if (u1 < umin) umin = u1;
730         if (u2 > umax) umax = u2;
731         if (v1 < vmin) vmin = v1;
732         if (v2 > vmax) vmax = v2;
733       }
734     }
735     Standard_Real z;
736     umin = umin / curview->Zoom;
737     vmin = vmin / curview->Zoom;
738     umax = umax / curview->Zoom;
739     vmax = vmax / curview->Zoom;
740     if ((umax - umin) < 1.e-6) {
741       if ((vmax - vmin) < 1.e-6)
742         return;
743       else
744         z = ((Standard_Real)(H - 2*frame)) / (vmax - vmin);
745     }
746     else {
747       z = ((Standard_Real)(W - 2*frame)) /((Standard_Real) (umax - umin));
748       if ((vmax - vmin) > 1.e-6) {
749         Standard_Real z2 = ((Standard_Real)(H - 2*frame)) /(vmax - vmin);
750         if (z2 < z) z = z2;
751       }
752     }
753     curview->Zoom = z;
754     curview->dX = (Standard_Integer )(    W / 2 - ((umin+umax) / 2) * z);
755     curview->dY = (Standard_Integer )(  - H / 2 - ((vmin+vmax) / 2) * z);
756   }
757 }
758
759 //=======================================================================
760 //function : PanView
761 //purpose  :
762 //=======================================================================
763
764 void Draw_Viewer::PanView(const Standard_Integer id,
765                           const Standard_Integer DX, const Standard_Integer DY)
766 {
767   if (Draw_Batch) return;
768   if (myViews[id]) {
769     myViews[id]->dX += DX;
770     myViews[id]->dY += DY;
771   }
772 }
773
774
775 //=======================================================================
776 //function : SetPan
777 //purpose  :
778 //=======================================================================
779
780 void Draw_Viewer::SetPan(const Standard_Integer id,
781                          const Standard_Integer DX, const Standard_Integer DY)
782 {
783   if (Draw_Batch) return;
784   if (myViews[id]) {
785     myViews[id]->dX = DX;
786     myViews[id]->dY = DY;
787   }
788 }
789
790 //=======================================================================
791 //function : GetPan
792 //purpose  :
793 //=======================================================================
794
795 void Draw_Viewer::GetPan(const Standard_Integer id,
796                          Standard_Integer& DX, Standard_Integer& DY)
797 {
798   if (Draw_Batch) return;
799   if (myViews[id]) {
800     DX = myViews[id]->dX;
801     DY = myViews[id]->dY;
802   }
803 }
804
805 //=======================================================================
806 //function : HasView
807 //purpose  :
808 //=======================================================================
809
810 Standard_Boolean Draw_Viewer::HasView(const Standard_Integer id) const
811 {
812   if (Draw_Batch) return Standard_False;
813   if ((id < 0) || id >= MAXVIEW) return Standard_False;
814   return myViews[id] != NULL;
815 }
816
817 //=======================================================================
818 //function : DisplayView
819 //purpose  :
820 //=======================================================================
821
822 void Draw_Viewer::DisplayView (const Standard_Integer id) const
823 {
824   if (Draw_Batch) return;
825   if (myViews[id]) myViews[id]->DisplayWindow();
826 }
827
828 //=======================================================================
829 //function : HideView
830 //purpose  :
831 //=======================================================================
832
833 void Draw_Viewer::HideView (const Standard_Integer id) const
834 {
835   if (Draw_Batch) return;
836   if (myViews[id]) {
837     //
838   }
839 }
840
841 //=======================================================================
842 //function : ClearView
843 //purpose  :
844 //=======================================================================
845
846 void Draw_Viewer::ClearView(const Standard_Integer id) const
847 {
848   if (Draw_Batch) return;
849   if (myViews[id]) myViews[id]->Clear();
850 }
851
852 //=======================================================================
853 //function : RemoveView
854 //purpose  :
855 //=======================================================================
856
857 void Draw_Viewer::RemoveView(const Standard_Integer id)
858 {
859   if (Draw_Batch) return;
860   if (myViews[id]) {
861     delete myViews[id];
862     myViews[id] = NULL;
863   }
864 }
865
866 //=======================================================================
867 //function : RepaintView
868 //purpose  :
869 //=======================================================================
870 void Draw_Viewer::RepaintView (const Standard_Integer id) const
871 {
872   if (Draw_Batch) return;
873   if (myViews[id]) {
874     ClearView(id);
875     Standard_Integer n = myDrawables.Length();
876     for (Standard_Integer i = 1; i <= n; i++)
877       DrawOnView(id,myDrawables(i));
878   }
879 }
880
881
882 #ifdef WNT
883 //=======================================================================
884 //function : ResizeView
885 //purpose  : WNT re-drawing optimization
886 //=======================================================================
887 void Draw_Viewer::ResizeView (const Standard_Integer id) const
888 {
889   if (Draw_Batch) return;
890   if (myViews[id] && myViews[id]->GetUseBuffer()) {
891     myViews[id]->InitBuffer();
892     RepaintView(id);
893   }
894 }
895
896 //=======================================================================
897 //function : UpdateView
898 //purpose  : WNT re-drawing optimization
899 //=======================================================================
900 void Draw_Viewer::UpdateView (const Standard_Integer id, const Standard_Boolean forced) const
901 {
902   if (Draw_Batch) return;
903   if (myViews[id]) {
904     if (!myViews[id]->GetUseBuffer() || forced) {
905       RepaintView(id);
906     }
907     // Fast redrawing on WNT
908     if (myViews[id]->GetUseBuffer()) myViews[id]->Redraw();
909   }
910 }
911 #endif
912
913 //=======================================================================
914 //function : ConfigView
915 //purpose  :
916 //=======================================================================
917
918 void Draw_Viewer::ConfigView (const Standard_Integer id) const
919 {
920   if (Draw_Batch) return;
921   if (myViews[id]) {
922     myViews[id]->dX =   myViews[id]->WidthWin() / 2;
923     myViews[id]->dY = - myViews[id]->HeightWin()  / 2;
924
925   }
926 }
927
928 //=======================================================================
929 //function : PostScriptView
930 //purpose  :
931 //=======================================================================
932
933 void Draw_Viewer::PostScriptView (const Standard_Integer id,
934                                   const Standard_Integer VXmin,
935                                   const Standard_Integer VYmin,
936                                   const Standard_Integer VXmax,
937                                   const Standard_Integer VYmax,
938                                   const Standard_Integer PXmin,
939                                   const Standard_Integer PYmin,
940                                   const Standard_Integer PXmax,
941                                   const Standard_Integer PYmax,
942                                   ostream& sortie) const
943 {
944   if (Draw_Batch) return;
945   if (myViews[id]) {
946     ps_vx = VXmin;
947     ps_vy = VYmin;
948     ps_px = PXmin;
949     ps_py = PYmin;
950     ps_kx = ((Standard_Real) (PXmax - PXmin)) / ((Standard_Real) (VXmax - VXmin));
951     ps_ky = ((Standard_Real) (PYmax - PYmin)) / ((Standard_Real) (VYmax - VYmin));
952     ps_stream = &sortie;
953     Standard_Integer n = myDrawables.Length();
954     if (n == 0) return;
955     CurrentMode = POSTSCRIPT;
956     Draw_Display DF = MakeDisplay(id);
957     Standard_Boolean view2d = myViews[id]->Flag2d;
958     for (Standard_Integer i = 1; i <= n; i++)
959       if (myDrawables(i)->Is3D()) {
960         if (!view2d) myDrawables(i)->DrawOn(DF);
961       }
962     else {
963       if (view2d) myDrawables(i)->DrawOn(DF);
964     }
965     sortie << "stroke\n";
966     CurrentMode = DRAW;
967   }
968 }
969
970 //=======================================================================
971 //function : PostColor
972 //purpose  :
973 //=======================================================================
974
975 void Draw_Viewer::PostColor(const Standard_Integer icol,
976                             const Standard_Integer width,
977                             const Standard_Real    gray)
978 {
979   if (Draw_Batch) return;
980   if ((icol < 0) || (icol >= MAXCOLOR)) return;
981   ps_width[icol] = width;
982   ps_gray[icol] = gray;
983 }
984
985 //=======================================================================
986 //function : SaveView
987 //purpose  :
988 //=======================================================================
989
990 Standard_Boolean Draw_Viewer::SaveView(const Standard_Integer id,
991                                        const char* filename)
992 {
993   if (Draw_Batch) return Standard_False;;
994   Flush();
995   if (myViews[id]) {
996     return myViews[id]->Save(filename);
997   }
998   else
999   {
1000     std::cerr << "View " << id << " doesn't exists!\n";
1001     return Standard_False;
1002   }
1003 }
1004
1005 //=======================================================================
1006 //function : RepaintAll
1007 //purpose  :
1008 //=======================================================================
1009
1010 void Draw_Viewer::RepaintAll () const
1011 {
1012   if (Draw_Batch) return;
1013   for (Standard_Integer id = 0; id < MAXVIEW; id++)
1014     RepaintView(id);
1015 }
1016
1017 //=======================================================================
1018 //function : Repaint2D
1019 //purpose  :
1020 //=======================================================================
1021
1022 void Draw_Viewer::Repaint2D () const
1023 {
1024   if (Draw_Batch) return;
1025   for (Standard_Integer id = 0; id < MAXVIEW; id++)
1026     if (myViews[id]) {
1027       if (myViews[id]->Flag2d) RepaintView(id);
1028     }
1029 }
1030
1031 //=======================================================================
1032 //function : Repaint3D
1033 //purpose  :
1034 //=======================================================================
1035
1036 void Draw_Viewer::Repaint3D () const
1037 {
1038   if (Draw_Batch) return;
1039   for (Standard_Integer id = 0; id < MAXVIEW; id++)
1040     if (myViews[id]) {
1041       if (!myViews[id]->Flag2d) RepaintView(id);
1042     }
1043 }
1044
1045 //=======================================================================
1046 //function : GetWindow
1047 //purpose  :
1048 //=======================================================================
1049 unsigned long Draw_Viewer::GetWindow (const Standard_Integer id) const
1050 {
1051   if (Draw_Batch) return 0;
1052   if (myViews[id]) {
1053   #if defined(_WIN32) || defined(__WIN32__)
1054     return (unsigned long)(myViews[id]->win);
1055         #elif !defined(__APPLE__) || defined(MACOSX_USE_GLX)
1056     return myViews[id]->win;
1057         #endif
1058   }
1059   return 0;
1060 }
1061
1062 //=======================================================================
1063 //function : DeleteView
1064 //purpose  :
1065 //=======================================================================
1066
1067 void Draw_Viewer::DeleteView(const Standard_Integer id)
1068 {
1069   if (Draw_Batch) return;
1070   if (myViews[id] != NULL) {
1071     delete myViews[id];
1072     myViews[id] = NULL;
1073   }
1074 }
1075
1076 //=======================================================================
1077 //function : Clear
1078 //purpose  :
1079 //=======================================================================
1080
1081 void Draw_Viewer::Clear()
1082 {
1083   if (Draw_Batch) return;
1084   for (Standard_Integer i = 1; i <= myDrawables.Length(); i++)
1085     myDrawables(i)->Visible(Standard_False);
1086   myDrawables.Clear();
1087   for (Standard_Integer id = 0; id < MAXVIEW; id++)
1088     ClearView(id);
1089 }
1090
1091 //=======================================================================
1092 //function : Clear2D
1093 //purpose  :
1094 //=======================================================================
1095
1096 void Draw_Viewer::Clear2D()
1097 {
1098   if (Draw_Batch) return;
1099   Standard_Integer i = 1;
1100   while (i <= myDrawables.Length()) {
1101     if (myDrawables(i)->Is3D())
1102       i++;
1103     else {
1104       myDrawables(i)->Visible(Standard_False);
1105       myDrawables.Remove(i);
1106     }
1107   }
1108   for (Standard_Integer id = 0; id < MAXVIEW; id++) {
1109     if (myViews[id]) {
1110       if (myViews[id]->Flag2d)
1111         ClearView(id);
1112     }
1113   }
1114 }
1115
1116 //=======================================================================
1117 //function : Clear3D
1118 //purpose  :
1119 //=======================================================================
1120
1121 void Draw_Viewer::Clear3D()
1122 {
1123   if (Draw_Batch) return;
1124   Standard_Integer i = 1;
1125   while (i <= myDrawables.Length()) {
1126     if (myDrawables(i)->Is3D()) {
1127       myDrawables(i)->Visible(Standard_False);
1128       myDrawables.Remove(i);
1129     }
1130     else
1131       i++;
1132   }
1133   for (Standard_Integer id = 0; id < MAXVIEW; id++) {
1134     if (myViews[id]) {
1135       if (!myViews[id]->Flag2d)
1136         ClearView(id);
1137     }
1138   }
1139 }
1140
1141 //=======================================================================
1142 //function : Flush
1143 //purpose  :
1144 //=======================================================================
1145
1146 void Draw_Viewer::Flush()
1147 {
1148   if (Draw_Batch) return;
1149   Draw_Window::Flush();
1150 }
1151
1152 //=======================================================================
1153 //function : DrawOnView
1154 //purpose  :
1155 //=======================================================================
1156
1157 void Draw_Viewer::DrawOnView(const Standard_Integer id,
1158                              const Handle(Draw_Drawable3D)& D) const
1159 {
1160   if (Draw_Batch) return;
1161   if (myViews[id]) {
1162     Draw_Display d = MakeDisplay(id);
1163     xmin = ymin = DRAWINFINITE;
1164     xmax = ymax = -DRAWINFINITE;
1165
1166     Standard_Boolean view2d = myViews[id]->Flag2d;
1167     myViews[id]->ResetFrame();
1168     if ((D->Is3D() && !view2d) ||
1169         (!D->Is3D() && view2d)) {
1170       D->DrawOn(d);
1171
1172       if (CurrentMode == DRAW)
1173         D->SetBounds(xmin,xmax,ymin,ymax);
1174       d.Flush();
1175     }
1176   }
1177 }
1178
1179 //=======================================================================
1180 //function : HighlightOnView
1181 //purpose  :
1182 //=======================================================================
1183
1184 void Draw_Viewer::HighlightOnView (const Standard_Integer id,
1185                                    const Handle(Draw_Drawable3D)& D,
1186                                    const Draw_ColorKind C) const
1187 {
1188   if (Draw_Batch) return;
1189   highlight = Standard_True;
1190   highlightcol = C;
1191   DrawOnView(id,D);
1192   highlight = Standard_False;
1193 }
1194
1195 //=======================================================================
1196 //function : AddDrawable
1197 //purpose  :
1198 //=======================================================================
1199
1200 void Draw_Viewer::AddDrawable (const Handle(Draw_Drawable3D)& D)
1201 {
1202   if (Draw_Batch) return;
1203   if (!D.IsNull() && !D->Visible()) {
1204     myDrawables.Append(D);
1205     D->Visible(Standard_True);
1206   }
1207 }
1208
1209 //=======================================================================
1210 //function : RemoveDrawable
1211 //purpose  :
1212 //=======================================================================
1213
1214 void Draw_Viewer::RemoveDrawable (const Handle(Draw_Drawable3D)& D)
1215 {
1216   if (Draw_Batch) return;
1217   if (!D.IsNull() && D->Visible()) {
1218     Standard_Integer index;
1219     for (index = 1; index <= myDrawables.Length(); index++) {
1220       if (myDrawables(index) == D) {
1221         D->Visible(Standard_False);
1222         myDrawables.Remove(index);
1223         return;
1224       }
1225     }
1226   }
1227 }
1228
1229 //=======================================================================
1230 //function : MakeDisplay
1231 //purpose  : return a display on the view
1232 //=======================================================================
1233
1234 Draw_Display Draw_Viewer::MakeDisplay (const Standard_Integer id) const
1235 {
1236   if (Draw_Batch) {Draw_Display dis;return dis;}
1237   curviewId = id;
1238   curview = myViews[id];
1239   int GXcopy = 0x3;
1240   nbseg = 0;
1241   Draw_Color initcol(Draw_blanc);
1242   // to force setting the color
1243   currentcolor = Draw_Color(Draw_rouge);
1244   Draw_Display dis;
1245   dis.SetColor(initcol);
1246   dis.SetMode(GXcopy);
1247   return dis;
1248 }
1249
1250 //=======================================================================
1251 //function : Select
1252 //purpose  :
1253 //=======================================================================
1254 void Draw_Viewer::Select (Standard_Integer& id, Standard_Integer& X, Standard_Integer& Y,
1255                           Standard_Integer& Button, Standard_Boolean wait)
1256 {
1257   if (Draw_Batch) return;
1258   Flush();
1259 #if !defined(_WIN32) && !defined(__WIN32__) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
1260   if (!wait) {
1261     if (id >=0 && id < MAXVIEW) {
1262       if (myViews[id]) myViews[id]->Wait(wait);
1263     }
1264   }
1265   else {
1266     for(int i=0 ; i<MAXVIEW ; i++)
1267       if (myViews[i])  myViews[i]->Wait(wait);
1268   }
1269
1270   Standard_Boolean again = Standard_True;
1271   while (again) {
1272
1273     Event ev;
1274     ev.type = 0;
1275
1276     GetNextEvent(ev);
1277
1278     switch (ev.type) {
1279
1280     case ButtonPress :
1281       Standard_Integer iv;
1282       for (iv = 0; iv < MAXVIEW; iv++) {
1283         if (myViews[iv]) {
1284           if (myViews[iv]->win == ev.window)
1285             break;
1286         }
1287       }
1288       if (wait || id == iv) {
1289         if (iv < MAXVIEW) {
1290           id = iv;
1291           X = ev.x;
1292           Y = ev.y;
1293           Button = ev.button;
1294         }
1295         else {
1296           id = -1;
1297         }
1298         again = Standard_False;
1299       }
1300       break;
1301
1302     case MotionNotify :
1303       if (wait) break;
1304       X = ev.x;
1305       Y = ev.y;
1306       Button = 0;
1307       again = Standard_False;
1308       break;
1309     }
1310   }
1311
1312   if (id != -1) {
1313     X =  X - myViews[id]->dX;
1314     Y = -Y - myViews[id]->dY;
1315   }
1316   if (!wait) myViews[id]->Wait(!wait);
1317 #elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
1318   Standard_Integer aWindowNumber;
1319
1320   id = MAXVIEW;
1321   while (id >= MAXVIEW)
1322   {
1323     GetNextEvent(wait, aWindowNumber, X, Y, Button);
1324     
1325     if (Y < 0)
1326     {
1327       continue; // mouse clicked on window title
1328     }
1329
1330     for (Standard_Integer anIter = 0; anIter < MAXVIEW; anIter++)
1331     {
1332       if (myViews[anIter] && myViews[anIter]->IsEqualWindows (aWindowNumber))
1333       {
1334         id = anIter;
1335       }
1336     }
1337   }
1338
1339   X =  X - myViews[id]->dX;
1340   Y = -Y - myViews[id]->dY;
1341
1342 #else
1343   HANDLE hWnd;
1344
1345   id = MAXVIEW; //:abv 29.05.02: cycle for working in console mode
1346   while ( id >= MAXVIEW ) {
1347     if (wait)
1348       Draw_Window::SelectWait(hWnd, X, Y, Button);
1349     else
1350       Draw_Window::SelectNoWait(hWnd, X, Y, Button);
1351
1352     // Recherche du numero de la vue grace au HANDLE
1353     for(int i=0 ; i<MAXVIEW ; i++)
1354       if (myViews[i] && myViews[i]->win == hWnd )  id = i;
1355   }
1356   X =  X - myViews[id]->dX;
1357   Y = -Y - myViews[id]->dY;
1358 #endif
1359 }
1360
1361 //=======================================================================
1362 //function : Pick
1363 //purpose  :
1364 //=======================================================================
1365
1366 Standard_Integer Draw_Viewer::Pick(const Standard_Integer id,
1367                           const Standard_Integer X, const Standard_Integer Y, const Standard_Integer Prec,
1368                           Handle(Draw_Drawable3D)& D,
1369                           const Standard_Integer first) const
1370 {
1371   if (Draw_Batch) return 0;
1372   if (myViews[id] == NULL)
1373     return 0;
1374
1375   // is this the only view in its category
1376   Standard_Integer is2d = myViews[id]->Flag2d;
1377   Standard_Integer i,nbviews = 0;
1378   for (i = 0; i < MAXVIEW; i++) {
1379     if (myViews[i]) {
1380       if (myViews[i]->Flag2d == is2d) nbviews++;
1381     }
1382   }
1383   Standard_Boolean only = (nbviews == 1);
1384
1385   CurrentMode = PICK;
1386   xpick = X;
1387   ypick = Y;
1388   precpick = Prec;
1389   found = Standard_False;
1390   Standard_Real x1,x2,y1,y2;
1391   for (i = first+1; i <= myDrawables.Length(); i++) {
1392     Standard_Boolean reject = Standard_False;
1393     // rejection if only view
1394     if (only) {
1395       myDrawables(i)->Bounds(x1,x2,y1,y2);
1396       if ((xpick+Prec < x1) || (xpick-Prec > x2) ||
1397           (ypick+Prec < y1) || (ypick-Prec > y2))
1398         reject = Standard_True;
1399     }
1400     if (!reject) {
1401       DrawOnView(id,myDrawables(i));
1402       if (found)
1403         break;
1404     }
1405   }
1406   CurrentMode = DRAW;
1407   found = Standard_False;
1408   if (i <= myDrawables.Length())
1409     D = myDrawables(i);
1410   else
1411     i = 0;
1412   return i;
1413 }
1414
1415 //=======================================================================
1416 //function : LastPick
1417 //purpose  :
1418 //=======================================================================
1419
1420 void Draw_Viewer::LastPick(gp_Pnt& P1, gp_Pnt& P2, Standard_Real& Param)
1421 {
1422   if (Draw_Batch) return;
1423   P1    = lastPickP1;
1424   P2    = lastPickP2;
1425   Param = lastPickParam;
1426 }
1427
1428 //=======================================================================
1429 //function : ~Draw_Viewer
1430 //purpose  :
1431 //=======================================================================
1432
1433 Draw_Viewer::~Draw_Viewer()
1434 {
1435   if (Draw_Batch) return;
1436   for (Standard_Integer id = 0; id < MAXVIEW; id++)
1437     DeleteView(id);
1438 }
1439
1440 //=======================================================================
1441 //function : operator<<
1442 //purpose  :
1443 //=======================================================================
1444
1445 Draw_Viewer& Draw_Viewer::operator<<(const Handle(Draw_Drawable3D)& d3d)
1446 {
1447   if (Draw_Batch) return *this;
1448   if (!d3d.IsNull()) {
1449     AddDrawable(d3d);
1450     for (Standard_Integer id = 0; id < MAXVIEW; id++)
1451       DrawOnView(id,d3d);
1452   }
1453   return *this;
1454 }
1455
1456 //=======================================================================
1457 //function : GetDrawables
1458 //purpose  :
1459 //=======================================================================
1460 const Draw_SequenceOfDrawable3D& Draw_Viewer::GetDrawables()
1461 {
1462   return myDrawables;
1463 }
1464
1465 // *******************************************************************
1466 // DISPLAY methods
1467 // *******************************************************************
1468
1469
1470 void Draw_Flush()
1471 {
1472   if (Draw_Batch) return;
1473   if (highlight) curview->SetColor(highlightcol.ID());
1474   curview->DrawSegments(segm,nbseg);
1475   nbseg = 0;
1476 }
1477
1478 //=======================================================================
1479 //function : SetColor
1480 //purpose  :
1481 //=======================================================================
1482
1483 void Draw_Display::SetColor (const Draw_Color& col) const
1484 {
1485   if (Draw_Batch) return;
1486   if (col.ID() == currentcolor.ID()) return;
1487
1488   currentcolor = col;
1489   switch (CurrentMode) {
1490
1491   case DRAW :
1492     Draw_Flush();
1493     curview->SetColor(col.ID());
1494     break;
1495
1496   case POSTSCRIPT :
1497     (*ps_stream) << "stroke\nnewpath\n";
1498     (*ps_stream) << ps_width[col.ID()]<<" setlinewidth\n";
1499     (*ps_stream) << ps_gray[col.ID()]<<" setgray\n";
1500
1501   case PICK :
1502     break;
1503   }
1504 }
1505
1506 //=======================================================================
1507 //function : SetMode
1508 //purpose  :
1509 //=======================================================================
1510
1511 void Draw_Display::SetMode (const Standard_Integer M) const
1512 {
1513   if (Draw_Batch) return;
1514   switch (CurrentMode) {
1515
1516   case DRAW :
1517     Draw_Flush();
1518     curview->SetMode(M);
1519     break;
1520
1521   case PICK :
1522   case POSTSCRIPT :
1523     break;
1524   }
1525 }
1526
1527 //=======================================================================
1528 //function : Zoom
1529 //purpose  :
1530 //=======================================================================
1531
1532 Standard_Real Draw_Display::Zoom() const
1533 {
1534   if (Draw_Batch) return 1.;
1535   return curview->Zoom;
1536 }
1537
1538 //=======================================================================
1539 //function : Flush
1540 //purpose  :
1541 //=======================================================================
1542
1543 void Draw_Display::Flush () const
1544 {
1545   if (Draw_Batch) return;
1546   Draw_Flush();
1547 }
1548
1549 //=======================================================================
1550 //function : DrawString
1551 //purpose  :
1552 //=======================================================================
1553
1554 void Draw_Display::DrawString(const gp_Pnt2d& ppt,
1555                               const Standard_CString S,
1556                               const Standard_Real moveX,
1557                               const Standard_Real moveY)
1558 {
1559   if (Draw_Batch) return;
1560   if (ppt.X() > 1.e09 || ppt.X() < -1.e09 ) return;
1561   if (ppt.Y() > 1.e09 || ppt.Y() < -1.e09 ) return;
1562
1563   gp_Pnt2d pt(ppt.X()*curview->Zoom,ppt.Y()*curview->Zoom);
1564
1565   if (pt.X() > 1.e09 || pt.X() < -1.e09 ) return;
1566   if (pt.Y() > 1.e09 || pt.Y() < -1.e09 ) return;
1567
1568   switch (CurrentMode) {
1569
1570   case DRAW :
1571     {
1572       int X =   (int) ( pt.X() + moveX + curview->dX);
1573       int Y =   (int) (-pt.Y() + moveY - curview->dY);
1574       curview->DrawString(X,Y,(char *)S);
1575       if (Draw_Bounds) {
1576         if (pt.X() + moveX > xmax) xmax = pt.X();
1577         if (pt.X() + moveX < xmin) xmin = pt.X();
1578         if (-pt.Y() - moveY > ymax) ymax = -pt.Y();
1579         if (-pt.Y() - moveY < ymin) ymin = -pt.Y();
1580       }
1581     }
1582     break;
1583
1584   case POSTSCRIPT :
1585     {
1586       Standard_Integer x = (Standard_Integer )( (pt.X() + moveX - ps_vx) * ps_kx + ps_px);
1587       Standard_Integer y = (Standard_Integer )( (pt.Y() + moveY - ps_vy) * ps_ky + ps_py);
1588       (*ps_stream) <<"stroke\n";
1589       (*ps_stream) << x << " " << y << " m\n";
1590       (*ps_stream) <<"("<<S<<") show\nnewpath\n";
1591     }
1592     break;
1593
1594   case PICK :
1595     break;
1596   }
1597 }
1598
1599 //=======================================================================
1600 //function : DrawString
1601 //purpose  :
1602 //=======================================================================
1603
1604 void Draw_Display::DrawString(const gp_Pnt2d& ppt,
1605                               const Standard_CString S)
1606 {
1607   if (Draw_Batch) return;
1608   DrawString(ppt,S,0.0,0.0);
1609 }
1610
1611 //=======================================================================
1612 //function : DrawString
1613 //purpose  :
1614 //=======================================================================
1615
1616 void Draw_Display::DrawString(const gp_Pnt& pt,
1617                               const Standard_CString S,
1618                               const Standard_Real moveX,
1619                               const Standard_Real moveY)
1620 {
1621   if (Draw_Batch) return;
1622   DrawString(Project(pt),S,moveX,moveY);
1623 }
1624
1625 //=======================================================================
1626 //function : DrawString
1627 //purpose  :
1628 //=======================================================================
1629
1630 void Draw_Display::DrawString(const gp_Pnt& pt,
1631                               const Standard_CString S)
1632 {
1633   if (Draw_Batch) return;
1634   DrawString(Project(pt),S,0.0,0.0);
1635 }
1636
1637
1638 // *******************************************************************
1639 // Drawing data static variables
1640 // *******************************************************************
1641 static gp_Pnt2d PtCur;  // current 2D point
1642 static gp_Pnt PtPers;   // current 3D point for Pers
1643
1644 //=======================================================================
1645 //function : Project
1646 //purpose  :
1647 //=======================================================================
1648
1649 void Draw_Display::Project(const gp_Pnt& p, gp_Pnt2d& p2d) const
1650 {
1651   if (Draw_Batch) return;
1652   gp_Pnt pt = p;
1653   pt.Transform(curview->Matrix);
1654   Standard_Real xp,yp,zp;
1655   pt.Coord(xp,yp,zp);
1656   if (curview->FlagPers) {
1657     xp = xp*curview->FocalDist/(curview->FocalDist-zp);
1658     yp = yp*curview->FocalDist/(curview->FocalDist-zp);
1659   }
1660   p2d.SetCoord(xp,yp);
1661 }
1662
1663 //=======================================================================
1664 //function : Draw_Display
1665 //purpose  :
1666 //=======================================================================
1667
1668 Draw_Display::Draw_Display ()
1669 {
1670   if (Draw_Batch) return;
1671   if (curview) {
1672     PtPers.SetCoord(0,0,0);
1673     PtPers.Transform(curview->Matrix);
1674     PtCur.SetCoord(PtPers.X()*curview->Zoom,PtPers.Y()*curview->Zoom);
1675   }
1676 }
1677
1678 //=======================================================================
1679 //function : MoveTo 2D
1680 //purpose  :
1681 //=======================================================================
1682
1683 void Draw_Display::MoveTo (const gp_Pnt2d& pp)
1684 {
1685   if (Draw_Batch) return;
1686   gp_Pnt2d pt(pp.X() * curview->Zoom, pp.Y() * curview->Zoom);
1687   switch (CurrentMode) {
1688
1689   case DRAW :
1690     PtCur = pt;
1691     if (Draw_Bounds) {
1692       if (pt.X() > xmax) xmax = pt.X();
1693       if (pt.X() < xmin) xmin = pt.X();
1694       if (pt.Y() > ymax) ymax = pt.Y();
1695       if (pt.Y() < ymin) ymin = pt.Y();
1696     }
1697     break;
1698
1699   case PICK :
1700     PtCur = pt;
1701     break;
1702
1703   case POSTSCRIPT :
1704     {
1705       Standard_Integer x = (Standard_Integer )( (pt.X() - ps_vx) * ps_kx + ps_px);
1706       Standard_Integer y = (Standard_Integer )( (pt.Y() - ps_vy) * ps_ky + ps_py);
1707       (*ps_stream) <<"stroke\nnewpath\n"<< x << " " << y << " m\n";
1708     }
1709     break;
1710   }
1711 }
1712
1713 //=======================================================================
1714 //function : DrawTo 2D
1715 //purpose  :
1716 //=======================================================================
1717 inline  Standard_Integer CalculRegion(const Standard_Real x,
1718                                       const Standard_Real y,
1719                                       const Standard_Real x1,
1720                                       const Standard_Real y1,
1721                                       const Standard_Real x2,
1722                                       const Standard_Real y2) {
1723   Standard_Integer r;
1724   if(x<x1) { r=1; }  else { if(x>x2) { r=2; } else { r=0; } }
1725   if(y<y1) { r|=4; } else { if(y>y2) { r|=8; } }
1726   return(r);
1727 }
1728
1729 Standard_Boolean Trim(gp_Pnt2d& P1,gp_Pnt2d& P2,
1730                       Standard_Real x0,
1731                       Standard_Real y0,
1732                       Standard_Real x1,
1733                       Standard_Real y1) {
1734   Standard_Real xa=P1.X(),ya=P1.Y(),xb=P2.X(),yb=P2.Y();
1735
1736   Standard_Integer regiona=0,regionb=0;
1737   regiona = CalculRegion(xa,ya,x0,y0,x1,y1);
1738   regionb = CalculRegion(xb,yb,x0,y0,x1,y1);
1739   if((regiona & regionb)==0) {
1740     Standard_Real dx=xb-xa;
1741     Standard_Real dy=yb-ya;
1742     Standard_Real dab=sqrt(dx*dx+dy*dy);
1743     if(dab<1e-10) return(Standard_False);
1744     dx/=dab;
1745     dy/=dab;
1746
1747     Standard_Real xm,ym,mfenx,mfeny;
1748     mfenx=xm=0.5*(x0+x1);
1749     mfeny=ym=0.5*(y0+y1);
1750     x1-=x0;     y1-=y0;
1751     Standard_Real d=sqrt(x1*x1+y1*y1) * 2;
1752
1753     Standard_Real p=(xm-xa)*dx+(ym-ya)*dy;
1754     xm=xa+p*dx;
1755     ym=ya+p*dy;
1756     gp_Pnt2d Pm(xm,ym);
1757
1758     gp_Pnt2d MFen(mfenx,mfeny);
1759     if(MFen.SquareDistance(Pm) > d*d) return(Standard_False);
1760
1761     Standard_Real PmDistP1 = Pm.Distance(P1);
1762     Standard_Real PmDistP2 = Pm.Distance(P2);
1763
1764     Standard_Real amab = (xm-xa)*(xb-xa)+(ym-ya)*(yb-ya);
1765
1766     if(amab > 0) { //-- M est compris entre A et B
1767       if(PmDistP1 > d) {
1768         P1.SetCoord(xm-d*dx,ym-d*dy);
1769       }
1770       if(PmDistP2 >d) {
1771         P2.SetCoord(xm+d*dx,ym+d*dy);
1772       }
1773     }
1774     else if(PmDistP1 < PmDistP2) {  //-- On a     M    P1 P2
1775       if(PmDistP2 > d) {
1776         P2.SetCoord(xm+d*dx,ym+d*dy);
1777       }
1778     }
1779     else { //-- On a      P1 P2 M
1780       if(PmDistP1 > d) {
1781         P1.SetCoord(xm-d*dx,ym-d*dy);
1782       }
1783     }
1784     return(Standard_True);
1785   }
1786   else return(Standard_False);
1787 }
1788
1789
1790
1791
1792 void Draw_Display::DrawTo (const gp_Pnt2d& pp2)
1793 {
1794   if (Draw_Batch) return;
1795   if (pp2.X() > 1.e09 || pp2.X() < -1.e09 ) return;
1796   if (pp2.Y() > 1.e09 || pp2.Y() < -1.e09 ) return;
1797
1798   gp_Pnt2d p2(pp2.X() * curview->Zoom, pp2.Y() * curview->Zoom);
1799
1800   if (p2.X() > 1.e09 || p2.X() < -1.e09 ) return;
1801   if (p2.Y() > 1.e09 || p2.Y() < -1.e09 ) return;
1802
1803   gp_Pnt2d p1 = PtCur;
1804   if (p1.X() > 1.e09 || p1.X() < -1.e09 ) return;
1805   if (p1.Y() > 1.e09 || p1.Y() < -1.e09 ) return;
1806
1807   PtCur = p2;
1808
1809   switch (CurrentMode) {
1810
1811   case DRAW : {
1812
1813 #if 1
1814     Standard_Integer x0,y0,x1,y1;
1815     curview->GetFrame(x0,y0,x1,y1);
1816
1817
1818     //Standard_Integer qx0,qy0,qx1,qy1;
1819     //curview->viewer->GetFrame(curview->id,qx0,qy0,qx1,qy1);
1820     //if(qx0!=x0 || qx1!=x1 || qy0!=y0 || qy1!=y1) {
1821     //  x0=qx0; x1=qx1; y0=qy0; y1=qy1;
1822     //}
1823
1824
1825
1826     gp_Pnt2d PI1(p1);
1827     gp_Pnt2d PI2(p2);
1828
1829     if(Trim(PI1,PI2,x0,y0,x1,y1)) {
1830       segm[nbseg].Init((Standard_Integer )( PI1.X() + curview->dX),
1831                        (Standard_Integer )(-PI1.Y() - curview->dY),
1832                        (Standard_Integer )( PI2.X() + curview->dX),
1833                        (Standard_Integer )(-PI2.Y() - curview->dY));
1834
1835       nbseg++;
1836     }
1837 #else
1838     segm[nbseg].Init(( p1.X() + curview->dX),
1839                      (-p1.Y() - curview->dY),
1840                      ( p2.X() + curview->dX),
1841                      (-p2.Y() - curview->dY));
1842
1843     nbseg++;
1844 #endif
1845     if (nbseg == MAXSEGMENT) {
1846       Draw_Flush();
1847     }
1848     if (Draw_Bounds) {
1849       if (p2.X() > xmax) xmax = p2.X();
1850       if (p2.X() < xmin) xmin = p2.X();
1851       if (p2.Y() > ymax) ymax = p2.Y();
1852       if (p2.Y() < ymin) ymin = p2.Y();
1853     }
1854   }
1855     break;
1856
1857   case PICK :
1858     if (!found) {
1859       Standard_Integer x1 =  (int) p1.X() ;
1860       Standard_Integer y1 =  (int) p1.Y() ;
1861       Standard_Integer x2 =  (int) p2.X() ;
1862       Standard_Integer y2 =  (int) p2.Y() ;
1863       if ((x1 >= xpick + precpick) && (x2 >= xpick + precpick)) break;
1864       if ((x1 <= xpick - precpick) && (x2 <= xpick - precpick)) break;
1865       if ((y1 >= ypick + precpick) && (y2 >= ypick + precpick)) break;
1866       if ((y1 <= ypick - precpick) && (y2 <= ypick - precpick)) break;
1867
1868       Standard_Boolean inside = Standard_True;
1869       if ((x1 > xpick + precpick) || (x2 > xpick + precpick)) {
1870         Standard_Real y = (Standard_Real) y1 +
1871           (Standard_Real) (y2-y1) * (Standard_Real) (xpick+precpick-x1) /
1872             (Standard_Real) (x2 - x1);
1873         if ( (y < ypick+precpick) && (y > ypick - precpick)) {
1874           found = Standard_True;
1875           lastPickParam = (Standard_Real) (xpick - x1) /
1876             (Standard_Real) (x2 - x1);
1877           break;
1878         }
1879         else
1880           inside = Standard_False;
1881       }
1882
1883       if ((x1 < xpick - precpick) || (x2 < xpick - precpick)) {
1884         Standard_Real y = (Standard_Real) y1 +
1885           (Standard_Real) (y2-y1) * (Standard_Real) (xpick-precpick-x1) /
1886             (Standard_Real) (x2 - x1);
1887         if ( (y < ypick+precpick) && (y > ypick - precpick)) {
1888           found = Standard_True;
1889           lastPickParam = (Standard_Real) (xpick - x1) /
1890             (Standard_Real) (x2 - x1);
1891           break;
1892         }
1893         else
1894           inside = Standard_False;
1895       }
1896
1897
1898       if ((y1 > ypick + precpick) || (y2 > ypick + precpick)) {
1899         Standard_Real x = (Standard_Real) x1 +
1900           (Standard_Real) (x2-x1) * (Standard_Real) (ypick+precpick-y1) /
1901             (Standard_Real) (y2 - y1);
1902         if ( (x < xpick+precpick) && (x > xpick - precpick)) {
1903           found = Standard_True;
1904           lastPickParam = (Standard_Real) (ypick - y1) /
1905             (Standard_Real) (y2 - y1);
1906           break;
1907         }
1908         else
1909           inside = Standard_False;
1910       }
1911
1912
1913       if ((y1 < ypick - precpick) || (y2 < ypick - precpick)) {
1914         Standard_Real x = (Standard_Real) x1 +
1915           (Standard_Real) (x2-x1) * (Standard_Real) (ypick-precpick-y1) /
1916             (Standard_Real) (y2 - y1);
1917         if ( (x < xpick+precpick) && (x > xpick - precpick)) {
1918           found = Standard_True;
1919           lastPickParam = (Standard_Real) (ypick - y1) /
1920             (Standard_Real) (y2 - y1);
1921           break;
1922         }
1923         else
1924           inside = Standard_False;
1925       }
1926     found = found || inside;
1927       if (found) {
1928         if (Abs(x2-x1) > Abs(y2-y1)) {
1929           if (Abs(x2-x1) < 1e-5)  lastPickParam = 0;
1930           else
1931             lastPickParam = (Standard_Real)(xpick - x1) /
1932               (Standard_Real)(x2 - x1);
1933         }
1934         else {
1935           if (Abs(y2-y1) < 1e-5)  lastPickParam = 0;
1936           else
1937             lastPickParam = (Standard_Real)(ypick - y1) /
1938               (Standard_Real)(y2 - y1);
1939         }
1940       }
1941     }
1942     break;
1943
1944   case POSTSCRIPT :
1945     {
1946       Standard_Integer x = (Standard_Integer )( (p2.X() - ps_vx) * ps_kx + ps_px);
1947       Standard_Integer y = (Standard_Integer )( (p2.Y() - ps_vy) * ps_ky + ps_py);
1948       (*ps_stream) << x << " " << y << " l\n";
1949     }
1950     break;
1951   }
1952
1953 }
1954
1955 //=======================================================================
1956 //function : MoveTo
1957 //purpose  :
1958 //=======================================================================
1959
1960 void Draw_Display::MoveTo (const gp_Pnt& pt)
1961 {
1962   if (Draw_Batch) return;
1963   if (CurrentMode == PICK) {
1964     if (!found) lastPickP1 = pt;
1965     else return;
1966   }
1967   PtPers = pt;
1968   PtPers.Transform(curview->Matrix);
1969   Standard_Real xp = PtPers.X();
1970   Standard_Real yp = PtPers.Y();
1971   if (curview->FlagPers) {
1972     Standard_Real ZPers = PtPers.Z();
1973     if (ZPers < curview->FocalDist*precpers) {
1974       xp=xp*curview->FocalDist/(curview->FocalDist-ZPers);
1975       yp=yp*curview->FocalDist/(curview->FocalDist-ZPers);
1976     }
1977   }
1978   MoveTo(gp_Pnt2d(xp,yp));
1979 }
1980
1981 //=======================================================================
1982 //function : DrawTo
1983 //purpose  :
1984 //=======================================================================
1985
1986 void Draw_Display::DrawTo (const gp_Pnt& pt)
1987 {
1988   if (Draw_Batch) return;
1989   if ((CurrentMode == PICK) && found) return;
1990
1991   gp_Pnt pt2 = pt.Transformed(curview->Matrix);
1992   Standard_Real xp2 = pt2.X();
1993   Standard_Real yp2 = pt2.Y();
1994
1995   if (curview->FlagPers) {
1996     Standard_Real xp1 = PtPers.X();
1997     Standard_Real yp1 = PtPers.Y();
1998     Standard_Real zp1 = PtPers.Z();
1999     Standard_Real zp2 = pt2.Z();
2000     PtPers   = pt2;
2001     if ((zp1 >= curview->FocalDist*precpers) &&
2002         (zp2 >= curview->FocalDist*precpers) ) {
2003       return;  // segment is not visible in perspective (behind the eye)
2004     }
2005     else if (zp1 >= curview->FocalDist*precpers) {
2006       xp1=xp1+(xp2-xp1)*(curview->FocalDist*precpers-zp1)/(zp2-zp1);
2007       yp1=yp1+(yp2-yp1)*(curview->FocalDist*precpers-zp1)/(zp2-zp1);
2008       zp1=curview->FocalDist*precpers;
2009       xp1=xp1*curview->FocalDist/(curview->FocalDist-zp1);
2010       yp1=yp1*curview->FocalDist/(curview->FocalDist-zp1);
2011       MoveTo(gp_Pnt2d(xp1*curview->Zoom,yp1*curview->Zoom));
2012     }
2013     else if (zp2 >= curview->FocalDist*precpers) {
2014       xp2=xp2+(xp1-xp2)*(curview->FocalDist*precpers-zp2)/(zp1-zp2);
2015       yp2=yp2+(yp1-yp2)*(curview->FocalDist*precpers-zp2)/(zp1-zp2);
2016       zp2=curview->FocalDist*precpers;
2017     }
2018     xp2=xp2*curview->FocalDist/(curview->FocalDist-zp2);
2019     yp2=yp2*curview->FocalDist/(curview->FocalDist-zp2);
2020   }
2021   DrawTo(gp_Pnt2d(xp2,yp2));
2022   if (CurrentMode == PICK) {
2023     if      (!found)    lastPickP1 = pt;
2024     else                lastPickP2 = pt;
2025   }
2026 }
2027
2028 //=======================================================================
2029 //function : Draw
2030 //purpose  :
2031 //=======================================================================
2032
2033 void Draw_Display::Draw (const gp_Pnt& p1, const gp_Pnt& p2)
2034 {
2035   if (Draw_Batch) return;
2036   MoveTo(p1);
2037   DrawTo(p2);
2038 }
2039
2040 //=======================================================================
2041 //function : Draw
2042 //purpose  :
2043 //=======================================================================
2044
2045 void Draw_Display::Draw(const gp_Pnt2d& p1, const gp_Pnt2d& p2)
2046 {
2047   if (Draw_Batch) return;
2048   MoveTo(p1);
2049   DrawTo(p2);
2050 }
2051
2052
2053 //=======================================================================
2054 //function : ViewId
2055 //purpose  :
2056 //=======================================================================
2057
2058 Standard_Integer Draw_Display::ViewId() const
2059 {
2060   if (Draw_Batch) return 0;
2061   return curviewId;
2062 }
2063
2064
2065 //=======================================================================
2066 //function : HasPicked
2067 //purpose  :
2068 //=======================================================================
2069
2070 Standard_Boolean Draw_Display::HasPicked() const
2071 {
2072   if (Draw_Batch) return Standard_False;
2073   return found;
2074 }
2075