src/os2/dc.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        dc.cpp
   3 // Purpose:     wxDC class
   4 // Author:      David Webster
   5 // Modified by:
   6 // Created:     10/14/99
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) David Webster
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // For compilers that support precompilation, includes "wx.h".
  13 #include "wx/wxprec.h"
  14
  15 #ifndef WX_PRECOMP
  16     #include "wx/window.h"
  17     #include "wx/dc.h"
  18     #include "wx/utils.h"
  19     #include "wx/dialog.h"
  20     #include "wx/app.h"
  21     #include "wx/bitmap.h"
  22     #include "wx/dcmemory.h"
  23     #include "wx/log.h"
  24     #include "wx/icon.h"
  25 #endif
  26
  27 #include "wx/dcprint.h"
  28
  29 #include <string.h>
  30 #include <math.h>
  31
  32 #include "wx/os2/private.h"
  33
  34     IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)
  35
  36 // ---------------------------------------------------------------------------
  37 // constants
  38 // ---------------------------------------------------------------------------
  39
  40 static const int VIEWPORT_EXTENT = 1000;
  41
  42 static const int MM_POINTS = 9;
  43 static const int MM_METRIC = 10;
  44
  45 // usually this is defined in math.h
  46 #ifndef M_PI
  47     static const double M_PI = 3.14159265358979323846;
  48 #endif // M_PI
  49
  50 // ---------------------------------------------------------------------------
  51 // private functions
  52 // ---------------------------------------------------------------------------
  53
  54 // convert degrees to radians
  55 static inline double DegToRad(double deg) { return (deg * M_PI) / 180.0; }
  56
  57 int SetTextColor(
  58   HPS                               hPS
  59 , int                               nForegroundColour
  60 )
  61 {
  62     CHARBUNDLE                      vCbnd;
  63
  64     vCbnd.lColor =  nForegroundColour;
  65     ::GpiSetAttrs( hPS       // presentation-space handle
  66                   ,PRIM_CHAR // Char primitive.
  67                   ,CBB_COLOR // sets color.
  68                   ,0         //
  69                   ,&vCbnd    // buffer for attributes.
  70                  );
  71     return 0;
  72 }
  73
  74 int QueryTextBkColor(
  75   HPS                               hPS
  76 )
  77 {
  78     CHARBUNDLE                      vCbnd;
  79
  80     ::GpiQueryAttrs( hPS            // presentation-space handle
  81                     ,PRIM_CHAR      // Char primitive.
  82                     ,CBB_BACK_COLOR // Background color.
  83                     ,&vCbnd         // buffer for attributes.
  84                    );
  85     return vCbnd.lBackColor;
  86 }
  87
  88
  89 int SetTextBkColor(
  90   HPS                               hPS
  91 , int                               nBackgroundColour
  92 )
  93 {
  94     CHARBUNDLE                      vCbnd;
  95     int                             rc;
  96
  97     rc =  QueryTextBkColor(hPS);
  98
  99     vCbnd.lBackColor = nBackgroundColour;
 100     ::GpiSetAttrs(hPS,            // presentation-space handle
 101                   PRIM_CHAR,      // Char primitive.
 102                   CBB_BACK_COLOR, // sets color.
 103                   0,
 104                   &vCbnd          // buffer for attributes.
 105                  );
 106     return rc;
 107 }
 108
 109 int SetBkMode(
 110   HPS                               hPS
 111 , int                               nBackgroundMode
 112 )
 113 {
 114     if(nBackgroundMode == wxTRANSPARENT)
 115         ::GpiSetBackMix( hPS
 116                         ,BM_LEAVEALONE
 117                        );
 118     else
 119         // the background of the primitive takes  over whatever is underneath.
 120         ::GpiSetBackMix( hPS
 121                         ,BM_OVERPAINT
 122                         );
 123     return 0;
 124 }
 125
 126 // ===========================================================================
 127 // implementation
 128 // ===========================================================================
 129
 130 // ---------------------------------------------------------------------------
 131 // wxDC
 132 // ---------------------------------------------------------------------------
 133
 134 wxDC::wxDC(void)
 135 {
 136     m_pCanvas      = NULL;
 137
 138     m_hOldBitmap   = 0;
 139     m_hOldPen      = 0;
 140     m_hOldBrush    = 0;
 141     m_hOldFont     = 0;
 142     m_hOldPalette  = 0;
 143
 144     m_bOwnsDC      = FALSE;
 145     m_hDC          = 0;
 146     m_nDCCount     = 0;
 147     m_hOldPS       = NULL;
 148     m_hPS          = NULL;
 149     m_bIsPaintTime = FALSE;// True at Paint Time
 150 };
 151
 152 wxDC::~wxDC(void)
 153 {
 154     // TODO:
 155 };
 156
 157 // This will select current objects out of the DC,
 158 // which is what you have to do before deleting the
 159 // DC.
 160 void wxDC::SelectOldObjects(WXHDC dc)
 161 {
 162     if (dc)
 163     {
 164         if (m_hOldBitmap)
 165         {
 166 //            ::SelectObject((HDC) dc, (HBITMAP) m_oldBitmap);
 167             if (m_vSelectedBitmap.Ok())
 168             {
 169                 m_vSelectedBitmap.SetSelectedInto(NULL);
 170             }
 171         }
 172         m_hOldBitmap = 0;
 173         if (m_hOldPen)
 174         {
 175 //            ::SelectObject((HDC) dc, (HPEN) m_oldPen);
 176         }
 177         m_hOldPen = 0;
 178         if (m_hOldBrush)
 179         {
 180 //            ::SelectObject((HDC) dc, (HBRUSH) m_oldBrush);
 181         }
 182         m_hOldBrush = 0;
 183         if (m_hOldFont)
 184         {
 185 //            ::SelectObject((HDC) dc, (HFONT) m_oldFont);
 186         }
 187         m_hOldFont = 0;
 188         if (m_hOldPalette)
 189         {
 190 //            ::SelectPalette((HDC) dc, (HPALETTE) m_oldPalette, TRUE);
 191         }
 192         m_hOldPalette = 0;
 193     }
 194
 195     m_brush           = wxNullBrush;
 196     m_pen             = wxNullPen;
 197     m_palette         = wxNullPalette;
 198     m_font            = wxNullFont;
 199     m_backgroundBrush = wxNullBrush;
 200     m_vSelectedBitmap = wxNullBitmap;
 201 }
 202
 203 // ---------------------------------------------------------------------------
 204 // clipping
 205 // ---------------------------------------------------------------------------
 206
 207 #define DO_SET_CLIPPING_BOX()                    \
 208 {                                                \
 209     RECTL rect;                                  \
 210                                                  \
 211     ::GpiQueryClipBox(m_hPS, &rect);             \
 212                                                  \
 213     m_clipX1 = (wxCoord) XDEV2LOG(rect.xLeft);   \
 214     m_clipY1 = (wxCoord) YDEV2LOG(rect.yTop);    \
 215     m_clipX2 = (wxCoord) XDEV2LOG(rect.xRight);  \
 216     m_clipY2 = (wxCoord) YDEV2LOG(rect.yBottom); \
 217 }
 218
 219 void wxDC::DoSetClippingRegion(
 220   wxCoord                           x
 221 , wxCoord                           y
 222 , wxCoord                           width
 223 , wxCoord                           height
 224 )
 225 {
 226     RECTL                           vRect;
 227
 228     m_clipping    = TRUE;
 229     vRect.xLeft   = XLOG2DEV(x);
 230     vRect.yTop    = YLOG2DEV(y + height);
 231     vRect.xRight  = XLOG2DEV(x + width);
 232     vRect.yBottom = YLOG2DEV(y);
 233     ::GpiIntersectClipRectangle(m_hPS, &vRect);
 234     DO_SET_CLIPPING_BOX()
 235 } // end of wxDC::DoSetClippingRegion
 236
 237 void wxDC::DoSetClippingRegionAsRegion(
 238   const wxRegion&                   rRegion
 239 )
 240 {
 241      wxCHECK_RET(rRegion.GetHRGN(), wxT("invalid clipping region"));
 242      HRGN                           hRgnOld;
 243
 244      m_clipping = TRUE;
 245      ::GpiSetClipRegion( m_hPS
 246                         ,(HRGN)rRegion.GetHRGN()
 247                         ,&hRgnOld
 248                        );
 249     DO_SET_CLIPPING_BOX()
 250 } // end of wxDC::DoSetClippingRegionAsRegion
 251
 252 void wxDC::DestroyClippingRegion(void)
 253 {
 254     if (m_clipping && m_hPS)
 255     {
 256          HRGN                       hRgnOld;
 257          RECTL                      vRect;
 258
 259          // TODO: this should restore the previous clipped region
 260          //       so that OnPaint processing works correctly, and
 261          //       the update doesn't get destroyed after the first
 262          //       DestroyClippingRegion
 263          vRect.xLeft   = XLOG2DEV(0);
 264          vRect.yTop    = YLOG2DEV(32000);
 265          vRect.xRight  = XLOG2DEV(32000);
 266          vRect.yBottom = YLOG2DEV(0);
 267
 268          HRGN                       hRgn = ::GpiCreateRegion(m_hPS, 1, &vRect);
 269
 270          ::GpiSetClipRegion(m_hPS, hRgn, &hRgnOld);
 271      }
 272       m_clipping = FALSE;
 273 } // end of wxDC::DestroyClippingRegion
 274
 275 // ---------------------------------------------------------------------------
 276 // query capabilities
 277 // ---------------------------------------------------------------------------
 278
 279 bool wxDC::CanDrawBitmap() const
 280 {
 281     return TRUE;
 282 }
 283
 284 bool wxDC::CanGetTextExtent() const
 285 {
 286     // What sort of display is it?
 287     int technology = 0; // TODO:  ::GetDeviceCaps(GetHdc(), TECHNOLOGY);
 288
 289     // TODO: return (technology == DT_RASDISPLAY) || (technology == DT_RASPRINTER);
 290     return FALSE;
 291 }
 292
 293 int wxDC::GetDepth() const
 294 {
 295    // TODO:
 296    return (1);
 297 }
 298
 299 // ---------------------------------------------------------------------------
 300 // drawing
 301 // ---------------------------------------------------------------------------
 302
 303 void wxDC::Clear()
 304 {
 305     ::GpiErase(m_hPS);
 306 }
 307
 308 void wxDC::DoFloodFill(
 309   wxCoord                           vX
 310 , wxCoord                           vY
 311 , const wxColour&                   rCol
 312 , int                               nStyle
 313 )
 314 {
 315     POINTL                          vPtlPos;
 316     LONG                            lColor;
 317     LONG                            lOptions;
 318
 319     vPtlPos.x = vX;             // Loads x-coordinate
 320     vPtlPos.y = vY;             // Loads y-coordinate
 321     ::GpiMove(m_hPS, &vPtlPos); // Sets current position
 322     lColor = rCol.GetPixel();
 323     lOptions = FF_BOUNDARY;
 324     if(wxFLOOD_SURFACE == nStyle)
 325         lOptions = FF_SURFACE;
 326
 327     ::GpiFloodFill(m_hPS, lOptions, lColor);
 328 }
 329
 330 bool wxDC::DoGetPixel(
 331   wxCoord                           vX
 332 , wxCoord                           vY
 333 , wxColour*                         pCol
 334 ) const
 335 {
 336     POINTL                          vPoint;
 337     LONG                            lColor;
 338
 339     vPoint.x = vX;
 340     vPoint.y = vY;
 341     lColor = ::GpiSetPel(m_hPS, &vPoint);
 342     pCol->Set((unsigned long)lColor);
 343     if(lColor>= 0)
 344         return(TRUE);
 345     else
 346         return(FALSE);
 347 }
 348
 349 void wxDC::DoCrossHair(wxCoord x, wxCoord y)
 350 {
 351    // TODO
 352 }
 353
 354 void wxDC::DoDrawLine(
 355   wxCoord                           vX1
 356 , wxCoord                           vY1
 357 , wxCoord                           vX2
 358 , wxCoord                           vY2
 359 )
 360 {
 361     POINTL                          vPoint[2];
 362
 363     vPoint[0].x = vX1;
 364     vPoint[0].y = vY1;
 365     vPoint[1].x = vX2;
 366     vPoint[1].y = vY2;
 367     ::GpiMove(m_hPS, &vPoint[0]);
 368     ::GpiLine(m_hPS, &vPoint[1]);
 369 }
 370
 371 //////////////////////////////////////////////////////////////////////////////
 372 // Draws an arc of a circle, centred on (xc, yc), with starting point (x1, y1)
 373 // and ending at (x2, y2). The current pen is used for the outline and the
 374 // current brush for filling the shape. The arc is drawn in an anticlockwise
 375 // direction from the start point to the end point.
 376 //////////////////////////////////////////////////////////////////////////////
 377 void wxDC::DoDrawArc(
 378   wxCoord                           vX1
 379 , wxCoord                           vY1
 380 , wxCoord                           vX2
 381 , wxCoord                           vY2
 382 , wxCoord                           vXc
 383 , wxCoord                           vYc
 384 )
 385 {
 386      POINTL                         vPtlPos;
 387      POINTL                         vPtlArc[2]; // Structure for current position
 388      int                            nDx;
 389      int                            nDy;
 390      double                         dRadius;
 391      double                         dAngl1;
 392      double                         dAngl2;
 393      double                         dAnglmid;
 394      wxCoord                        vXm;
 395      wxCoord                        vYm;
 396      ARCPARAMS                      vArcp; // Structure for arc parameters
 397
 398     if((vX1 == vXc && vY1 == vXc) || (vX2 == vXc && vY2 == vXc))
 399         return; // Draw point ??
 400     dRadius = 0.5 * ( hypot( (double)(vY1 - vYc)
 401                             ,(double)(vX1 - vXc)
 402                            ) +
 403                       hypot( (double)(vY2 - vYc)
 404                             ,(double)(vX2 - vXc)
 405                            )
 406                      );
 407
 408     dAngl1 = atan2( (double)(vY1 - vYc)
 409                    ,(double)(vX1 - vXc)
 410                   );
 411     dAngl2 = atan2( (double)(vY2 - vYc)
 412                    ,(double)(vX2 - vXc)
 413                   );
 414     if(dAngl2 < dAngl1)
 415         dAngl2 += M_PI * 2;
 416
 417     //
 418     // GpiPointArc can't draw full arc
 419     //
 420      if(dAngl2 == dAngl1 || (vX1 == vX2 && vY1 == vY2) )
 421      {
 422         //
 423         // Medium point
 424         //
 425         dAnglmid = (dAngl1 + dAngl2)/2. + M_PI;
 426         vXm      = vXc + dRadius * cos(dAnglmid);
 427         vYm      = vYc + dRadius * sin(dAnglmid);
 428         DoDrawArc( vX1
 429                   ,vY1
 430                   ,vXm
 431                   ,vYm
 432                   ,vXc
 433                   ,vYc
 434                  );
 435         DoDrawArc( vXm
 436                   ,vYm
 437                   ,vX2
 438                   ,vY2
 439                   ,vXc
 440                   ,vYc
 441                  );
 442         return;
 443     }
 444
 445     //
 446     // Medium point
 447     //
 448     dAnglmid = (dAngl1 + dAngl2)/2.;
 449     vXm      = vXc + dRadius * cos(dAnglmid);
 450     vYm      = vYc + dRadius * sin(dAnglmid);
 451
 452     //
 453     // Ellipse main axis (r,q), (p,s) with center at (0,0) */
 454     //
 455     vArcp.lR = 0;
 456     vArcp.lQ = 1;
 457     vArcp.lP = 1;
 458     vArcp.lS = 0;
 459     ::GpiSetArcParams(m_hPS, &vArcp); // Sets parameters to default
 460
 461     vPtlPos.x = vX1; // Loads x-coordinate
 462     vPtlPos.y = vY1; // Loads y-coordinate
 463     ::GpiMove(m_hPS, &vPtlPos); // Sets current position
 464     vPtlArc[0].x =  vXm;
 465     vPtlArc[0].y =  vYm;
 466     vPtlArc[1].x = vX2;
 467     vPtlArc[1].y = vY2;
 468     ::GpiPointArc(m_hPS, vPtlArc); // Draws the arc
 469 }
 470
 471 void wxDC::DoDrawCheckMark(
 472   wxCoord                           vX1
 473 , wxCoord                           vY1
 474 , wxCoord                           vWidth
 475 , wxCoord                           vHeight
 476 )
 477 {
 478     POINTL                          vPoint[2];
 479
 480     vPoint[0].x = vX1;
 481     vPoint[0].y = vY1;
 482     vPoint[1].x = vX1 + vWidth;
 483     vPoint[1].y = vY1 + vHeight;
 484
 485     ::GpiMove(m_hPS, &vPoint[0]);
 486     ::GpiBox( m_hPS       // handle to a presentation space
 487              ,DRO_OUTLINE // draw the box outline ? or ?
 488              ,&vPoint[1]  // address of the corner
 489              ,0L          // horizontal corner radius
 490              ,0L          // vertical corner radius
 491             );
 492     if(vWidth > 4 && vHeight > 4)
 493     {
 494         int                         nTmp;
 495
 496         vPoint[0].x += 2; vPoint[0].y += 2;
 497         vPoint[1].x -= 2; vPoint[1].y -= 2;
 498         ::GpiMove(m_hPS, &vPoint[0]);
 499         ::GpiLine(m_hPS, &vPoint[1]);
 500         nTmp = vPoint[0].x;
 501         vPoint[0].x = vPoint[1].x;
 502         vPoint[1].x = nTmp;
 503         ::GpiMove(m_hPS, &vPoint[0]);
 504         ::GpiLine(m_hPS, &vPoint[1]);
 505     }
 506 }
 507
 508 void wxDC::DoDrawPoint(
 509   wxCoord                           vX
 510 , wxCoord                           vY
 511 )
 512 {
 513     POINTL                          vPoint;
 514
 515     vPoint.x = vX;
 516     vPoint.y = vY;
 517     ::GpiSetPel(m_hPS, &vPoint);
 518 }
 519
 520 void wxDC::DoDrawPolygon(
 521   int                               n
 522 , wxPoint                           vPoints[]
 523 , wxCoord                           vXoffset
 524 , wxCoord                           vYoffset
 525 , int                               nFillStyle
 526 )
 527 {
 528     ULONG                           ulCount = 1;    // Number of polygons.
 529     POLYGON                         vPlgn;          // polygon.
 530     ULONG                           flOptions = 0L; // Drawing options.
 531
 532 //////////////////////////////////////////////////////////////////////////////
 533 // This contains fields of option bits... to draw boundary lines as well as
 534 // the area interior.
 535 //
 536 // Drawing boundary lines:
 537 //   POLYGON_NOBOUNDARY              Does not draw boundary lines.
 538 //   POLYGON_BOUNDARY                Draws boundary lines (the default).
 539 //
 540 // Construction of the area interior:
 541 //   POLYGON_ALTERNATE               Constructs interior in alternate mode
 542 //                                   (the default).
 543 //   POLYGON_WINDING                 Constructs interior in winding mode.
 544 //////////////////////////////////////////////////////////////////////////////
 545
 546     ULONG                           flModel = 0L; // Drawing model.
 547
 548 //////////////////////////////////////////////////////////////////////////////
 549 // Drawing model.
 550 //   POLYGON_INCL  Fill is inclusive of bottom right (the default).
 551 //   POLYGON_EXCL  Fill is exclusive of bottom right.
 552 //       This is provided to aid migration from other graphics models.
 553 //////////////////////////////////////////////////////////////////////////////
 554
 555     LONG                            lHits = 0L; // Correlation/error indicator.
 556     POINTL                          vPoint;
 557     int                             i;
 558     int                             nIsTRANSPARENT = 0;
 559     LONG                            lBorderColor = 0L;
 560     LONG                            lColor = 0L;
 561
 562     lBorderColor = m_pen.GetColour().GetPixel();
 563     lColor       = m_brush.GetColour().GetPixel();
 564     if(m_brush.GetStyle() == wxTRANSPARENT)
 565         nIsTRANSPARENT = 1;
 566
 567     vPlgn.ulPoints = n;
 568     vPlgn.aPointl = (POINTL*) calloc( n + 1
 569                                      ,sizeof(POINTL)
 570                                     ); // well, new will call malloc
 571
 572     for(i = 0; i < n; i++)
 573     {
 574         vPlgn.aPointl[i].x = vPoints[i].x; // +xoffset;
 575         vPlgn.aPointl[i].y = vPoints[i].y; // +yoffset;
 576     }
 577     flModel = POLYGON_BOUNDARY;
 578     if(nFillStyle == wxWINDING_RULE)
 579         flModel |= POLYGON_WINDING;
 580     else
 581         flModel |= POLYGON_ALTERNATE;
 582
 583     vPoint.x = vXoffset;
 584     vPoint.y = vYoffset;
 585
 586     ::GpiSetColor(m_hPS, lBorderColor);
 587     ::GpiMove(m_hPS, &vPoint);
 588     lHits = ::GpiPolygons(m_hPS, ulCount, &vPlgn, flOptions, flModel);
 589     free(vPlgn.aPointl);
 590 }
 591
 592 void wxDC::DoDrawLines(
 593   int                               n
 594 , wxPoint                           vPoints[]
 595 , wxCoord                           vXoffset
 596 , wxCoord                           vYoffset
 597 )
 598 {
 599     int                             i;
 600     POINTL                          vPoint;
 601
 602     vPoint.x = vPoints[0].x + vXoffset;
 603     vPoint.y = vPoints[0].y + vYoffset;
 604     ::GpiMove(m_hPS, &vPoint);
 605
 606     LONG                            lBorderColor = m_pen.GetColour().GetPixel();
 607
 608     ::GpiSetColor(m_hPS, lBorderColor);
 609     for(i = 1; i < n; i++)
 610     {
 611         vPoint.x = vPoints[0].x + vXoffset;
 612         vPoint.y = vPoints[0].y + vYoffset;
 613         ::GpiLine(m_hPS, &vPoint);
 614     }
 615 }
 616
 617 void wxDC::DoDrawRectangle(
 618   wxCoord                           vX
 619 , wxCoord                           vY
 620 , wxCoord                           vWidth
 621 , wxCoord                           vHeight
 622 )
 623 {
 624     POINTL                          vPoint[2];
 625     LONG                            lControl;
 626     LONG                            lColor;
 627     LONG                            lBorderColor;
 628     int                             nIsTRANSPARENT = 0;
 629
 630     vPoint[0].x = vX;
 631     vPoint[0].y = vY;
 632     vPoint[1].x = vX + vWidth;
 633     vPoint[1].y = vY - vHeight;
 634     ::GpiMove(m_hPS, &vPoint[0]);
 635     lColor       = m_brush.GetColour().GetPixel();
 636     lBorderColor = m_pen.GetColour().GetPixel();
 637     if (m_brush.GetStyle() == wxTRANSPARENT)
 638         nIsTRANSPARENT = 1;
 639     if(lColor == lBorderColor || nIsTRANSPARENT)
 640     {
 641         lControl = DRO_OUTLINEFILL; //DRO_FILL;
 642         if(m_brush.GetStyle() == wxTRANSPARENT)
 643             lControl = DRO_OUTLINE;
 644
 645         ::GpiSetColor(m_hPS, CLR_GREEN);
 646         ::GpiBox( m_hPS       // handle to a presentation space
 647                  ,lControl   // draw the box outline ? or ?
 648                  ,&vPoint[1]  // address of the corner
 649                  ,0L          // horizontal corner radius
 650                  ,0L          // vertical corner radius
 651                 );
 652     }
 653     else
 654     {
 655         lControl = DRO_OUTLINE;
 656         ::GpiSetColor( m_hPS
 657                       ,lBorderColor
 658                      );
 659         ::GpiBox( m_hPS
 660                  ,lControl
 661                  ,&vPoint[1]
 662                  ,0L
 663                  ,0L
 664                 );
 665         lControl = DRO_FILL;
 666         ::GpiSetColor( m_hPS
 667                       ,lColor
 668                      );
 669         ::GpiBox( m_hPS
 670                  ,lControl
 671                  ,&vPoint[1]
 672                  ,0L
 673                  ,0L
 674                 );
 675     }
 676 }
 677
 678 void wxDC::DoDrawRoundedRectangle(
 679   wxCoord                           vX
 680 , wxCoord                           vY
 681 , wxCoord                           vWidth
 682 , wxCoord                           vHeight
 683 , double                            dRadius
 684 )
 685 {
 686     POINTL                          vPoint[2];
 687     LONG                            lControl;
 688
 689     vPoint[0].x = vX;
 690     vPoint[0].y = vY;
 691     vPoint[1].x = vX + vWidth;
 692     vPoint[1].y = vY + vHeight;
 693     ::GpiMove(m_hPS, &vPoint[0]);
 694
 695     lControl = DRO_OUTLINEFILL; //DRO_FILL;
 696     if (m_brush.GetStyle() == wxTRANSPARENT)
 697         lControl = DRO_OUTLINE;
 698     ::GpiBox( m_hPS         // handle to a presentation space
 699              ,DRO_OUTLINE   // draw the box outline ? or ?
 700              ,&vPoint[1]    // address of the corner
 701              ,(LONG)dRadius // horizontal corner radius
 702              ,(LONG)dRadius // vertical corner radius
 703             );
 704 }
 705
 706 // Draw Ellipse within box (x,y) - (x+width, y+height)
 707 void wxDC::DoDrawEllipse(
 708   wxCoord                           vX
 709 , wxCoord                           vY
 710 , wxCoord                           vWidth
 711 , wxCoord                           vHeight
 712 )
 713 {
 714     POINTL                          vPtlPos; // Structure for current position
 715     FIXED                           vFxMult; // Multiplier for ellipse
 716     ARCPARAMS                       vArcp;   // Structure for arc parameters
 717
 718     vArcp.lR = 0;
 719     vArcp.lQ = vHeight/2;
 720     vArcp.lP = vWidth/2;
 721     vArcp.lS = 0;
 722     ::GpiSetArcParams( m_hPS
 723                       ,&vArcp
 724                      ); // Sets parameters to default
 725     vPtlPos.x = vX + vWidth/2;  // Loads x-coordinate
 726     vPtlPos.y = vY + vHeight/2; // Loads y-coordinate
 727     ::GpiMove( m_hPS
 728               ,&vPtlPos
 729              ); // Sets current position
 730     vFxMult = MAKEFIXED(1, 0);             /* Sets multiplier            */
 731
 732     //
 733     // DRO_FILL, DRO_OTLINEFILL - where to get
 734     //
 735     ::GpiFullArc( m_hPS
 736                  ,DRO_OUTLINE
 737                  ,vFxMult
 738                 ); // Draws full arc with center at current position
 739 }
 740
 741 void wxDC::DoDrawEllipticArc(
 742   wxCoord                           vX
 743 , wxCoord                           vY
 744 , wxCoord                           vWidth
 745 , wxCoord                           vHeight
 746 , double                            dSa
 747 , double                            dEa
 748 )
 749 {
 750     POINTL                          vPtlPos; // Structure for current position
 751     FIXED                           vFxMult; // Multiplier for ellipse
 752     ARCPARAMS                       vArcp;   // Structure for arc parameters
 753     FIXED                           vFSa;
 754     FIXED                           vFSweepa; // Start angle, sweep angle
 755     double                          dIntPart;
 756     double                          dFractPart;
 757     double                          dRadius;
 758
 759     dFractPart = modf(dSa,&dIntPart);
 760     vFSa = MAKEFIXED((int)dIntPart, (int)(dFractPart * 0xffff) );
 761     dFractPart = modf(dEa - dSa, &dIntPart);
 762     vFSweepa = MAKEFIXED((int)dIntPart, (int)(dFractPart * 0xffff) );
 763
 764     //
 765     // Ellipse main axis (r,q), (p,s) with center at (0,0)
 766     //
 767     vArcp.lR = 0;
 768     vArcp.lQ = vHeight/2;
 769     vArcp.lP = vWidth/2;
 770     vArcp.lS = 0;
 771     ::GpiSetArcParams(m_hPS, &vArcp); // Sets parameters to default
 772     vPtlPos.x = vX + vWidth/2  * (1. + cos(DegToRad(dSa))); // Loads x-coordinate
 773     vPtlPos.y = vY + vHeight/2 * (1. + sin(DegToRad(dSa))); // Loads y-coordinate
 774     ::GpiMove(m_hPS, &vPtlPos); // Sets current position
 775
 776     //
 777     // May be not to the center ?
 778     //
 779     vPtlPos.x = vX + vWidth/2 ; // Loads x-coordinate
 780     vPtlPos.y = vY + vHeight/2; // Loads y-coordinate
 781     vFxMult = MAKEFIXED(1, 0);  // Sets multiplier
 782
 783     //
 784     // DRO_FILL, DRO_OTLINEFILL - where to get
 785     //
 786     ::GpiPartialArc( m_hPS
 787                     ,&vPtlPos
 788                     ,vFxMult
 789                     ,vFSa
 790                     ,vFSweepa
 791                    );
 792 }
 793
 794 void wxDC::DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y)
 795 {
 796     // TODO:
 797 }
 798
 799 void wxDC::DoDrawBitmap( const wxBitmap &bmp
 800                         ,wxCoord x, wxCoord y
 801                         ,bool useMask
 802                        )
 803 {
 804    // TODO
 805 }
 806
 807 void wxDC::DoDrawText(
 808   const wxString&                   rsText
 809 , wxCoord                           vX
 810 , wxCoord                           vY
 811 )
 812 {
 813     DrawAnyText( rsText
 814                 ,vX
 815                 ,vY
 816                );
 817 }
 818
 819 void wxDC::DrawAnyText(
 820   const wxString&                   rsText
 821 , wxCoord                           vX
 822 , wxCoord                           vY
 823 )
 824 {
 825     int                             nOldBackground = 0;
 826     POINTL                          vPtlStart;
 827     LONG                            lHits;
 828
 829     //
 830     // prepare for drawing the text
 831     //
 832
 833     //
 834     // Set text color attributes
 835     //
 836     if (m_textForegroundColour.Ok())
 837     {
 838         SetTextColor( m_hPS
 839                      ,(int)m_textForegroundColour.GetPixel()
 840                     );
 841     }
 842
 843     if (m_textBackgroundColour.Ok())
 844     {
 845         nOldBackground = SetTextBkColor( m_hPS
 846                                         ,(int)m_textBackgroundColour.GetPixel()
 847                                        );
 848     }
 849     SetBkMode( m_hPS
 850               ,m_backgroundMode
 851              );
 852     vPtlStart.x = vX;
 853     vPtlStart.y = vY;
 854
 855     lHits = ::GpiCharStringAt( m_hPS
 856                               ,&vPtlStart
 857                               ,rsText.length()
 858                               ,(PCH)rsText.c_str()
 859                              );
 860     if (lHits != GPI_OK)
 861     {
 862         wxLogLastError(wxT("TextOut"));
 863     }
 864
 865     //
 866     // Restore the old parameters (text foreground colour may be left because
 867     // it never is set to anything else, but background should remain
 868     // transparent even if we just drew an opaque string)
 869     //
 870     if (m_textBackgroundColour.Ok())
 871             SetTextBkColor( m_hPS
 872                            ,nOldBackground
 873                           );
 874     SetBkMode( m_hPS
 875               ,wxTRANSPARENT
 876              );
 877 }
 878
 879 void wxDC::DoDrawRotatedText(
 880   const wxString&                   rsText
 881 , wxCoord                           vX
 882 , wxCoord                           vY
 883 , double                            dAngle
 884 )
 885 {
 886     if (dAngle == 0.0)
 887     {
 888         DoDrawText( rsText
 889                    ,vX
 890                    ,vY
 891                   );
 892     }
 893
 894    // TODO:
 895    /*
 896     if ( angle == 0.0 )
 897     {
 898         DoDrawText(text, x, y);
 899     }
 900     else
 901     {
 902         LOGFONT lf;
 903         wxFillLogFont(&lf, &m_font);
 904
 905         // GDI wants the angle in tenth of degree
 906         long angle10 = (long)(angle * 10);
 907         lf.lfEscapement = angle10;
 908         lf. lfOrientation = angle10;
 909
 910         HFONT hfont = ::CreateFontIndirect(&lf);
 911         if ( !hfont )
 912         {
 913             wxLogLastError("CreateFont");
 914         }
 915         else
 916         {
 917             HFONT hfontOld = ::SelectObject(GetHdc(), hfont);
 918
 919             DrawAnyText(text, x, y);
 920
 921             (void)::SelectObject(GetHdc(), hfontOld);
 922         }
 923
 924         // call the bounding box by adding all four vertices of the rectangle
 925         // containing the text to it (simpler and probably not slower than
 926         // determining which of them is really topmost/leftmost/...)
 927         wxCoord w, h;
 928         GetTextExtent(text, &w, &h);
 929
 930         double rad = DegToRad(angle);
 931
 932         // "upper left" and "upper right"
 933         CalcBoundingBox(x, y);
 934         CalcBoundingBox(x + w*cos(rad), y - h*sin(rad));
 935         CalcBoundingBox(x + h*sin(rad), y + h*cos(rad));
 936
 937         // "bottom left" and "bottom right"
 938         x += (wxCoord)(h*sin(rad));
 939         y += (wxCoord)(h*cos(rad));
 940         CalcBoundingBox(x, y);
 941         CalcBoundingBox(x + h*sin(rad), y + h*cos(rad));
 942     }
 943 */
 944 }
 945
 946 // ---------------------------------------------------------------------------
 947 // set GDI objects
 948 // ---------------------------------------------------------------------------
 949
 950 void wxDC::SetPalette(const wxPalette& palette)
 951 {
 952    // TODO
 953 }
 954
 955 void wxDC::SetFont(
 956   const wxFont&                     rFont
 957 )
 958 {
 959     //
 960     // Set the old object temporarily, in case the assignment deletes an object
 961     // that's not yet selected out.
 962     //
 963     if (m_hOldFont)
 964     {
 965 //        ::SelectObject(GetHdc(), (HFONT) m_hOldFont);
 966         m_hOldFont = 0;
 967     }
 968
 969     m_font = rFont;
 970
 971     if (!rFont.Ok())
 972     {
 973         if (m_hOldFont)
 974 //            ::SelectObject(GetHdc(), (HFONT) m_hOldFont);
 975         m_hOldFont = 0;
 976     }
 977
 978     if (m_font.Ok() && m_font.GetResourceHandle())
 979     {
 980         HFONT                       hFont = (HFONT)0; //::SelectObject(GetHdc(), (HFONT) m_font.GetResourceHandle());
 981         if (hFont == (HFONT) NULL)
 982         {
 983             wxLogDebug(wxT("::SelectObject failed in wxDC::SetFont."));
 984         }
 985         if (!m_hOldFont)
 986             m_hOldFont = (WXHFONT) hFont;
 987     }
 988 }
 989
 990 void wxDC::SetPen(
 991   const wxPen&                      rPen
 992 )
 993 {
 994     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 995
 996     if (m_pen == rPen)
 997         return;
 998     m_pen = rPen;
 999     if (!m_pen.Ok())
1000         return;
1001
1002     if (m_hOldPen)
1003         m_hOldPen = 0L;
1004     m_pen = rPen;
1005
1006     if (!m_pen.Ok())
1007     {
1008         if (m_hOldPen)
1009         {
1010             m_pen.SetPS((HPS)m_hOldPen);
1011         }
1012         m_hOldPen = 0L;
1013     }
1014
1015     if (m_pen.Ok())
1016     {
1017         if (m_pen.GetResourceHandle())
1018         {
1019             m_pen.SetPS(m_hPS);
1020             if (!m_hOldPen)
1021                 m_hOldPen = m_pen.GetPS();
1022         }
1023     }
1024
1025 }
1026
1027 void wxDC::SetBrush(
1028   const wxBrush&                    rBrush
1029 )
1030 {
1031    // TODO
1032 }
1033
1034 void wxDC::SetBackground(const wxBrush& brush)
1035 {
1036    // TODO
1037 }
1038
1039 void wxDC::SetBackgroundMode(
1040   int                               nMode
1041 )
1042 {
1043     m_backgroundMode = nMode;
1044 }
1045
1046 void wxDC::SetLogicalFunction(int function)
1047 {
1048    // TODO
1049 }
1050
1051 void wxDC::SetRop(WXHDC dc)
1052 {
1053     if (!dc || m_logicalFunction < 0)
1054         return;
1055
1056     int c_rop;
1057     // These may be wrong
1058     switch (m_logicalFunction)
1059     {
1060 // TODO: Figure this stuff out
1061         //    case wxXOR: c_rop = R2_XORPEN; break;
1062 //    case wxXOR: c_rop = R2_NOTXORPEN; break;
1063 //    case wxINVERT: c_rop = R2_NOT; break;
1064 //    case wxOR_REVERSE: c_rop = R2_MERGEPENNOT; break;
1065 //    case wxAND_REVERSE: c_rop = R2_MASKPENNOT; break;
1066 //    case wxCLEAR: c_rop = R2_WHITE; break;
1067 //    case wxSET: c_rop = R2_BLACK; break;
1068 //    case wxSRC_INVERT: c_rop = R2_NOTCOPYPEN; break;
1069 //    case wxOR_INVERT: c_rop = R2_MERGENOTPEN; break;
1070 //    case wxAND: c_rop = R2_MASKPEN; break;
1071 //    case wxOR: c_rop = R2_MERGEPEN; break;
1072 //    case wxAND_INVERT: c_rop = R2_MASKNOTPEN; break;
1073 //    case wxEQUIV:
1074 //    case wxNAND:
1075 //    case wxCOPY:
1076     default:
1077 //      c_rop = R2_COPYPEN;
1078         break;
1079     }
1080 //    SetROP2((HDC) dc, c_rop);
1081 }
1082
1083 bool wxDC::StartDoc(const wxString& message)
1084 {
1085     // We might be previewing, so return TRUE to let it continue.
1086     return TRUE;
1087 }
1088
1089 void wxDC::EndDoc()
1090 {
1091 }
1092
1093 void wxDC::StartPage()
1094 {
1095 }
1096
1097 void wxDC::EndPage()
1098 {
1099 }
1100
1101 // ---------------------------------------------------------------------------
1102 // text metrics
1103 // ---------------------------------------------------------------------------
1104
1105 wxCoord wxDC::GetCharHeight() const
1106 {
1107     // TODO
1108     return(8);
1109 }
1110
1111 wxCoord wxDC::GetCharWidth() const
1112 {
1113     // TODO
1114     return(8);
1115 }
1116
1117 void wxDC::DoGetTextExtent(
1118   const wxString&                   rsString
1119 , wxCoord*                          pvX
1120 , wxCoord*                          pvY
1121 , wxCoord*                          pvDescent
1122 , wxCoord*                          pvExternalLeading
1123 , wxFont*                           pTheFont
1124 ) const
1125 {
1126     POINTL                          avPoint[TXTBOX_COUNT];
1127     POINTL                          vPtMin;
1128     POINTL                          vPtMax;
1129     int                             i;
1130     int                             l;
1131     FONTMETRICS                     vFM; // metrics structure
1132     BOOL                            bRc;
1133     char*                           pStr;
1134     ERRORID                         vErrorCode; // last error id code
1135     wxFont*                         pFontToUse = (wxFont*)pTheFont;
1136
1137     if (!pFontToUse)
1138         pFontToUse = (wxFont*)&m_font;
1139     l = rsString.length();
1140     pStr = (PCH) rsString.c_str();
1141
1142     //
1143     // In world coordinates.
1144     //
1145     bRc = ::GpiQueryTextBox( m_hPS
1146                             ,l
1147                             ,pStr
1148                             ,TXTBOX_COUNT // return maximum information
1149                             ,avPoint      // array of coordinates points
1150                            );
1151     if(!bRc)
1152     {
1153        vErrorCode = ::WinGetLastError(wxGetInstance());
1154     }
1155
1156     vPtMin.x = avPoint[0].x;
1157     vPtMax.x = avPoint[0].x;
1158     vPtMin.y = avPoint[0].y;
1159     vPtMax.y = avPoint[0].y;
1160     for (i = 1; i < 4; i++)
1161     {
1162         if(vPtMin.x > avPoint[i].x) vPtMin.x = avPoint[i].x;
1163         if(vPtMin.y > avPoint[i].y) vPtMin.y = avPoint[i].y;
1164         if(vPtMax.x < avPoint[i].x) vPtMax.x = avPoint[i].x;
1165         if(vPtMax.y < avPoint[i].y) vPtMax.y = avPoint[i].y;
1166     }
1167     ::GpiQueryFontMetrics( m_hPS
1168                           ,sizeof(FONTMETRICS)
1169                           ,&vFM
1170                          );
1171
1172     if (pvX)
1173         *pvX = (wxCoord)(vPtMax.x - vPtMin.x + 1);
1174     if (pvY)
1175         *pvY = (wxCoord)(vPtMax.y - vPtMin.y + 1);
1176     if (pvDescent)
1177         *pvDescent = vFM.lMaxDescender;
1178     if (pvExternalLeading)
1179         *pvExternalLeading = vFM.lExternalLeading;
1180 }
1181
1182 void wxDC::SetMapMode( int mode )
1183 {
1184     // TODO:
1185 };
1186
1187 void wxDC::SetUserScale(double x, double y)
1188 {
1189     m_userScaleX = x;
1190     m_userScaleY = y;
1191
1192     SetMapMode(m_mappingMode);
1193 }
1194
1195 void wxDC::SetAxisOrientation(bool xLeftRight, bool yBottomUp)
1196 {
1197     m_signX = xLeftRight ? 1 : -1;
1198     m_signY = yBottomUp ? -1 : 1;
1199
1200     SetMapMode(m_mappingMode);
1201 }
1202
1203 void wxDC::SetSystemScale(double x, double y)
1204 {
1205     m_scaleX = x;
1206     m_scaleY = y;
1207
1208     SetMapMode(m_mappingMode);
1209 }
1210
1211 void wxDC::SetLogicalOrigin( wxCoord x, wxCoord y )
1212 {
1213     // TODO:
1214 };
1215
1216 void wxDC::SetDeviceOrigin( wxCoord x, wxCoord y )
1217 {
1218     RECTL                           vRect;
1219
1220     ::GpiQueryPageViewport( m_hPS
1221                            ,&vRect
1222                           );
1223     vRect.xLeft += x;
1224     vRect.xRight += x;
1225     vRect.yBottom -= y;
1226     vRect.yTop -= y;
1227     ::GpiSetPageViewport( m_hPS
1228                          ,&vRect
1229                         );
1230 };
1231
1232 // ---------------------------------------------------------------------------
1233 // coordinates transformations
1234 // ---------------------------------------------------------------------------
1235
1236 wxCoord wxDCBase::DeviceToLogicalX(wxCoord x) const
1237 {
1238     return (wxCoord) (((x) - m_deviceOriginX)/(m_logicalScaleX*m_userScaleX*m_signX*m_scaleX) - m_logicalOriginX);
1239 }
1240
1241 wxCoord wxDCBase::DeviceToLogicalXRel(wxCoord x) const
1242 {
1243     return (wxCoord) ((x)/(m_logicalScaleX*m_userScaleX*m_signX*m_scaleX));
1244 }
1245
1246 wxCoord wxDCBase::DeviceToLogicalY(wxCoord y) const
1247 {
1248     return (wxCoord) (((y) - m_deviceOriginY)/(m_logicalScaleY*m_userScaleY*m_signY*m_scaleY) - m_logicalOriginY);
1249 }
1250
1251 wxCoord wxDCBase::DeviceToLogicalYRel(wxCoord y) const
1252 {
1253     return (wxCoord) ((y)/(m_logicalScaleY*m_userScaleY*m_signY*m_scaleY));
1254 }
1255
1256 wxCoord wxDCBase::LogicalToDeviceX(wxCoord x) const
1257 {
1258     return (wxCoord) ((x - m_logicalOriginX)*m_logicalScaleX*m_userScaleX*m_signX*m_scaleX + m_deviceOriginX);
1259 }
1260
1261 wxCoord wxDCBase::LogicalToDeviceXRel(wxCoord x) const
1262 {
1263     return (wxCoord) (x*m_logicalScaleX*m_userScaleX*m_signX*m_scaleX);
1264 }
1265
1266 wxCoord wxDCBase::LogicalToDeviceY(wxCoord y) const
1267 {
1268     return (wxCoord) ((y - m_logicalOriginY)*m_logicalScaleY*m_userScaleY*m_signY*m_scaleY + m_deviceOriginY);
1269 }
1270
1271 wxCoord wxDCBase::LogicalToDeviceYRel(wxCoord y) const
1272 {
1273     return (wxCoord) (y*m_logicalScaleY*m_userScaleY*m_signY*m_scaleY);
1274 }
1275
1276 // ---------------------------------------------------------------------------
1277 // bit blit
1278 // ---------------------------------------------------------------------------
1279
1280 bool wxDC::DoBlit( wxCoord xdest
1281                   ,wxCoord ydest
1282                   ,wxCoord width
1283                   ,wxCoord height
1284                   ,wxDC *source
1285                   ,wxCoord xsrc
1286                   ,wxCoord ysrc
1287                   ,int  rop
1288                   ,bool useMask
1289                  )
1290 {
1291    // TODO
1292    return(TRUE);
1293 }
1294
1295 void wxDC::DoGetSize( int* width, int* height ) const
1296 {
1297     // TODO:
1298 };
1299
1300 void wxDC::DoGetSizeMM( int* width, int* height ) const
1301 {
1302     // TODO:
1303 };
1304
1305 wxSize wxDC::GetPPI() const
1306 {
1307    int x = 1;
1308    int y = 1;
1309    // TODO:
1310    return (wxSize(x,y));
1311 }
1312
1313 void wxDC::SetLogicalScale( double x, double y )
1314 {
1315     // TODO:
1316 };
1317
1318 #if WXWIN_COMPATIBILITY
1319 void wxDC::DoGetTextExtent(const wxString& string, float *x, float *y,
1320                          float *descent, float *externalLeading,
1321                          wxFont *theFont, bool use16bit) const
1322 {
1323     wxCoord x1, y1, descent1, externalLeading1;
1324     GetTextExtent(string, & x1, & y1, & descent1, & externalLeading1, theFont, use16bit);
1325     *x = x1; *y = y1;
1326     if (descent)
1327         *descent = descent1;
1328     if (externalLeading)
1329         *externalLeading = externalLeading1;
1330 }
1331 #endif
1332
1333 // ---------------------------------------------------------------------------
1334 // spline drawing code
1335 // ---------------------------------------------------------------------------
1336
1337 #if wxUSE_SPLINES
1338
1339 class wxSpline: public wxObject
1340 {
1341 public:
1342     int type;
1343     wxList *points;
1344
1345     wxSpline(wxList *list);
1346     void DeletePoints();
1347
1348     // Doesn't delete points
1349     ~wxSpline();
1350 };
1351
1352 void wx_draw_open_spline(wxDC *dc, wxSpline *spline);
1353
1354 void wx_quadratic_spline(double a1, double b1, double a2, double b2,
1355                          double a3, double b3, double a4, double b4);
1356 void wx_clear_stack();
1357 int wx_spline_pop(double *x1, double *y1, double *x2, double *y2, double *x3,
1358                   double *y3, double *x4, double *y4);
1359 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3,
1360                     double x4, double y4);
1361 static bool wx_spline_add_point(double x, double y);
1362 static void wx_spline_draw_point_array(wxDC *dc);
1363 wxSpline *wx_make_spline(int x1, int y1, int x2, int y2, int x3, int y3);
1364
1365 void wxDC::DoDrawSpline(wxList *list)
1366 {
1367     wxSpline spline(list);
1368
1369     wx_draw_open_spline(this, &spline);
1370 }
1371
1372 wxList wx_spline_point_list;
1373
1374 void wx_draw_open_spline(wxDC *dc, wxSpline *spline)
1375 {
1376     wxPoint *p;
1377     double           cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4;
1378     double           x1, y1, x2, y2;
1379
1380     wxNode *node = spline->points->First();
1381     p = (wxPoint *)node->Data();
1382
1383     x1 = p->x;
1384     y1 = p->y;
1385
1386     node = node->Next();
1387     p = (wxPoint *)node->Data();
1388
1389     x2 = p->x;
1390     y2 = p->y;
1391     cx1 = (double)((x1 + x2) / 2);
1392     cy1 = (double)((y1 + y2) / 2);
1393     cx2 = (double)((cx1 + x2) / 2);
1394     cy2 = (double)((cy1 + y2) / 2);
1395
1396     wx_spline_add_point(x1, y1);
1397
1398     while ((node = node->Next()) != NULL)
1399     {
1400         p = (wxPoint *)node->Data();
1401         x1 = x2;
1402         y1 = y2;
1403         x2 = p->x;
1404         y2 = p->y;
1405         cx4 = (double)(x1 + x2) / 2;
1406         cy4 = (double)(y1 + y2) / 2;
1407         cx3 = (double)(x1 + cx4) / 2;
1408         cy3 = (double)(y1 + cy4) / 2;
1409
1410         wx_quadratic_spline(cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4);
1411
1412         cx1 = cx4;
1413         cy1 = cy4;
1414         cx2 = (double)(cx1 + x2) / 2;
1415         cy2 = (double)(cy1 + y2) / 2;
1416     }
1417
1418     wx_spline_add_point((double)wx_round(cx1), (double)wx_round(cy1));
1419     wx_spline_add_point(x2, y2);
1420
1421     wx_spline_draw_point_array(dc);
1422
1423 }
1424
1425 /********************* CURVES FOR SPLINES *****************************
1426
1427   The following spline drawing routine is from
1428
1429     "An Algorithm for High-Speed Curve Generation"
1430     by George Merrill Chaikin,
1431     Computer Graphics and Image Processing, 3, Academic Press,
1432     1974, 346-349.
1433
1434       and
1435
1436         "On Chaikin's Algorithm" by R. F. Riesenfeld,
1437         Computer Graphics and Image Processing, 4, Academic Press,
1438         1975, 304-310.
1439
1440 ***********************************************************************/
1441
1442 #define     half(z1, z2)    ((z1+z2)/2.0)
1443 #define     THRESHOLD   5
1444
1445 /* iterative version */
1446
1447 void wx_quadratic_spline(double a1, double b1, double a2, double b2, double a3, double b3, double a4,
1448                          double b4)
1449 {
1450     register double  xmid, ymid;
1451     double           x1, y1, x2, y2, x3, y3, x4, y4;
1452
1453     wx_clear_stack();
1454     wx_spline_push(a1, b1, a2, b2, a3, b3, a4, b4);
1455
1456     while (wx_spline_pop(&x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4)) {
1457         xmid = (double)half(x2, x3);
1458         ymid = (double)half(y2, y3);
1459         if (fabs(x1 - xmid) < THRESHOLD && fabs(y1 - ymid) < THRESHOLD &&
1460             fabs(xmid - x4) < THRESHOLD && fabs(ymid - y4) < THRESHOLD) {
1461             wx_spline_add_point((double)wx_round(x1), (double)wx_round(y1));
1462             wx_spline_add_point((double)wx_round(xmid), (double)wx_round(ymid));
1463         } else {
1464             wx_spline_push(xmid, ymid, (double)half(xmid, x3), (double)half(ymid, y3),
1465                 (double)half(x3, x4), (double)half(y3, y4), x4, y4);
1466             wx_spline_push(x1, y1, (double)half(x1, x2), (double)half(y1, y2),
1467                 (double)half(x2, xmid), (double)half(y2, ymid), xmid, ymid);
1468         }
1469     }
1470 }
1471
1472
1473 /* utilities used by spline drawing routines */
1474
1475
1476 typedef struct wx_spline_stack_struct {
1477     double           x1, y1, x2, y2, x3, y3, x4, y4;
1478 }
1479 Stack;
1480
1481 #define         SPLINE_STACK_DEPTH             20
1482 static Stack    wx_spline_stack[SPLINE_STACK_DEPTH];
1483 static Stack   *wx_stack_top;
1484 static int      wx_stack_count;
1485
1486 void wx_clear_stack()
1487 {
1488     wx_stack_top = wx_spline_stack;
1489     wx_stack_count = 0;
1490 }
1491
1492 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
1493 {
1494     wx_stack_top->x1 = x1;
1495     wx_stack_top->y1 = y1;
1496     wx_stack_top->x2 = x2;
1497     wx_stack_top->y2 = y2;
1498     wx_stack_top->x3 = x3;
1499     wx_stack_top->y3 = y3;
1500     wx_stack_top->x4 = x4;
1501     wx_stack_top->y4 = y4;
1502     wx_stack_top++;
1503     wx_stack_count++;
1504 }
1505
1506 int wx_spline_pop(double *x1, double *y1, double *x2, double *y2,
1507                   double *x3, double *y3, double *x4, double *y4)
1508 {
1509     if (wx_stack_count == 0)
1510         return (0);
1511     wx_stack_top--;
1512     wx_stack_count--;
1513     *x1 = wx_stack_top->x1;
1514     *y1 = wx_stack_top->y1;
1515     *x2 = wx_stack_top->x2;
1516     *y2 = wx_stack_top->y2;
1517     *x3 = wx_stack_top->x3;
1518     *y3 = wx_stack_top->y3;
1519     *x4 = wx_stack_top->x4;
1520     *y4 = wx_stack_top->y4;
1521     return (1);
1522 }
1523
1524 static bool wx_spline_add_point(double x, double y)
1525 {
1526     wxPoint *point = new wxPoint;
1527     point->x = (int) x;
1528     point->y = (int) y;
1529     wx_spline_point_list.Append((wxObject*)point);
1530     return TRUE;
1531 }
1532
1533 static void wx_spline_draw_point_array(wxDC *dc)
1534 {
1535     dc->DrawLines(&wx_spline_point_list, 0, 0);
1536     wxNode *node = wx_spline_point_list.First();
1537     while (node)
1538     {
1539         wxPoint *point = (wxPoint *)node->Data();
1540         delete point;
1541         delete node;
1542         node = wx_spline_point_list.First();
1543     }
1544 }
1545
1546 wxSpline::wxSpline(wxList *list)
1547 {
1548     points = list;
1549 }
1550
1551 wxSpline::~wxSpline()
1552 {
1553 }
1554
1555 void wxSpline::DeletePoints()
1556 {
1557     for(wxNode *node = points->First(); node; node = points->First())
1558     {
1559         wxPoint *point = (wxPoint *)node->Data();
1560         delete point;
1561         delete node;
1562     }
1563     delete points;
1564 }
1565
1566
1567 #endif // wxUSE_SPLINES
1568