b311480e |
1 | // Created on: 1992-04-06 |
2 | // Created by: Remi LEQUETTE |
3 | // Copyright (c) 1992-1999 Matra Datavision |
973c2be1 |
4 | // Copyright (c) 1999-2014 OPEN CASCADE SAS |
b311480e |
5 | // |
973c2be1 |
6 | // This file is part of Open CASCADE Technology software library. |
b311480e |
7 | // |
d5f74e42 |
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 |
973c2be1 |
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. |
b311480e |
13 | // |
973c2be1 |
14 | // Alternatively, this file may be used under the terms of Open CASCADE |
15 | // commercial license or contractual agreement. |
b311480e |
16 | |
7fd59977 |
17 | #include <Draw_Viewer.hxx> |
96f3bacc |
18 | #include <Draw_View.hxx> |
7fd59977 |
19 | |
20 | #include <gp_Pnt.hxx> |
21 | #include <gp_Pnt2d.hxx> |
22 | #include <Draw_Window.hxx> |
23 | #include <Draw_Display.hxx> |
ad03c234 |
24 | #include <TCollection_AsciiString.hxx> |
7fd59977 |
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; |
04232180 |
50 | static std::ostream* ps_stream; |
7fd59977 |
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 | |
7fd59977 |
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 |
96f3bacc |
102 | myViews[id]->SetDx(W / 2); |
103 | myViews[id]->SetDy(- H / 2); |
7fd59977 |
104 | |
105 | if (!myViews[id]->Init(typ)) |
106 | DeleteView(id); |
107 | |
108 | RepaintView(id); |
109 | } |
110 | } |
111 | |
57c28b61 |
112 | #ifdef _WIN32 |
7fd59977 |
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 |
96f3bacc |
132 | myViews[id]->SetDx( W / 2); |
133 | myViews[id]->SetDy(-H / 2); |
7fd59977 |
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 | |
96f3bacc |
158 | myViews[id]->SetDx(myViews[id]->WidthWin() / 2); |
159 | myViews[id]->SetDy(-myViews[id]->HeightWin() / 2); |
7fd59977 |
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; |
ad03c234 |
177 | if(myViews[id]) myViews[id]->SetTitle (name); |
7fd59977 |
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]) { |
96f3bacc |
189 | myViews[id]->Init(myViews[id]->Type()); |
7fd59977 |
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 | { |
96f3bacc |
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); |
7fd59977 |
209 | Standard_Integer X,Y,W,H; |
210 | GetPosSize(id,X,Y,W,H); |
96f3bacc |
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); |
7fd59977 |
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]) { |
96f3bacc |
236 | gp_Trsf T = myViews[id]->GetMatrix(); |
7fd59977 |
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); |
96f3bacc |
261 | myViews[id]->Transform(T); |
7fd59977 |
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]) |
96f3bacc |
275 | myViews[id]->SetFocalDistance(F); |
7fd59977 |
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]) |
96f3bacc |
287 | return const_cast<char*>(myViews[id]->Type()); |
7fd59977 |
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]) |
96f3bacc |
301 | return myViews[id]->GetZoom(); |
7fd59977 |
302 | else |
96f3bacc |
303 | return 0.0; |
7fd59977 |
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]) |
96f3bacc |
315 | return myViews[id]->GetFocalDistance(); |
7fd59977 |
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]) |
96f3bacc |
329 | T = myViews[id]->GetMatrix(); |
7fd59977 |
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]) |
96f3bacc |
341 | return !myViews[id]->Is2D(); |
7fd59977 |
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]) |
96f3bacc |
355 | myViews[id]->SetMatrix(T); |
7fd59977 |
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); |
96f3bacc |
388 | xminf = - myViews[id]->GetDx(); |
389 | xmaxf = W - myViews[id]->GetDx(); |
390 | yminf = - myViews[id]->GetDy() - H; |
391 | ymaxf = - myViews[id]->GetDy(); |
7fd59977 |
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 |
96f3bacc |
406 | Standard_Boolean is2d = myViews[id]->Is2D(); |
7fd59977 |
407 | Standard_Integer i,nbviews = 0; |
408 | for (i = 1; i < MAXVIEW; i++) { |
409 | if (myViews[i]) { |
96f3bacc |
410 | if (myViews[i]->Is2D() == is2d) |
411 | ++nbviews; |
7fd59977 |
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; |
96f3bacc |
442 | umin = umin / curview->GetZoom(); |
443 | vmin = vmin / curview->GetZoom(); |
444 | umax = umax / curview->GetZoom(); |
445 | vmax = vmax / curview->GetZoom(); |
7fd59977 |
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 | } |
96f3bacc |
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) ); |
7fd59977 |
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]) { |
96f3bacc |
475 | myViews[id]->SetDx(myViews[id]->GetDx() + DX); |
476 | myViews[id]->SetDy(myViews[id]->GetDy() + DY); |
7fd59977 |
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]) { |
96f3bacc |
491 | myViews[id]->SetDx(DX); |
492 | myViews[id]->SetDy(DY); |
7fd59977 |
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]) { |
96f3bacc |
506 | DX = myViews[id]->GetDx(); |
507 | DY = myViews[id]->GetDy(); |
7fd59977 |
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 | |
57c28b61 |
588 | #ifdef _WIN32 |
7fd59977 |
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; |
96f3bacc |
627 | if (myViews[id]) |
628 | { |
629 | myViews[id]->SetDx(myViews[id]->WidthWin() / 2); |
630 | myViews[id]->SetDy(-myViews[id]->HeightWin() / 2); |
7fd59977 |
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, |
04232180 |
648 | std::ostream& sortie) const |
7fd59977 |
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); |
96f3bacc |
663 | Standard_Boolean view2d = myViews[id]->Is2D(); |
7fd59977 |
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 | { |
8c2d3314 |
699 | if (Draw_Batch) |
700 | { |
701 | return Standard_False; |
702 | } |
7fd59977 |
703 | Flush(); |
704 | if (myViews[id]) { |
705 | return myViews[id]->Save(filename); |
706 | } |
707 | else |
708 | { |
709 | std::cerr << "View " << id << " doesn't exists!\n"; |
710 | return Standard_False; |
711 | } |
712 | } |
713 | |
714 | //======================================================================= |
715 | //function : RepaintAll |
716 | //purpose : |
717 | //======================================================================= |
718 | |
719 | void Draw_Viewer::RepaintAll () const |
720 | { |
721 | if (Draw_Batch) return; |
722 | for (Standard_Integer id = 0; id < MAXVIEW; id++) |
723 | RepaintView(id); |
724 | } |
725 | |
726 | //======================================================================= |
727 | //function : Repaint2D |
728 | //purpose : |
729 | //======================================================================= |
730 | |
731 | void Draw_Viewer::Repaint2D () const |
732 | { |
733 | if (Draw_Batch) return; |
734 | for (Standard_Integer id = 0; id < MAXVIEW; id++) |
735 | if (myViews[id]) { |
96f3bacc |
736 | if (myViews[id]->Is2D()) |
737 | RepaintView(id); |
7fd59977 |
738 | } |
739 | } |
740 | |
741 | //======================================================================= |
742 | //function : Repaint3D |
743 | //purpose : |
744 | //======================================================================= |
745 | |
746 | void Draw_Viewer::Repaint3D () const |
747 | { |
748 | if (Draw_Batch) return; |
749 | for (Standard_Integer id = 0; id < MAXVIEW; id++) |
750 | if (myViews[id]) { |
96f3bacc |
751 | if (!myViews[id]->Is2D()) |
752 | RepaintView(id); |
7fd59977 |
753 | } |
754 | } |
755 | |
7fd59977 |
756 | //======================================================================= |
757 | //function : DeleteView |
758 | //purpose : |
759 | //======================================================================= |
760 | |
761 | void Draw_Viewer::DeleteView(const Standard_Integer id) |
762 | { |
763 | if (Draw_Batch) return; |
764 | if (myViews[id] != NULL) { |
765 | delete myViews[id]; |
766 | myViews[id] = NULL; |
767 | } |
768 | } |
769 | |
770 | //======================================================================= |
771 | //function : Clear |
772 | //purpose : |
773 | //======================================================================= |
774 | |
775 | void Draw_Viewer::Clear() |
776 | { |
777 | if (Draw_Batch) return; |
778 | for (Standard_Integer i = 1; i <= myDrawables.Length(); i++) |
779 | myDrawables(i)->Visible(Standard_False); |
780 | myDrawables.Clear(); |
781 | for (Standard_Integer id = 0; id < MAXVIEW; id++) |
782 | ClearView(id); |
783 | } |
784 | |
785 | //======================================================================= |
786 | //function : Clear2D |
787 | //purpose : |
788 | //======================================================================= |
789 | |
790 | void Draw_Viewer::Clear2D() |
791 | { |
792 | if (Draw_Batch) return; |
793 | Standard_Integer i = 1; |
794 | while (i <= myDrawables.Length()) { |
795 | if (myDrawables(i)->Is3D()) |
796 | i++; |
797 | else { |
798 | myDrawables(i)->Visible(Standard_False); |
799 | myDrawables.Remove(i); |
800 | } |
801 | } |
802 | for (Standard_Integer id = 0; id < MAXVIEW; id++) { |
803 | if (myViews[id]) { |
96f3bacc |
804 | if (myViews[id]->Is2D()) |
805 | ClearView(id); |
7fd59977 |
806 | } |
807 | } |
808 | } |
809 | |
810 | //======================================================================= |
811 | //function : Clear3D |
812 | //purpose : |
813 | //======================================================================= |
814 | |
815 | void Draw_Viewer::Clear3D() |
816 | { |
817 | if (Draw_Batch) return; |
818 | Standard_Integer i = 1; |
819 | while (i <= myDrawables.Length()) { |
820 | if (myDrawables(i)->Is3D()) { |
821 | myDrawables(i)->Visible(Standard_False); |
822 | myDrawables.Remove(i); |
823 | } |
824 | else |
825 | i++; |
826 | } |
827 | for (Standard_Integer id = 0; id < MAXVIEW; id++) { |
828 | if (myViews[id]) { |
96f3bacc |
829 | if (!myViews[id]->Is2D()) |
830 | ClearView(id); |
7fd59977 |
831 | } |
832 | } |
833 | } |
834 | |
835 | //======================================================================= |
836 | //function : Flush |
837 | //purpose : |
838 | //======================================================================= |
839 | |
840 | void Draw_Viewer::Flush() |
841 | { |
842 | if (Draw_Batch) return; |
843 | Draw_Window::Flush(); |
844 | } |
845 | |
846 | //======================================================================= |
847 | //function : DrawOnView |
848 | //purpose : |
849 | //======================================================================= |
850 | |
851 | void Draw_Viewer::DrawOnView(const Standard_Integer id, |
852 | const Handle(Draw_Drawable3D)& D) const |
853 | { |
854 | if (Draw_Batch) return; |
855 | if (myViews[id]) { |
856 | Draw_Display d = MakeDisplay(id); |
857 | xmin = ymin = DRAWINFINITE; |
858 | xmax = ymax = -DRAWINFINITE; |
859 | |
96f3bacc |
860 | Standard_Boolean view2d = myViews[id]->Is2D(); |
7fd59977 |
861 | myViews[id]->ResetFrame(); |
96f3bacc |
862 | if ((D->Is3D() && !view2d) || (!D->Is3D() && view2d)) |
863 | { |
7fd59977 |
864 | D->DrawOn(d); |
7fd59977 |
865 | if (CurrentMode == DRAW) |
96f3bacc |
866 | D->SetBounds(xmin,xmax,ymin,ymax); |
7fd59977 |
867 | d.Flush(); |
868 | } |
869 | } |
870 | } |
871 | |
872 | //======================================================================= |
873 | //function : HighlightOnView |
874 | //purpose : |
875 | //======================================================================= |
876 | |
877 | void Draw_Viewer::HighlightOnView (const Standard_Integer id, |
878 | const Handle(Draw_Drawable3D)& D, |
879 | const Draw_ColorKind C) const |
880 | { |
881 | if (Draw_Batch) return; |
882 | highlight = Standard_True; |
883 | highlightcol = C; |
884 | DrawOnView(id,D); |
885 | highlight = Standard_False; |
886 | } |
887 | |
888 | //======================================================================= |
889 | //function : AddDrawable |
890 | //purpose : |
891 | //======================================================================= |
892 | |
893 | void Draw_Viewer::AddDrawable (const Handle(Draw_Drawable3D)& D) |
894 | { |
895 | if (Draw_Batch) return; |
896 | if (!D.IsNull() && !D->Visible()) { |
897 | myDrawables.Append(D); |
898 | D->Visible(Standard_True); |
899 | } |
900 | } |
901 | |
902 | //======================================================================= |
903 | //function : RemoveDrawable |
904 | //purpose : |
905 | //======================================================================= |
906 | |
907 | void Draw_Viewer::RemoveDrawable (const Handle(Draw_Drawable3D)& D) |
908 | { |
909 | if (Draw_Batch) return; |
910 | if (!D.IsNull() && D->Visible()) { |
911 | Standard_Integer index; |
912 | for (index = 1; index <= myDrawables.Length(); index++) { |
913 | if (myDrawables(index) == D) { |
914 | D->Visible(Standard_False); |
915 | myDrawables.Remove(index); |
916 | return; |
917 | } |
918 | } |
919 | } |
920 | } |
921 | |
922 | //======================================================================= |
923 | //function : MakeDisplay |
924 | //purpose : return a display on the view |
925 | //======================================================================= |
926 | |
927 | Draw_Display Draw_Viewer::MakeDisplay (const Standard_Integer id) const |
928 | { |
929 | if (Draw_Batch) {Draw_Display dis;return dis;} |
930 | curviewId = id; |
931 | curview = myViews[id]; |
7fd59977 |
932 | nbseg = 0; |
933 | Draw_Color initcol(Draw_blanc); |
934 | // to force setting the color |
935 | currentcolor = Draw_Color(Draw_rouge); |
936 | Draw_Display dis; |
937 | dis.SetColor(initcol); |
896faa72 |
938 | dis.SetMode(0x3 /*GXcopy*/); |
7fd59977 |
939 | return dis; |
940 | } |
941 | |
942 | //======================================================================= |
943 | //function : Select |
944 | //purpose : |
945 | //======================================================================= |
7c441da0 |
946 | |
7fd59977 |
947 | void Draw_Viewer::Select (Standard_Integer& id, Standard_Integer& X, Standard_Integer& Y, |
948 | Standard_Integer& Button, Standard_Boolean wait) |
949 | { |
950 | if (Draw_Batch) return; |
7c441da0 |
951 | id = X = Y = Button = 0; |
952 | Standard_Boolean hasView = Standard_False; |
953 | for (int aViewIter = 0; aViewIter < MAXVIEW; ++aViewIter) |
954 | { |
955 | if (myViews[aViewIter] != NULL |
956 | && myViews[aViewIter]->IsMapped()) |
957 | { |
958 | hasView = Standard_True; |
959 | break; |
960 | } |
961 | } |
962 | if (!hasView) |
963 | { |
964 | std::cerr << "No selection is possible with no open views\n"; |
965 | return; |
966 | } |
7fd59977 |
967 | Flush(); |
7c441da0 |
968 | #if !defined(_WIN32) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX)) |
7fd59977 |
969 | if (!wait) { |
970 | if (id >=0 && id < MAXVIEW) { |
971 | if (myViews[id]) myViews[id]->Wait(wait); |
972 | } |
973 | } |
974 | else { |
975 | for(int i=0 ; i<MAXVIEW ; i++) |
976 | if (myViews[i]) myViews[i]->Wait(wait); |
977 | } |
978 | |
979 | Standard_Boolean again = Standard_True; |
980 | while (again) { |
981 | |
982 | Event ev; |
983 | ev.type = 0; |
984 | |
985 | GetNextEvent(ev); |
986 | |
987 | switch (ev.type) { |
988 | |
989 | case ButtonPress : |
990 | Standard_Integer iv; |
991 | for (iv = 0; iv < MAXVIEW; iv++) { |
992 | if (myViews[iv]) { |
993 | if (myViews[iv]->win == ev.window) |
994 | break; |
995 | } |
996 | } |
997 | if (wait || id == iv) { |
998 | if (iv < MAXVIEW) { |
999 | id = iv; |
1000 | X = ev.x; |
1001 | Y = ev.y; |
1002 | Button = ev.button; |
1003 | } |
1004 | else { |
1005 | id = -1; |
1006 | } |
1007 | again = Standard_False; |
1008 | } |
1009 | break; |
1010 | |
1011 | case MotionNotify : |
1012 | if (wait) break; |
1013 | X = ev.x; |
1014 | Y = ev.y; |
1015 | Button = 0; |
1016 | again = Standard_False; |
1017 | break; |
1018 | } |
1019 | } |
1020 | |
1021 | if (id != -1) { |
96f3bacc |
1022 | X = X - myViews[id]->GetDx(); |
1023 | Y = -Y - myViews[id]->GetDy(); |
7fd59977 |
1024 | } |
1025 | if (!wait) myViews[id]->Wait(!wait); |
67d97f0e |
1026 | #elif defined(__APPLE__) && !defined(MACOSX_USE_GLX) |
1027 | Standard_Integer aWindowNumber; |
1028 | |
1029 | id = MAXVIEW; |
1030 | while (id >= MAXVIEW) |
1031 | { |
1032 | GetNextEvent(wait, aWindowNumber, X, Y, Button); |
96f3bacc |
1033 | |
67d97f0e |
1034 | if (Y < 0) |
1035 | { |
1036 | continue; // mouse clicked on window title |
1037 | } |
1038 | |
1039 | for (Standard_Integer anIter = 0; anIter < MAXVIEW; anIter++) |
1040 | { |
1041 | if (myViews[anIter] && myViews[anIter]->IsEqualWindows (aWindowNumber)) |
1042 | { |
1043 | id = anIter; |
1044 | } |
1045 | } |
1046 | } |
1047 | |
96f3bacc |
1048 | X = X - myViews[id]->GetDx(); |
1049 | Y = -Y - myViews[id]->GetDy(); |
67d97f0e |
1050 | |
7fd59977 |
1051 | #else |
1052 | HANDLE hWnd; |
1053 | |
1054 | id = MAXVIEW; //:abv 29.05.02: cycle for working in console mode |
1055 | while ( id >= MAXVIEW ) { |
1056 | if (wait) |
1057 | Draw_Window::SelectWait(hWnd, X, Y, Button); |
1058 | else |
1059 | Draw_Window::SelectNoWait(hWnd, X, Y, Button); |
1060 | |
1061 | // Recherche du numero de la vue grace au HANDLE |
1062 | for(int i=0 ; i<MAXVIEW ; i++) |
1063 | if (myViews[i] && myViews[i]->win == hWnd ) id = i; |
1064 | } |
96f3bacc |
1065 | X = X - myViews[id]->GetDx(); |
1066 | Y = -Y - myViews[id]->GetDy(); |
7fd59977 |
1067 | #endif |
1068 | } |
1069 | |
1070 | //======================================================================= |
1071 | //function : Pick |
1072 | //purpose : |
1073 | //======================================================================= |
1074 | |
1075 | Standard_Integer Draw_Viewer::Pick(const Standard_Integer id, |
1076 | const Standard_Integer X, const Standard_Integer Y, const Standard_Integer Prec, |
1077 | Handle(Draw_Drawable3D)& D, |
1078 | const Standard_Integer first) const |
1079 | { |
1080 | if (Draw_Batch) return 0; |
1081 | if (myViews[id] == NULL) |
1082 | return 0; |
1083 | |
1084 | // is this the only view in its category |
96f3bacc |
1085 | Standard_Boolean is2d = myViews[id]->Is2D(); |
7fd59977 |
1086 | Standard_Integer i,nbviews = 0; |
96f3bacc |
1087 | for (i = 0; i < MAXVIEW; i++) |
1088 | { |
1089 | if (myViews[i]) |
1090 | if (myViews[i]->Is2D() == is2d) |
1091 | ++nbviews; |
7fd59977 |
1092 | } |
1093 | Standard_Boolean only = (nbviews == 1); |
1094 | |
1095 | CurrentMode = PICK; |
1096 | xpick = X; |
1097 | ypick = Y; |
1098 | precpick = Prec; |
1099 | found = Standard_False; |
1100 | Standard_Real x1,x2,y1,y2; |
1101 | for (i = first+1; i <= myDrawables.Length(); i++) { |
1102 | Standard_Boolean reject = Standard_False; |
1103 | // rejection if only view |
1104 | if (only) { |
1105 | myDrawables(i)->Bounds(x1,x2,y1,y2); |
1106 | if ((xpick+Prec < x1) || (xpick-Prec > x2) || |
1107 | (ypick+Prec < y1) || (ypick-Prec > y2)) |
1108 | reject = Standard_True; |
1109 | } |
1110 | if (!reject) { |
1111 | DrawOnView(id,myDrawables(i)); |
1112 | if (found) |
1113 | break; |
1114 | } |
1115 | } |
1116 | CurrentMode = DRAW; |
1117 | found = Standard_False; |
1118 | if (i <= myDrawables.Length()) |
1119 | D = myDrawables(i); |
1120 | else |
1121 | i = 0; |
1122 | return i; |
1123 | } |
1124 | |
1125 | //======================================================================= |
1126 | //function : LastPick |
1127 | //purpose : |
1128 | //======================================================================= |
1129 | |
1130 | void Draw_Viewer::LastPick(gp_Pnt& P1, gp_Pnt& P2, Standard_Real& Param) |
1131 | { |
1132 | if (Draw_Batch) return; |
1133 | P1 = lastPickP1; |
1134 | P2 = lastPickP2; |
1135 | Param = lastPickParam; |
1136 | } |
1137 | |
1138 | //======================================================================= |
1139 | //function : ~Draw_Viewer |
1140 | //purpose : |
1141 | //======================================================================= |
1142 | |
1143 | Draw_Viewer::~Draw_Viewer() |
1144 | { |
1145 | if (Draw_Batch) return; |
1146 | for (Standard_Integer id = 0; id < MAXVIEW; id++) |
1147 | DeleteView(id); |
1148 | } |
1149 | |
1150 | //======================================================================= |
1151 | //function : operator<< |
1152 | //purpose : |
1153 | //======================================================================= |
1154 | |
1155 | Draw_Viewer& Draw_Viewer::operator<<(const Handle(Draw_Drawable3D)& d3d) |
1156 | { |
1157 | if (Draw_Batch) return *this; |
1158 | if (!d3d.IsNull()) { |
1159 | AddDrawable(d3d); |
1160 | for (Standard_Integer id = 0; id < MAXVIEW; id++) |
1161 | DrawOnView(id,d3d); |
1162 | } |
1163 | return *this; |
1164 | } |
1165 | |
1166 | //======================================================================= |
1167 | //function : GetDrawables |
1168 | //purpose : |
1169 | //======================================================================= |
1170 | const Draw_SequenceOfDrawable3D& Draw_Viewer::GetDrawables() |
1171 | { |
1172 | return myDrawables; |
1173 | } |
1174 | |
1175 | // ******************************************************************* |
1176 | // DISPLAY methods |
1177 | // ******************************************************************* |
1178 | |
1179 | |
1180 | void Draw_Flush() |
1181 | { |
1182 | if (Draw_Batch) return; |
1183 | if (highlight) curview->SetColor(highlightcol.ID()); |
1184 | curview->DrawSegments(segm,nbseg); |
1185 | nbseg = 0; |
1186 | } |
1187 | |
1188 | //======================================================================= |
1189 | //function : SetColor |
1190 | //purpose : |
1191 | //======================================================================= |
1192 | |
1193 | void Draw_Display::SetColor (const Draw_Color& col) const |
1194 | { |
1195 | if (Draw_Batch) return; |
1196 | if (col.ID() == currentcolor.ID()) return; |
1197 | |
1198 | currentcolor = col; |
1199 | switch (CurrentMode) { |
1200 | |
1201 | case DRAW : |
1202 | Draw_Flush(); |
1203 | curview->SetColor(col.ID()); |
1204 | break; |
1205 | |
1206 | case POSTSCRIPT : |
1207 | (*ps_stream) << "stroke\nnewpath\n"; |
1208 | (*ps_stream) << ps_width[col.ID()]<<" setlinewidth\n"; |
1209 | (*ps_stream) << ps_gray[col.ID()]<<" setgray\n"; |
1210 | |
1211 | case PICK : |
1212 | break; |
1213 | } |
1214 | } |
1215 | |
1216 | //======================================================================= |
1217 | //function : SetMode |
1218 | //purpose : |
1219 | //======================================================================= |
1220 | |
1221 | void Draw_Display::SetMode (const Standard_Integer M) const |
1222 | { |
1223 | if (Draw_Batch) return; |
1224 | switch (CurrentMode) { |
1225 | |
1226 | case DRAW : |
1227 | Draw_Flush(); |
1228 | curview->SetMode(M); |
1229 | break; |
1230 | |
1231 | case PICK : |
1232 | case POSTSCRIPT : |
1233 | break; |
1234 | } |
1235 | } |
1236 | |
1237 | //======================================================================= |
1238 | //function : Zoom |
1239 | //purpose : |
1240 | //======================================================================= |
1241 | |
1242 | Standard_Real Draw_Display::Zoom() const |
1243 | { |
1244 | if (Draw_Batch) return 1.; |
96f3bacc |
1245 | return curview->GetZoom(); |
7fd59977 |
1246 | } |
1247 | |
1248 | //======================================================================= |
1249 | //function : Flush |
1250 | //purpose : |
1251 | //======================================================================= |
1252 | |
1253 | void Draw_Display::Flush () const |
1254 | { |
1255 | if (Draw_Batch) return; |
1256 | Draw_Flush(); |
1257 | } |
1258 | |
1259 | //======================================================================= |
1260 | //function : DrawString |
1261 | //purpose : |
1262 | //======================================================================= |
1263 | |
1264 | void Draw_Display::DrawString(const gp_Pnt2d& ppt, |
1265 | const Standard_CString S, |
1266 | const Standard_Real moveX, |
1267 | const Standard_Real moveY) |
1268 | { |
1269 | if (Draw_Batch) return; |
1270 | if (ppt.X() > 1.e09 || ppt.X() < -1.e09 ) return; |
1271 | if (ppt.Y() > 1.e09 || ppt.Y() < -1.e09 ) return; |
1272 | |
96f3bacc |
1273 | gp_Pnt2d pt(ppt.X()*curview->GetZoom(),ppt.Y()*curview->GetZoom()); |
7fd59977 |
1274 | |
1275 | if (pt.X() > 1.e09 || pt.X() < -1.e09 ) return; |
1276 | if (pt.Y() > 1.e09 || pt.Y() < -1.e09 ) return; |
1277 | |
1278 | switch (CurrentMode) { |
1279 | |
1280 | case DRAW : |
1281 | { |
96f3bacc |
1282 | int X = (int) ( pt.X() + moveX + curview->GetDx()); |
1283 | int Y = (int) (-pt.Y() + moveY - curview->GetDy()); |
7fd59977 |
1284 | curview->DrawString(X,Y,(char *)S); |
1285 | if (Draw_Bounds) { |
1286 | if (pt.X() + moveX > xmax) xmax = pt.X(); |
1287 | if (pt.X() + moveX < xmin) xmin = pt.X(); |
1288 | if (-pt.Y() - moveY > ymax) ymax = -pt.Y(); |
1289 | if (-pt.Y() - moveY < ymin) ymin = -pt.Y(); |
1290 | } |
1291 | } |
1292 | break; |
1293 | |
1294 | case POSTSCRIPT : |
1295 | { |
1296 | Standard_Integer x = (Standard_Integer )( (pt.X() + moveX - ps_vx) * ps_kx + ps_px); |
1297 | Standard_Integer y = (Standard_Integer )( (pt.Y() + moveY - ps_vy) * ps_ky + ps_py); |
1298 | (*ps_stream) <<"stroke\n"; |
1299 | (*ps_stream) << x << " " << y << " m\n"; |
1300 | (*ps_stream) <<"("<<S<<") show\nnewpath\n"; |
1301 | } |
1302 | break; |
1303 | |
1304 | case PICK : |
1305 | break; |
1306 | } |
1307 | } |
1308 | |
1309 | //======================================================================= |
1310 | //function : DrawString |
1311 | //purpose : |
1312 | //======================================================================= |
1313 | |
1314 | void Draw_Display::DrawString(const gp_Pnt2d& ppt, |
1315 | const Standard_CString S) |
1316 | { |
1317 | if (Draw_Batch) return; |
1318 | DrawString(ppt,S,0.0,0.0); |
1319 | } |
1320 | |
1321 | //======================================================================= |
1322 | //function : DrawString |
1323 | //purpose : |
1324 | //======================================================================= |
1325 | |
1326 | void Draw_Display::DrawString(const gp_Pnt& pt, |
1327 | const Standard_CString S, |
1328 | const Standard_Real moveX, |
1329 | const Standard_Real moveY) |
1330 | { |
1331 | if (Draw_Batch) return; |
1332 | DrawString(Project(pt),S,moveX,moveY); |
1333 | } |
1334 | |
1335 | //======================================================================= |
1336 | //function : DrawString |
1337 | //purpose : |
1338 | //======================================================================= |
1339 | |
1340 | void Draw_Display::DrawString(const gp_Pnt& pt, |
1341 | const Standard_CString S) |
1342 | { |
1343 | if (Draw_Batch) return; |
1344 | DrawString(Project(pt),S,0.0,0.0); |
1345 | } |
1346 | |
1347 | |
1348 | // ******************************************************************* |
1349 | // Drawing data static variables |
1350 | // ******************************************************************* |
1351 | static gp_Pnt2d PtCur; // current 2D point |
1352 | static gp_Pnt PtPers; // current 3D point for Pers |
1353 | |
1354 | //======================================================================= |
1355 | //function : Project |
1356 | //purpose : |
1357 | //======================================================================= |
1358 | |
1359 | void Draw_Display::Project(const gp_Pnt& p, gp_Pnt2d& p2d) const |
1360 | { |
1361 | if (Draw_Batch) return; |
1362 | gp_Pnt pt = p; |
96f3bacc |
1363 | pt.Transform(curview->GetMatrix()); |
7fd59977 |
1364 | Standard_Real xp,yp,zp; |
1365 | pt.Coord(xp,yp,zp); |
96f3bacc |
1366 | if (curview->IsPerspective()) { |
1367 | const Standard_Real aDistance = curview->GetFocalDistance(); |
1368 | xp = xp * aDistance / (aDistance-zp); |
1369 | yp = yp * aDistance / (aDistance-zp); |
7fd59977 |
1370 | } |
1371 | p2d.SetCoord(xp,yp); |
1372 | } |
1373 | |
1374 | //======================================================================= |
1375 | //function : Draw_Display |
1376 | //purpose : |
1377 | //======================================================================= |
1378 | |
1379 | Draw_Display::Draw_Display () |
1380 | { |
1381 | if (Draw_Batch) return; |
1382 | if (curview) { |
96f3bacc |
1383 | PtPers.SetCoord(0., 0., 0.); |
1384 | PtPers.Transform(curview->GetMatrix()); |
1385 | PtCur.SetCoord(PtPers.X()*curview->GetZoom(),PtPers.Y()*curview->GetZoom()); |
7fd59977 |
1386 | } |
1387 | } |
1388 | |
1389 | //======================================================================= |
1390 | //function : MoveTo 2D |
1391 | //purpose : |
1392 | //======================================================================= |
1393 | |
1394 | void Draw_Display::MoveTo (const gp_Pnt2d& pp) |
1395 | { |
1396 | if (Draw_Batch) return; |
96f3bacc |
1397 | const Standard_Real aZoom = curview->GetZoom(); |
1398 | gp_Pnt2d pt(pp.X() * aZoom, pp.Y() * aZoom); |
7fd59977 |
1399 | switch (CurrentMode) { |
1400 | |
1401 | case DRAW : |
1402 | PtCur = pt; |
1403 | if (Draw_Bounds) { |
1404 | if (pt.X() > xmax) xmax = pt.X(); |
1405 | if (pt.X() < xmin) xmin = pt.X(); |
1406 | if (pt.Y() > ymax) ymax = pt.Y(); |
1407 | if (pt.Y() < ymin) ymin = pt.Y(); |
1408 | } |
1409 | break; |
1410 | |
1411 | case PICK : |
1412 | PtCur = pt; |
1413 | break; |
1414 | |
1415 | case POSTSCRIPT : |
1416 | { |
1417 | Standard_Integer x = (Standard_Integer )( (pt.X() - ps_vx) * ps_kx + ps_px); |
1418 | Standard_Integer y = (Standard_Integer )( (pt.Y() - ps_vy) * ps_ky + ps_py); |
1419 | (*ps_stream) <<"stroke\nnewpath\n"<< x << " " << y << " m\n"; |
1420 | } |
1421 | break; |
1422 | } |
1423 | } |
1424 | |
1425 | //======================================================================= |
1426 | //function : DrawTo 2D |
1427 | //purpose : |
1428 | //======================================================================= |
1429 | inline Standard_Integer CalculRegion(const Standard_Real x, |
1430 | const Standard_Real y, |
1431 | const Standard_Real x1, |
1432 | const Standard_Real y1, |
1433 | const Standard_Real x2, |
1434 | const Standard_Real y2) { |
1435 | Standard_Integer r; |
1436 | if(x<x1) { r=1; } else { if(x>x2) { r=2; } else { r=0; } } |
1437 | if(y<y1) { r|=4; } else { if(y>y2) { r|=8; } } |
1438 | return(r); |
1439 | } |
1440 | |
1441 | Standard_Boolean Trim(gp_Pnt2d& P1,gp_Pnt2d& P2, |
1442 | Standard_Real x0, |
1443 | Standard_Real y0, |
1444 | Standard_Real x1, |
1445 | Standard_Real y1) { |
1446 | Standard_Real xa=P1.X(),ya=P1.Y(),xb=P2.X(),yb=P2.Y(); |
1447 | |
1448 | Standard_Integer regiona=0,regionb=0; |
1449 | regiona = CalculRegion(xa,ya,x0,y0,x1,y1); |
1450 | regionb = CalculRegion(xb,yb,x0,y0,x1,y1); |
1451 | if((regiona & regionb)==0) { |
1452 | Standard_Real dx=xb-xa; |
1453 | Standard_Real dy=yb-ya; |
1454 | Standard_Real dab=sqrt(dx*dx+dy*dy); |
1455 | if(dab<1e-10) return(Standard_False); |
1456 | dx/=dab; |
1457 | dy/=dab; |
1458 | |
1459 | Standard_Real xm,ym,mfenx,mfeny; |
1460 | mfenx=xm=0.5*(x0+x1); |
1461 | mfeny=ym=0.5*(y0+y1); |
1462 | x1-=x0; y1-=y0; |
1463 | Standard_Real d=sqrt(x1*x1+y1*y1) * 2; |
1464 | |
1465 | Standard_Real p=(xm-xa)*dx+(ym-ya)*dy; |
1466 | xm=xa+p*dx; |
1467 | ym=ya+p*dy; |
1468 | gp_Pnt2d Pm(xm,ym); |
1469 | |
1470 | gp_Pnt2d MFen(mfenx,mfeny); |
1471 | if(MFen.SquareDistance(Pm) > d*d) return(Standard_False); |
1472 | |
1473 | Standard_Real PmDistP1 = Pm.Distance(P1); |
1474 | Standard_Real PmDistP2 = Pm.Distance(P2); |
1475 | |
1476 | Standard_Real amab = (xm-xa)*(xb-xa)+(ym-ya)*(yb-ya); |
1477 | |
1478 | if(amab > 0) { //-- M est compris entre A et B |
1479 | if(PmDistP1 > d) { |
1480 | P1.SetCoord(xm-d*dx,ym-d*dy); |
1481 | } |
1482 | if(PmDistP2 >d) { |
1483 | P2.SetCoord(xm+d*dx,ym+d*dy); |
1484 | } |
1485 | } |
1486 | else if(PmDistP1 < PmDistP2) { //-- On a M P1 P2 |
1487 | if(PmDistP2 > d) { |
1488 | P2.SetCoord(xm+d*dx,ym+d*dy); |
1489 | } |
1490 | } |
1491 | else { //-- On a P1 P2 M |
1492 | if(PmDistP1 > d) { |
1493 | P1.SetCoord(xm-d*dx,ym-d*dy); |
1494 | } |
1495 | } |
1496 | return(Standard_True); |
1497 | } |
1498 | else return(Standard_False); |
1499 | } |
1500 | |
1501 | |
1502 | |
1503 | |
1504 | void Draw_Display::DrawTo (const gp_Pnt2d& pp2) |
1505 | { |
1506 | if (Draw_Batch) return; |
1507 | if (pp2.X() > 1.e09 || pp2.X() < -1.e09 ) return; |
1508 | if (pp2.Y() > 1.e09 || pp2.Y() < -1.e09 ) return; |
1509 | |
96f3bacc |
1510 | gp_Pnt2d p2(pp2.X() * curview->GetZoom(), pp2.Y() * curview->GetZoom()); |
7fd59977 |
1511 | |
1512 | if (p2.X() > 1.e09 || p2.X() < -1.e09 ) return; |
1513 | if (p2.Y() > 1.e09 || p2.Y() < -1.e09 ) return; |
1514 | |
1515 | gp_Pnt2d p1 = PtCur; |
1516 | if (p1.X() > 1.e09 || p1.X() < -1.e09 ) return; |
1517 | if (p1.Y() > 1.e09 || p1.Y() < -1.e09 ) return; |
1518 | |
1519 | PtCur = p2; |
1520 | |
1521 | switch (CurrentMode) { |
1522 | |
1523 | case DRAW : { |
1524 | |
1525 | #if 1 |
1526 | Standard_Integer x0,y0,x1,y1; |
1527 | curview->GetFrame(x0,y0,x1,y1); |
1528 | |
1529 | |
1530 | //Standard_Integer qx0,qy0,qx1,qy1; |
1531 | //curview->viewer->GetFrame(curview->id,qx0,qy0,qx1,qy1); |
1532 | //if(qx0!=x0 || qx1!=x1 || qy0!=y0 || qy1!=y1) { |
1533 | // x0=qx0; x1=qx1; y0=qy0; y1=qy1; |
1534 | //} |
1535 | |
1536 | |
1537 | |
1538 | gp_Pnt2d PI1(p1); |
1539 | gp_Pnt2d PI2(p2); |
1540 | |
96f3bacc |
1541 | if(Trim(PI1,PI2,x0,y0,x1,y1)) |
1542 | { |
1543 | segm[nbseg].Init(static_cast<Standard_Integer>( PI1.X() + curview->GetDx()), |
1544 | static_cast<Standard_Integer>(-PI1.Y() - curview->GetDy()), |
1545 | static_cast<Standard_Integer>( PI2.X() + curview->GetDx()), |
1546 | static_cast<Standard_Integer>(-PI2.Y() - curview->GetDy())); |
1547 | ++nbseg; |
7fd59977 |
1548 | } |
1549 | #else |
96f3bacc |
1550 | segm[nbseg].Init(static_cast<Standard_Integer>( p1.X() + curview->GetDx()), |
1551 | static_cast<Standard_Integer>(-p1.Y() - curview->GetDy()), |
1552 | static_cast<Standard_Integer>( p2.X() + curview->GetDx()), |
1553 | static_cast<Standard_Integer>(-p2.Y() - curview->GetDy())); |
7fd59977 |
1554 | nbseg++; |
1555 | #endif |
1556 | if (nbseg == MAXSEGMENT) { |
1557 | Draw_Flush(); |
1558 | } |
1559 | if (Draw_Bounds) { |
1560 | if (p2.X() > xmax) xmax = p2.X(); |
1561 | if (p2.X() < xmin) xmin = p2.X(); |
1562 | if (p2.Y() > ymax) ymax = p2.Y(); |
1563 | if (p2.Y() < ymin) ymin = p2.Y(); |
1564 | } |
1565 | } |
1566 | break; |
1567 | |
1568 | case PICK : |
1569 | if (!found) { |
1570 | Standard_Integer x1 = (int) p1.X() ; |
1571 | Standard_Integer y1 = (int) p1.Y() ; |
1572 | Standard_Integer x2 = (int) p2.X() ; |
1573 | Standard_Integer y2 = (int) p2.Y() ; |
1574 | if ((x1 >= xpick + precpick) && (x2 >= xpick + precpick)) break; |
1575 | if ((x1 <= xpick - precpick) && (x2 <= xpick - precpick)) break; |
1576 | if ((y1 >= ypick + precpick) && (y2 >= ypick + precpick)) break; |
1577 | if ((y1 <= ypick - precpick) && (y2 <= ypick - precpick)) break; |
1578 | |
1579 | Standard_Boolean inside = Standard_True; |
1580 | if ((x1 > xpick + precpick) || (x2 > xpick + precpick)) { |
1581 | Standard_Real y = (Standard_Real) y1 + |
1582 | (Standard_Real) (y2-y1) * (Standard_Real) (xpick+precpick-x1) / |
1583 | (Standard_Real) (x2 - x1); |
1584 | if ( (y < ypick+precpick) && (y > ypick - precpick)) { |
1585 | found = Standard_True; |
1586 | lastPickParam = (Standard_Real) (xpick - x1) / |
1587 | (Standard_Real) (x2 - x1); |
1588 | break; |
1589 | } |
1590 | else |
1591 | inside = Standard_False; |
1592 | } |
1593 | |
1594 | if ((x1 < xpick - precpick) || (x2 < xpick - precpick)) { |
1595 | Standard_Real y = (Standard_Real) y1 + |
1596 | (Standard_Real) (y2-y1) * (Standard_Real) (xpick-precpick-x1) / |
1597 | (Standard_Real) (x2 - x1); |
1598 | if ( (y < ypick+precpick) && (y > ypick - precpick)) { |
1599 | found = Standard_True; |
1600 | lastPickParam = (Standard_Real) (xpick - x1) / |
1601 | (Standard_Real) (x2 - x1); |
1602 | break; |
1603 | } |
1604 | else |
1605 | inside = Standard_False; |
1606 | } |
1607 | |
1608 | |
1609 | if ((y1 > ypick + precpick) || (y2 > ypick + precpick)) { |
1610 | Standard_Real x = (Standard_Real) x1 + |
1611 | (Standard_Real) (x2-x1) * (Standard_Real) (ypick+precpick-y1) / |
1612 | (Standard_Real) (y2 - y1); |
1613 | if ( (x < xpick+precpick) && (x > xpick - precpick)) { |
1614 | found = Standard_True; |
1615 | lastPickParam = (Standard_Real) (ypick - y1) / |
1616 | (Standard_Real) (y2 - y1); |
1617 | break; |
1618 | } |
1619 | else |
1620 | inside = Standard_False; |
1621 | } |
1622 | |
1623 | |
1624 | if ((y1 < ypick - precpick) || (y2 < ypick - precpick)) { |
1625 | Standard_Real x = (Standard_Real) x1 + |
1626 | (Standard_Real) (x2-x1) * (Standard_Real) (ypick-precpick-y1) / |
1627 | (Standard_Real) (y2 - y1); |
1628 | if ( (x < xpick+precpick) && (x > xpick - precpick)) { |
1629 | found = Standard_True; |
1630 | lastPickParam = (Standard_Real) (ypick - y1) / |
1631 | (Standard_Real) (y2 - y1); |
1632 | break; |
1633 | } |
1634 | else |
1635 | inside = Standard_False; |
1636 | } |
1637 | found = found || inside; |
1638 | if (found) { |
1639 | if (Abs(x2-x1) > Abs(y2-y1)) { |
1640 | if (Abs(x2-x1) < 1e-5) lastPickParam = 0; |
1641 | else |
1642 | lastPickParam = (Standard_Real)(xpick - x1) / |
1643 | (Standard_Real)(x2 - x1); |
1644 | } |
1645 | else { |
1646 | if (Abs(y2-y1) < 1e-5) lastPickParam = 0; |
1647 | else |
1648 | lastPickParam = (Standard_Real)(ypick - y1) / |
1649 | (Standard_Real)(y2 - y1); |
1650 | } |
1651 | } |
1652 | } |
1653 | break; |
1654 | |
1655 | case POSTSCRIPT : |
1656 | { |
1657 | Standard_Integer x = (Standard_Integer )( (p2.X() - ps_vx) * ps_kx + ps_px); |
1658 | Standard_Integer y = (Standard_Integer )( (p2.Y() - ps_vy) * ps_ky + ps_py); |
1659 | (*ps_stream) << x << " " << y << " l\n"; |
1660 | } |
1661 | break; |
1662 | } |
1663 | |
1664 | } |
1665 | |
1666 | //======================================================================= |
1667 | //function : MoveTo |
1668 | //purpose : |
1669 | //======================================================================= |
1670 | |
1671 | void Draw_Display::MoveTo (const gp_Pnt& pt) |
1672 | { |
1673 | if (Draw_Batch) return; |
1674 | if (CurrentMode == PICK) { |
1675 | if (!found) lastPickP1 = pt; |
1676 | else return; |
1677 | } |
1678 | PtPers = pt; |
96f3bacc |
1679 | PtPers.Transform(curview->GetMatrix()); |
7fd59977 |
1680 | Standard_Real xp = PtPers.X(); |
1681 | Standard_Real yp = PtPers.Y(); |
96f3bacc |
1682 | if (curview->IsPerspective()) |
1683 | { |
7fd59977 |
1684 | Standard_Real ZPers = PtPers.Z(); |
96f3bacc |
1685 | const Standard_Real aDistance = curview->GetFocalDistance(); |
1686 | if (ZPers < aDistance * precpers) |
1687 | { |
1688 | xp=xp * aDistance / (aDistance-ZPers); |
1689 | yp=yp * aDistance / (aDistance-ZPers); |
7fd59977 |
1690 | } |
1691 | } |
1692 | MoveTo(gp_Pnt2d(xp,yp)); |
1693 | } |
1694 | |
1695 | //======================================================================= |
1696 | //function : DrawTo |
1697 | //purpose : |
1698 | //======================================================================= |
1699 | |
1700 | void Draw_Display::DrawTo (const gp_Pnt& pt) |
1701 | { |
1702 | if (Draw_Batch) return; |
1703 | if ((CurrentMode == PICK) && found) return; |
1704 | |
96f3bacc |
1705 | gp_Pnt pt2 = pt.Transformed(curview->GetMatrix()); |
7fd59977 |
1706 | Standard_Real xp2 = pt2.X(); |
1707 | Standard_Real yp2 = pt2.Y(); |
1708 | |
96f3bacc |
1709 | if (curview->IsPerspective()) |
1710 | { |
1711 | const Standard_Real aZoom = curview->GetZoom(); |
1712 | const Standard_Real aDistance = curview->GetFocalDistance(); |
1713 | |
7fd59977 |
1714 | Standard_Real xp1 = PtPers.X(); |
1715 | Standard_Real yp1 = PtPers.Y(); |
1716 | Standard_Real zp1 = PtPers.Z(); |
1717 | Standard_Real zp2 = pt2.Z(); |
1718 | PtPers = pt2; |
96f3bacc |
1719 | if ((zp1 >= aDistance*precpers) && (zp2 >= aDistance*precpers) ) |
1720 | { |
7fd59977 |
1721 | return; // segment is not visible in perspective (behind the eye) |
1722 | } |
96f3bacc |
1723 | else if (zp1 >= aDistance*precpers) |
1724 | { |
1725 | xp1=xp1+(xp2-xp1)*(aDistance*precpers-zp1)/(zp2-zp1); |
1726 | yp1=yp1+(yp2-yp1)*(aDistance*precpers-zp1)/(zp2-zp1); |
1727 | zp1=aDistance*precpers; |
1728 | xp1=xp1*aDistance/(aDistance-zp1); |
1729 | yp1=yp1*aDistance/(aDistance-zp1); |
1730 | MoveTo( gp_Pnt2d(xp1 * aZoom, yp1 * aZoom) ); |
1731 | } |
1732 | else if (zp2 >= aDistance*precpers) |
1733 | { |
1734 | xp2=xp2+(xp1-xp2)*(aDistance*precpers-zp2)/(zp1-zp2); |
1735 | yp2=yp2+(yp1-yp2)*(aDistance*precpers-zp2)/(zp1-zp2); |
1736 | zp2=aDistance*precpers; |
7fd59977 |
1737 | } |
96f3bacc |
1738 | xp2 = xp2 * aDistance / (aDistance - zp2); |
1739 | yp2 = yp2 * aDistance / (aDistance - zp2); |
7fd59977 |
1740 | } |
1741 | DrawTo(gp_Pnt2d(xp2,yp2)); |
1742 | if (CurrentMode == PICK) { |
1743 | if (!found) lastPickP1 = pt; |
1744 | else lastPickP2 = pt; |
1745 | } |
1746 | } |
1747 | |
1748 | //======================================================================= |
1749 | //function : Draw |
1750 | //purpose : |
1751 | //======================================================================= |
1752 | |
1753 | void Draw_Display::Draw (const gp_Pnt& p1, const gp_Pnt& p2) |
1754 | { |
1755 | if (Draw_Batch) return; |
1756 | MoveTo(p1); |
1757 | DrawTo(p2); |
1758 | } |
1759 | |
1760 | //======================================================================= |
1761 | //function : Draw |
1762 | //purpose : |
1763 | //======================================================================= |
1764 | |
1765 | void Draw_Display::Draw(const gp_Pnt2d& p1, const gp_Pnt2d& p2) |
1766 | { |
1767 | if (Draw_Batch) return; |
1768 | MoveTo(p1); |
1769 | DrawTo(p2); |
1770 | } |
1771 | |
1772 | |
1773 | //======================================================================= |
1774 | //function : ViewId |
1775 | //purpose : |
1776 | //======================================================================= |
1777 | |
1778 | Standard_Integer Draw_Display::ViewId() const |
1779 | { |
1780 | if (Draw_Batch) return 0; |
1781 | return curviewId; |
1782 | } |
1783 | |
1784 | |
1785 | //======================================================================= |
1786 | //function : HasPicked |
1787 | //purpose : |
1788 | //======================================================================= |
1789 | |
1790 | Standard_Boolean Draw_Display::HasPicked() const |
1791 | { |
1792 | if (Draw_Batch) return Standard_False; |
1793 | return found; |
1794 | } |
1795 | |