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 std::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                                   std::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)
 700   {
 701     return Standard_False;
 702   }
 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]) {
 736       if (myViews[id]->Is2D())
 737         RepaintView(id);
 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]) {
 751       if (!myViews[id]->Is2D())
 752         RepaintView(id);
 753     }
 754 }
 755
 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]) {
 804       if (myViews[id]->Is2D())
 805         ClearView(id);
 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]) {
 829       if (!myViews[id]->Is2D())
 830         ClearView(id);
 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
 860     Standard_Boolean view2d = myViews[id]->Is2D();
 861     myViews[id]->ResetFrame();
 862     if ((D->Is3D() && !view2d) || (!D->Is3D() && view2d))
 863     {
 864       D->DrawOn(d);
 865       if (CurrentMode == DRAW)
 866         D->SetBounds(xmin,xmax,ymin,ymax);
 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];
 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);
 938   dis.SetMode(0x3 /*GXcopy*/);
 939   return dis;
 940 }
 941
 942 //=======================================================================
 943 //function : Select
 944 //purpose  :
 945 //=======================================================================
 946
 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;
 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   }
 967   Flush();
 968 #if !defined(_WIN32) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
 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) {
1022     X =  X - myViews[id]->GetDx();
1023     Y = -Y - myViews[id]->GetDy();
1024   }
1025   if (!wait) myViews[id]->Wait(!wait);
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);
1033
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
1048   X =  X - myViews[id]->GetDx();
1049   Y = -Y - myViews[id]->GetDy();
1050
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   }
1065   X =  X - myViews[id]->GetDx();
1066   Y = -Y - myViews[id]->GetDy();
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
1085   Standard_Boolean is2d = myViews[id]->Is2D();
1086   Standard_Integer i,nbviews = 0;
1087   for (i = 0; i < MAXVIEW; i++)
1088   {
1089     if (myViews[i])
1090       if (myViews[i]->Is2D() == is2d)
1091         ++nbviews;
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.;
1245   return curview->GetZoom();
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
1273   gp_Pnt2d pt(ppt.X()*curview->GetZoom(),ppt.Y()*curview->GetZoom());
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     {
1282       int X =   (int) ( pt.X() + moveX + curview->GetDx());
1283       int Y =   (int) (-pt.Y() + moveY - curview->GetDy());
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;
1363   pt.Transform(curview->GetMatrix());
1364   Standard_Real xp,yp,zp;
1365   pt.Coord(xp,yp,zp);
1366   if (curview->IsPerspective()) {
1367     const Standard_Real aDistance = curview->GetFocalDistance();
1368     xp = xp * aDistance / (aDistance-zp);
1369     yp = yp * aDistance / (aDistance-zp);
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) {
1383     PtPers.SetCoord(0., 0., 0.);
1384     PtPers.Transform(curview->GetMatrix());
1385     PtCur.SetCoord(PtPers.X()*curview->GetZoom(),PtPers.Y()*curview->GetZoom());
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;
1397   const Standard_Real aZoom = curview->GetZoom();
1398   gp_Pnt2d pt(pp.X() * aZoom, pp.Y() * aZoom);
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
1510   gp_Pnt2d p2(pp2.X() * curview->GetZoom(), pp2.Y() * curview->GetZoom());
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
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;
1548     }
1549 #else
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()));
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;
1679   PtPers.Transform(curview->GetMatrix());
1680   Standard_Real xp = PtPers.X();
1681   Standard_Real yp = PtPers.Y();
1682   if (curview->IsPerspective())
1683   {
1684     Standard_Real ZPers = PtPers.Z();
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);
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
1705   gp_Pnt pt2 = pt.Transformed(curview->GetMatrix());
1706   Standard_Real xp2 = pt2.X();
1707   Standard_Real yp2 = pt2.Y();
1708
1709   if (curview->IsPerspective())
1710   {
1711     const Standard_Real aZoom     = curview->GetZoom();
1712     const Standard_Real aDistance = curview->GetFocalDistance();
1713
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;
1719     if ((zp1 >= aDistance*precpers) && (zp2 >= aDistance*precpers) )
1720     {
1721       return;  // segment is not visible in perspective (behind the eye)
1722     }
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;
1737     }
1738     xp2 = xp2 * aDistance / (aDistance - zp2);
1739     yp2 = yp2 * aDistance / (aDistance - zp2);
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