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