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     return vCbnd.lBackColor;
  85 }
  86
  87
  88 int SetTextBkColor(
  89   HPS                               hPS
  90 , int                               nBackgroundColour
  91 )
  92 {
  93     CHARBUNDLE                      vCbnd;
  94     int                             rc;
  95
  96     rc =  QueryTextBkColor(hPS);
  97
  98     vCbnd.lBackColor = nBackgroundColour;
  99     ::GpiSetAttrs(hPS,            // presentation-space handle
 100                   PRIM_CHAR,      // Char primitive.
 101                   CBB_BACK_COLOR, // sets color.
 102                   0,
 103                   &vCbnd          // buffer for attributes.
 104                  );
 105     return rc;
 106 }
 107
 108 int SetBkMode(
 109   HPS                               hPS
 110 , int                               nBackgroundMode
 111 )
 112 {
 113     if(nBackgroundMode == wxTRANSPARENT)
 114         ::GpiSetBackMix( hPS
 115                         ,BM_LEAVEALONE
 116                        );
 117     else
 118         // the background of the primitive takes  over whatever is underneath.
 119         ::GpiSetBackMix( hPS
 120                         ,BM_OVERPAINT
 121                         );
 122     return 0;
 123 }
 124
 125 // ===========================================================================
 126 // implementation
 127 // ===========================================================================
 128
 129 // ---------------------------------------------------------------------------
 130 // wxDC
 131 // ---------------------------------------------------------------------------
 132
 133 wxDC::wxDC(void)
 134 {
 135     m_pCanvas      = NULL;
 136
 137     m_hOldBitmap   = 0;
 138     m_hOldPen      = 0;
 139     m_hOldBrush    = 0;
 140     m_hOldFont     = 0;
 141     m_hOldPalette  = 0;
 142
 143     m_bOwnsDC      = FALSE;
 144     m_hDC          = 0;
 145     m_nDCCount     = 0;
 146     m_hOldPS       = NULL;
 147     m_hPS          = NULL;
 148     m_bIsPaintTime = FALSE;// True at Paint Time
 149 };
 150
 151 wxDC::~wxDC(void)
 152 {
 153     // TODO:
 154 };
 155
 156 // This will select current objects out of the DC,
 157 // which is what you have to do before deleting the
 158 // DC.
 159 void wxDC::SelectOldObjects(WXHDC dc)
 160 {
 161     if (dc)
 162     {
 163         if (m_hOldBitmap)
 164         {
 165 //            ::SelectObject((HDC) dc, (HBITMAP) m_oldBitmap);
 166             if (m_vSelectedBitmap.Ok())
 167             {
 168                 m_vSelectedBitmap.SetSelectedInto(NULL);
 169             }
 170         }
 171         m_hOldBitmap = 0;
 172         if (m_hOldPen)
 173         {
 174 //            ::SelectObject((HDC) dc, (HPEN) m_oldPen);
 175         }
 176         m_hOldPen = 0;
 177         if (m_hOldBrush)
 178         {
 179 //            ::SelectObject((HDC) dc, (HBRUSH) m_oldBrush);
 180         }
 181         m_hOldBrush = 0;
 182         if (m_hOldFont)
 183         {
 184 //            ::SelectObject((HDC) dc, (HFONT) m_oldFont);
 185         }
 186         m_hOldFont = 0;
 187         if (m_hOldPalette)
 188         {
 189 //            ::SelectPalette((HDC) dc, (HPALETTE) m_oldPalette, TRUE);
 190         }
 191         m_hOldPalette = 0;
 192     }
 193
 194     m_brush           = wxNullBrush;
 195     m_pen             = wxNullPen;
 196     m_palette         = wxNullPalette;
 197     m_font            = wxNullFont;
 198     m_backgroundBrush = wxNullBrush;
 199     m_vSelectedBitmap = wxNullBitmap;
 200 }
 201
 202 // ---------------------------------------------------------------------------
 203 // clipping
 204 // ---------------------------------------------------------------------------
 205
 206 #define DO_SET_CLIPPING_BOX()                   \
 207 {                                               \
 208     RECT rect;                                  \
 209                                                 \
 210     GetClipBox(GetHdc(), &rect);                \
 211                                                 \
 212     m_clipX1 = (wxCoord) XDEV2LOG(rect.left);   \
 213     m_clipY1 = (wxCoord) YDEV2LOG(rect.top);    \
 214     m_clipX2 = (wxCoord) XDEV2LOG(rect.right);  \
 215     m_clipY2 = (wxCoord) YDEV2LOG(rect.bottom); \
 216 }
 217
 218 void wxDC::DoSetClippingRegion( wxCoord x, wxCoord y
 219                                ,wxCoord width, wxCoord height
 220                               )
 221 {
 222    // TODO
 223 }
 224
 225 void wxDC::DoSetClippingRegionAsRegion(const wxRegion& region)
 226 {
 227    // TODO
 228 }
 229
 230 void wxDC::DestroyClippingRegion(void)
 231 {
 232     // TODO:
 233 };
 234
 235 // ---------------------------------------------------------------------------
 236 // query capabilities
 237 // ---------------------------------------------------------------------------
 238
 239 bool wxDC::CanDrawBitmap() const
 240 {
 241     return TRUE;
 242 }
 243
 244 bool wxDC::CanGetTextExtent() const
 245 {
 246     // What sort of display is it?
 247     int technology = 0; // TODO:  ::GetDeviceCaps(GetHdc(), TECHNOLOGY);
 248
 249     // TODO: return (technology == DT_RASDISPLAY) || (technology == DT_RASPRINTER);
 250     return FALSE;
 251 }
 252
 253 int wxDC::GetDepth() const
 254 {
 255    // TODO:
 256    return (1);
 257 }
 258
 259 // ---------------------------------------------------------------------------
 260 // drawing
 261 // ---------------------------------------------------------------------------
 262
 263 void wxDC::Clear()
 264 {
 265    // TODO
 266 }
 267
 268 void wxDC::DoFloodFill( wxCoord x
 269                        ,wxCoord y
 270                        ,const wxColour& col
 271                        ,int style
 272                       )
 273 {
 274    // TODO
 275 }
 276
 277 bool wxDC::DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const
 278 {
 279    // TODO
 280    return(TRUE);
 281 }
 282
 283 void wxDC::DoCrossHair(wxCoord x, wxCoord y)
 284 {
 285    // TODO
 286 }
 287
 288 void wxDC::DoDrawLine(
 289   wxCoord                           vX1
 290 , wxCoord                           vY1
 291 , wxCoord                           vX2
 292 , wxCoord                           vY2
 293 )
 294 {
 295     POINTL                          vPoint[2];
 296
 297     vPoint[0].x = vX1;
 298     vPoint[0].y = vY1;
 299     vPoint[1].x = vX2;
 300     vPoint[1].y = vY2;
 301     // ::GpiSetColor(m_hPS,CLR_RED); //DEbug
 302     ::GpiMove(m_hPS, &vPoint[0]);
 303     ::GpiLine(m_hPS, &vPoint[1]);
 304 }
 305
 306 void wxDC::DoDrawArc( wxCoord x1, wxCoord y1
 307                      ,wxCoord x2, wxCoord y2
 308                      ,wxCoord xc, wxCoord yc
 309                     )
 310 {
 311    // TODO
 312 }
 313
 314 void wxDC::DoDrawCheckMark(wxCoord x1, wxCoord y1,
 315                            wxCoord width, wxCoord height)
 316 {
 317     // TODO
 318 }
 319
 320 void wxDC::DoDrawPoint(wxCoord x, wxCoord y)
 321 {
 322    // TODO
 323 }
 324
 325 void wxDC::DoDrawPolygon(int n, wxPoint points[]
 326                          ,wxCoord xoffset, wxCoord yoffset
 327                          ,int fillStyle
 328                         )
 329 {
 330    // TODO
 331 }
 332
 333 void wxDC::DoDrawLines( int n, wxPoint points[]
 334                        ,wxCoord xoffset, wxCoord yoffset
 335                       )
 336 {
 337    // TODO
 338 }
 339
 340 void wxDC::DoDrawRectangle(
 341   wxCoord                           vS
 342 , wxCoord                           vY
 343 , wxCoord                           vWidth
 344 , wxCoord                           vHeight
 345 )
 346 {
 347     POINTL                          vPoint[2];
 348
 349     vPoint[0].x = vX;
 350     vPoint[0].y = vY;
 351     vPoint[1].x = vX + Width;
 352     vPoint[1].y = vY - Height;      //mustdie !!! ??
 353
 354     ::GpiMove(m_hPS, &vPoint[0]);
 355     ::GpiBox( m_hPS       // handle to a presentation space
 356              ,DRO_OUTLINE // draw the box outline ? or ?
 357              ,&vPoint[1]  // address of the corner
 358              ,0L          // horizontal corner radius
 359              ,0L          // vertical corner radius
 360             );
 361 }
 362
 363 void wxDC::DoDrawRoundedRectangle(
 364   wxCoord                           vX
 365 , wxCoord                           vY
 366 , wxCoord                           vWidth
 367 , wxCoord                           vHeight
 368 , double                            dRadius
 369 )
 370 {
 371     POINTL                          vPoint[2];
 372
 373     vPoint[0].x = vX;
 374     vPoint[0].y = vY;
 375     vPoint[1].x = vX + vWidth;
 376     vPoint[1].y = vY + vHeight;      //or -height aka mustdie !!! ??
 377
 378     ::GpiMove(m_hPS, &vPoint[0]);
 379     ::GpiBox( m_hPS        // handle to a presentation space
 380              ,DRO_OUTLINE  // draw the box outline ? or ?
 381              ,&vPoint[1]   // address of the corner
 382              ,(LONG)radius // horizontal corner radius
 383              ,(LONG)radius // vertical corner radius
 384             );
 385 }
 386
 387 void wxDC::DoDrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
 388 {
 389    // TODO
 390 }
 391
 392 void wxDC::DoDrawEllipticArc( wxCoord x
 393                              ,wxCoord y
 394                              ,wxCoord w
 395                              ,wxCoord h
 396                              ,double sa
 397                              ,double ea
 398                             )
 399 {
 400    // TODO
 401 }
 402
 403 void wxDC::DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y)
 404 {
 405    // TODO
 406 }
 407
 408 void wxDC::DoDrawBitmap( const wxBitmap &bmp
 409                         ,wxCoord x, wxCoord y
 410                         ,bool useMask
 411                        )
 412 {
 413    // TODO
 414 }
 415
 416 void wxDC::DoDrawText(
 417   const wxString&                   rsText
 418 , wxCoord                           vX
 419 , wxCoord                           vY
 420 )
 421 {
 422     DrawAnyText( rsText
 423                 ,vX
 424                 ,vY
 425                );
 426 }
 427
 428 void wxDC::DrawAnyText(
 429   const wxString&                   rsText
 430 , wxCoord                           vX
 431 , wxCoord                           vY
 432 )
 433 {
 434     int                             nOldBackground = 0;
 435     POINTL                          vPtlStart;
 436     LONG                            lHits;
 437
 438     //
 439     // prepare for drawing the text
 440     //
 441
 442     //
 443     // Set text color attributes
 444     //
 445     if (m_textForegroundColour.Ok())
 446     {
 447         SetTextColor( m_hPS
 448                      ,(int)m_textForegroundColour.GetPixel()
 449                     );
 450     }
 451
 452     if (m_textBackgroundColour.Ok())
 453     {
 454         nOldBackground = SetTextBkColor( m_hPS
 455                                         ,(int)m_textBackgroundColour.GetPixel()
 456                                        );
 457     }
 458     SetBkMode( m_hPS
 459               ,m_backgroundMode
 460              );
 461     vPtlStart.x = vX;
 462     vPtlStart.y = vY;
 463
 464     lHits = ::GpiCharStringAt( m_hPS
 465                               ,&vPtlStart
 466                               ,rsText.length()
 467                               ,(PCH)rsText.c_str()
 468                              );
 469     if (lHits != GPI_OK)
 470     {
 471         wxLogLastError(wxT("TextOut"));
 472     }
 473
 474     //
 475     // Restore the old parameters (text foreground colour may be left because
 476     // it never is set to anything else, but background should remain
 477     // transparent even if we just drew an opaque string)
 478     //
 479     if (m_textBackgroundColour.Ok())
 480             SetTextBkColor( m_hPS
 481                            ,nOldBackground
 482                           );
 483     SetBkMode( m_hPS
 484               ,wxTRANSPARENT
 485              );
 486 }
 487
 488 void wxDC::DoDrawRotatedText(
 489   const wxString&                   rsText
 490 , wxCoord                           vX
 491 , wxCoord                           vY
 492 , double                            dAngle
 493 )
 494 {
 495     if (dAngle == 0.0)
 496     {
 497         DoDrawText( rsText
 498                    ,vX
 499                    ,vY
 500                   );
 501     }
 502
 503    // TODO:
 504    /*
 505     if ( angle == 0.0 )
 506     {
 507         DoDrawText(text, x, y);
 508     }
 509     else
 510     {
 511         LOGFONT lf;
 512         wxFillLogFont(&lf, &m_font);
 513
 514         // GDI wants the angle in tenth of degree
 515         long angle10 = (long)(angle * 10);
 516         lf.lfEscapement = angle10;
 517         lf. lfOrientation = angle10;
 518
 519         HFONT hfont = ::CreateFontIndirect(&lf);
 520         if ( !hfont )
 521         {
 522             wxLogLastError("CreateFont");
 523         }
 524         else
 525         {
 526             HFONT hfontOld = ::SelectObject(GetHdc(), hfont);
 527
 528             DrawAnyText(text, x, y);
 529
 530             (void)::SelectObject(GetHdc(), hfontOld);
 531         }
 532
 533         // call the bounding box by adding all four vertices of the rectangle
 534         // containing the text to it (simpler and probably not slower than
 535         // determining which of them is really topmost/leftmost/...)
 536         wxCoord w, h;
 537         GetTextExtent(text, &w, &h);
 538
 539         double rad = DegToRad(angle);
 540
 541         // "upper left" and "upper right"
 542         CalcBoundingBox(x, y);
 543         CalcBoundingBox(x + w*cos(rad), y - h*sin(rad));
 544         CalcBoundingBox(x + h*sin(rad), y + h*cos(rad));
 545
 546         // "bottom left" and "bottom right"
 547         x += (wxCoord)(h*sin(rad));
 548         y += (wxCoord)(h*cos(rad));
 549         CalcBoundingBox(x, y);
 550         CalcBoundingBox(x + h*sin(rad), y + h*cos(rad));
 551     }
 552 */
 553 }
 554
 555 // ---------------------------------------------------------------------------
 556 // set GDI objects
 557 // ---------------------------------------------------------------------------
 558
 559 void wxDC::SetPalette(const wxPalette& palette)
 560 {
 561    // TODO
 562 }
 563
 564 void wxDC::SetFont(
 565   const wxFont&                     rFont
 566 )
 567 {
 568     //
 569     // Set the old object temporarily, in case the assignment deletes an object
 570     // that's not yet selected out.
 571     //
 572     if (m_hOldFont)
 573     {
 574 //        ::SelectObject(GetHdc(), (HFONT) m_hOldFont);
 575         m_hOldFont = 0;
 576     }
 577
 578     m_font = rFont;
 579
 580     if (!rFont.Ok())
 581     {
 582         if (m_hOldFont)
 583 //            ::SelectObject(GetHdc(), (HFONT) m_hOldFont);
 584         m_hOldFont = 0;
 585     }
 586
 587     if (m_font.Ok() && m_font.GetResourceHandle())
 588     {
 589         HFONT                       hFont = (HFONT)0; //::SelectObject(GetHdc(), (HFONT) m_font.GetResourceHandle());
 590         if (hFont == (HFONT) NULL)
 591         {
 592             wxLogDebug(wxT("::SelectObject failed in wxDC::SetFont."));
 593         }
 594         if (!m_hOldFont)
 595             m_hOldFont = (WXHFONT) hFont;
 596     }
 597 }
 598
 599 void wxDC::SetPen(
 600   const wxPen&                      rPen
 601 )
 602 {
 603     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 604
 605     if (m_pen == rPen)
 606         return;
 607     m_pen = rPen;
 608     if (!m_pen.Ok())
 609         return;
 610
 611     int                             nWidth = m_pen.GetWidth();
 612
 613     if (nWidth <= 0)
 614     {
 615         nWidth = 1;
 616     }
 617     else
 618     {
 619         double                      dW = 0.5 +
 620                                        ( fabs((double) XLOG2DEVREL(width)) +
 621                                          fabs((double) YLOG2DEVREL(width))
 622                                        ) / 2.0;
 623         nWidth = (int)dW;
 624     }
 625     wxColour                        vColor = m_pen.GetColour();
 626
 627     ::GpiSetColor( m_hPS
 628                   ,vColor.GetPixel()
 629                  ); //DEbug ??
 630 }
 631
 632 void wxDC::SetBrush(const wxBrush& brush)
 633 {
 634    // TODO
 635 }
 636
 637 void wxDC::SetBackground(const wxBrush& brush)
 638 {
 639    // TODO
 640 }
 641
 642 void wxDC::SetBackgroundMode(
 643   int                               nMode
 644 )
 645 {
 646     m_backgroundMode = nMode;
 647 }
 648
 649 void wxDC::SetLogicalFunction(int function)
 650 {
 651    // TODO
 652 }
 653
 654 void wxDC::SetRop(WXHDC dc)
 655 {
 656     if (!dc || m_logicalFunction < 0)
 657         return;
 658
 659     int c_rop;
 660     // These may be wrong
 661     switch (m_logicalFunction)
 662     {
 663 // TODO: Figure this stuff out
 664         //    case wxXOR: c_rop = R2_XORPEN; break;
 665 //    case wxXOR: c_rop = R2_NOTXORPEN; break;
 666 //    case wxINVERT: c_rop = R2_NOT; break;
 667 //    case wxOR_REVERSE: c_rop = R2_MERGEPENNOT; break;
 668 //    case wxAND_REVERSE: c_rop = R2_MASKPENNOT; break;
 669 //    case wxCLEAR: c_rop = R2_WHITE; break;
 670 //    case wxSET: c_rop = R2_BLACK; break;
 671 //    case wxSRC_INVERT: c_rop = R2_NOTCOPYPEN; break;
 672 //    case wxOR_INVERT: c_rop = R2_MERGENOTPEN; break;
 673 //    case wxAND: c_rop = R2_MASKPEN; break;
 674 //    case wxOR: c_rop = R2_MERGEPEN; break;
 675 //    case wxAND_INVERT: c_rop = R2_MASKNOTPEN; break;
 676 //    case wxEQUIV:
 677 //    case wxNAND:
 678 //    case wxCOPY:
 679     default:
 680 //      c_rop = R2_COPYPEN;
 681         break;
 682     }
 683 //    SetROP2((HDC) dc, c_rop);
 684 }
 685
 686 bool wxDC::StartDoc(const wxString& message)
 687 {
 688     // We might be previewing, so return TRUE to let it continue.
 689     return TRUE;
 690 }
 691
 692 void wxDC::EndDoc()
 693 {
 694 }
 695
 696 void wxDC::StartPage()
 697 {
 698 }
 699
 700 void wxDC::EndPage()
 701 {
 702 }
 703
 704 // ---------------------------------------------------------------------------
 705 // text metrics
 706 // ---------------------------------------------------------------------------
 707
 708 wxCoord wxDC::GetCharHeight() const
 709 {
 710     // TODO
 711     return(8);
 712 }
 713
 714 wxCoord wxDC::GetCharWidth() const
 715 {
 716     // TODO
 717     return(8);
 718 }
 719
 720 void wxDC::DoGetTextExtent(
 721   const wxString&                   rsString
 722 , wxCoord*                          pvX
 723 , wxCoord*                          pvY
 724 , wxCoord*                          pvDecent
 725 , wxCoord*                          pvExternalLeading
 726 , wxFont*                           pTheFont
 727 ) const
 728 {
 729     POINTL                          avPoint[TXTBOX_COUNT];
 730     POINTL                          vPtMin;
 731     POINTL                          vPtMax;
 732     int                             i;
 733     int                             l;
 734     FONTMETRICS                     vFM; // metrics structure
 735     BOOL                            bRc;
 736     char*                           pStr;
 737     ERRORID                         vErrorCode; // last error id code
 738     wxFont*                         pFontToUse = (wxFont*)pTheFont;
 739
 740     if (!pFontToUse)
 741         pFontToUse = (wxFont*)&m_font;
 742     l = rsString.length();
 743     pStr = (PCH) rsString.c_str();
 744
 745     //
 746     // In world coordinates.
 747     //
 748     bRc = ::GpiQueryTextBox( m_hPS
 749                             ,l
 750                             ,pStr
 751                             ,TXTBOX_COUNT // return maximum information
 752                             ,avPoint      // array of coordinates points
 753                            )
 754     if(!bRc)
 755     {
 756        vErrorCode = ::WinGetLastError(wxGetInstance());
 757     }
 758
 759     vPtMin.x = avPoint[0].x;
 760     vPtMax.x = avPoint[0].x;
 761     vPtMin.y = avPoint[0].y;
 762     vPtMax.y = avPoint[0].y;
 763     for (i = 1; i < 4; i++)
 764     {
 765         if(vPtMin.x > avPoint[i].x) vPtMin.x = avPoint[i].x;
 766         if(vPtMin.y > avPoint[i].y) vPtMin.y = avPoint[i].y;
 767         if(vPtMax.x < avPoint[i].x) vPtMax.x = avPoint[i].x;
 768         if(vPtMax.y < avPoint[i].y) vPtMax.y = avPoint[i].y;
 769     }
 770     ::GpiQueryFontMetrics( m_hPS
 771                           ,sizeof(FONTMETRICS)
 772                           ,&vFM
 773                          );
 774
 775     if (pvX)
 776         *pvX = (wxCoord)(vPtMax.x - vPtMin.x + 1);
 777     if (pvY)
 778         *pvY = (wxCoord)(vPtMax.y - vPtMin.y + 1);
 779     if (pvDescent)
 780         *pvDescent = vFM.lMaxDescender;
 781     if (externalLeading)
 782         *pvExternalLeading = vFM.lExternalLeading;
 783 }
 784
 785 void wxDC::SetMapMode( int mode )
 786 {
 787     // TODO:
 788 };
 789
 790 void wxDC::SetUserScale(double x, double y)
 791 {
 792     m_userScaleX = x;
 793     m_userScaleY = y;
 794
 795     SetMapMode(m_mappingMode);
 796 }
 797
 798 void wxDC::SetAxisOrientation(bool xLeftRight, bool yBottomUp)
 799 {
 800     m_signX = xLeftRight ? 1 : -1;
 801     m_signY = yBottomUp ? -1 : 1;
 802
 803     SetMapMode(m_mappingMode);
 804 }
 805
 806 void wxDC::SetSystemScale(double x, double y)
 807 {
 808     m_scaleX = x;
 809     m_scaleY = y;
 810
 811     SetMapMode(m_mappingMode);
 812 }
 813
 814 void wxDC::SetLogicalOrigin( wxCoord x, wxCoord y )
 815 {
 816     // TODO:
 817 };
 818
 819 void wxDC::SetDeviceOrigin( wxCoord x, wxCoord y )
 820 {
 821     // TODO:
 822 };
 823
 824 // ---------------------------------------------------------------------------
 825 // coordinates transformations
 826 // ---------------------------------------------------------------------------
 827
 828 wxCoord wxDCBase::DeviceToLogicalX(wxCoord x) const
 829 {
 830     return (wxCoord) (((x) - m_deviceOriginX)/(m_logicalScaleX*m_userScaleX*m_signX*m_scaleX) - m_logicalOriginX);
 831 }
 832
 833 wxCoord wxDCBase::DeviceToLogicalXRel(wxCoord x) const
 834 {
 835     return (wxCoord) ((x)/(m_logicalScaleX*m_userScaleX*m_signX*m_scaleX));
 836 }
 837
 838 wxCoord wxDCBase::DeviceToLogicalY(wxCoord y) const
 839 {
 840     return (wxCoord) (((y) - m_deviceOriginY)/(m_logicalScaleY*m_userScaleY*m_signY*m_scaleY) - m_logicalOriginY);
 841 }
 842
 843 wxCoord wxDCBase::DeviceToLogicalYRel(wxCoord y) const
 844 {
 845     return (wxCoord) ((y)/(m_logicalScaleY*m_userScaleY*m_signY*m_scaleY));
 846 }
 847
 848 wxCoord wxDCBase::LogicalToDeviceX(wxCoord x) const
 849 {
 850     return (wxCoord) ((x - m_logicalOriginX)*m_logicalScaleX*m_userScaleX*m_signX*m_scaleX + m_deviceOriginX);
 851 }
 852
 853 wxCoord wxDCBase::LogicalToDeviceXRel(wxCoord x) const
 854 {
 855     return (wxCoord) (x*m_logicalScaleX*m_userScaleX*m_signX*m_scaleX);
 856 }
 857
 858 wxCoord wxDCBase::LogicalToDeviceY(wxCoord y) const
 859 {
 860     return (wxCoord) ((y - m_logicalOriginY)*m_logicalScaleY*m_userScaleY*m_signY*m_scaleY + m_deviceOriginY);
 861 }
 862
 863 wxCoord wxDCBase::LogicalToDeviceYRel(wxCoord y) const
 864 {
 865     return (wxCoord) (y*m_logicalScaleY*m_userScaleY*m_signY*m_scaleY);
 866 }
 867
 868 // ---------------------------------------------------------------------------
 869 // bit blit
 870 // ---------------------------------------------------------------------------
 871
 872 bool wxDC::DoBlit( wxCoord xdest
 873                   ,wxCoord ydest
 874                   ,wxCoord width
 875                   ,wxCoord height
 876                   ,wxDC *source
 877                   ,wxCoord xsrc
 878                   ,wxCoord ysrc
 879                   ,int  rop
 880                   ,bool useMask
 881                  )
 882 {
 883    // TODO
 884    return(TRUE);
 885 }
 886
 887 void wxDC::DoGetSize( int* width, int* height ) const
 888 {
 889     // TODO:
 890 };
 891
 892 void wxDC::DoGetSizeMM( int* width, int* height ) const
 893 {
 894     // TODO:
 895 };
 896
 897 wxSize wxDC::GetPPI() const
 898 {
 899    int x = 1;
 900    int y = 1;
 901    // TODO:
 902    return (wxSize(x,y));
 903 }
 904
 905 void wxDC::SetLogicalScale( double x, double y )
 906 {
 907     // TODO:
 908 };
 909
 910 #if WXWIN_COMPATIBILITY
 911 void wxDC::DoGetTextExtent(const wxString& string, float *x, float *y,
 912                          float *descent, float *externalLeading,
 913                          wxFont *theFont, bool use16bit) const
 914 {
 915     wxCoord x1, y1, descent1, externalLeading1;
 916     GetTextExtent(string, & x1, & y1, & descent1, & externalLeading1, theFont, use16bit);
 917     *x = x1; *y = y1;
 918     if (descent)
 919         *descent = descent1;
 920     if (externalLeading)
 921         *externalLeading = externalLeading1;
 922 }
 923 #endif
 924
 925 // ---------------------------------------------------------------------------
 926 // spline drawing code
 927 // ---------------------------------------------------------------------------
 928
 929 #if wxUSE_SPLINES
 930
 931 class wxSpline: public wxObject
 932 {
 933 public:
 934     int type;
 935     wxList *points;
 936
 937     wxSpline(wxList *list);
 938     void DeletePoints();
 939
 940     // Doesn't delete points
 941     ~wxSpline();
 942 };
 943
 944 void wx_draw_open_spline(wxDC *dc, wxSpline *spline);
 945
 946 void wx_quadratic_spline(double a1, double b1, double a2, double b2,
 947                          double a3, double b3, double a4, double b4);
 948 void wx_clear_stack();
 949 int wx_spline_pop(double *x1, double *y1, double *x2, double *y2, double *x3,
 950                   double *y3, double *x4, double *y4);
 951 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3,
 952                     double x4, double y4);
 953 static bool wx_spline_add_point(double x, double y);
 954 static void wx_spline_draw_point_array(wxDC *dc);
 955 wxSpline *wx_make_spline(int x1, int y1, int x2, int y2, int x3, int y3);
 956
 957 void wxDC::DoDrawSpline(wxList *list)
 958 {
 959     wxSpline spline(list);
 960
 961     wx_draw_open_spline(this, &spline);
 962 }
 963
 964 wxList wx_spline_point_list;
 965
 966 void wx_draw_open_spline(wxDC *dc, wxSpline *spline)
 967 {
 968     wxPoint *p;
 969     double           cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4;
 970     double           x1, y1, x2, y2;
 971
 972     wxNode *node = spline->points->First();
 973     p = (wxPoint *)node->Data();
 974
 975     x1 = p->x;
 976     y1 = p->y;
 977
 978     node = node->Next();
 979     p = (wxPoint *)node->Data();
 980
 981     x2 = p->x;
 982     y2 = p->y;
 983     cx1 = (double)((x1 + x2) / 2);
 984     cy1 = (double)((y1 + y2) / 2);
 985     cx2 = (double)((cx1 + x2) / 2);
 986     cy2 = (double)((cy1 + y2) / 2);
 987
 988     wx_spline_add_point(x1, y1);
 989
 990     while ((node = node->Next()) != NULL)
 991     {
 992         p = (wxPoint *)node->Data();
 993         x1 = x2;
 994         y1 = y2;
 995         x2 = p->x;
 996         y2 = p->y;
 997         cx4 = (double)(x1 + x2) / 2;
 998         cy4 = (double)(y1 + y2) / 2;
 999         cx3 = (double)(x1 + cx4) / 2;
1000         cy3 = (double)(y1 + cy4) / 2;
1001
1002         wx_quadratic_spline(cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4);
1003
1004         cx1 = cx4;
1005         cy1 = cy4;
1006         cx2 = (double)(cx1 + x2) / 2;
1007         cy2 = (double)(cy1 + y2) / 2;
1008     }
1009
1010     wx_spline_add_point((double)wx_round(cx1), (double)wx_round(cy1));
1011     wx_spline_add_point(x2, y2);
1012
1013     wx_spline_draw_point_array(dc);
1014
1015 }
1016
1017 /********************* CURVES FOR SPLINES *****************************
1018
1019   The following spline drawing routine is from
1020
1021     "An Algorithm for High-Speed Curve Generation"
1022     by George Merrill Chaikin,
1023     Computer Graphics and Image Processing, 3, Academic Press,
1024     1974, 346-349.
1025
1026       and
1027
1028         "On Chaikin's Algorithm" by R. F. Riesenfeld,
1029         Computer Graphics and Image Processing, 4, Academic Press,
1030         1975, 304-310.
1031
1032 ***********************************************************************/
1033
1034 #define     half(z1, z2)    ((z1+z2)/2.0)
1035 #define     THRESHOLD   5
1036
1037 /* iterative version */
1038
1039 void wx_quadratic_spline(double a1, double b1, double a2, double b2, double a3, double b3, double a4,
1040                          double b4)
1041 {
1042     register double  xmid, ymid;
1043     double           x1, y1, x2, y2, x3, y3, x4, y4;
1044
1045     wx_clear_stack();
1046     wx_spline_push(a1, b1, a2, b2, a3, b3, a4, b4);
1047
1048     while (wx_spline_pop(&x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4)) {
1049         xmid = (double)half(x2, x3);
1050         ymid = (double)half(y2, y3);
1051         if (fabs(x1 - xmid) < THRESHOLD && fabs(y1 - ymid) < THRESHOLD &&
1052             fabs(xmid - x4) < THRESHOLD && fabs(ymid - y4) < THRESHOLD) {
1053             wx_spline_add_point((double)wx_round(x1), (double)wx_round(y1));
1054             wx_spline_add_point((double)wx_round(xmid), (double)wx_round(ymid));
1055         } else {
1056             wx_spline_push(xmid, ymid, (double)half(xmid, x3), (double)half(ymid, y3),
1057                 (double)half(x3, x4), (double)half(y3, y4), x4, y4);
1058             wx_spline_push(x1, y1, (double)half(x1, x2), (double)half(y1, y2),
1059                 (double)half(x2, xmid), (double)half(y2, ymid), xmid, ymid);
1060         }
1061     }
1062 }
1063
1064
1065 /* utilities used by spline drawing routines */
1066
1067
1068 typedef struct wx_spline_stack_struct {
1069     double           x1, y1, x2, y2, x3, y3, x4, y4;
1070 }
1071 Stack;
1072
1073 #define         SPLINE_STACK_DEPTH             20
1074 static Stack    wx_spline_stack[SPLINE_STACK_DEPTH];
1075 static Stack   *wx_stack_top;
1076 static int      wx_stack_count;
1077
1078 void wx_clear_stack()
1079 {
1080     wx_stack_top = wx_spline_stack;
1081     wx_stack_count = 0;
1082 }
1083
1084 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
1085 {
1086     wx_stack_top->x1 = x1;
1087     wx_stack_top->y1 = y1;
1088     wx_stack_top->x2 = x2;
1089     wx_stack_top->y2 = y2;
1090     wx_stack_top->x3 = x3;
1091     wx_stack_top->y3 = y3;
1092     wx_stack_top->x4 = x4;
1093     wx_stack_top->y4 = y4;
1094     wx_stack_top++;
1095     wx_stack_count++;
1096 }
1097
1098 int wx_spline_pop(double *x1, double *y1, double *x2, double *y2,
1099                   double *x3, double *y3, double *x4, double *y4)
1100 {
1101     if (wx_stack_count == 0)
1102         return (0);
1103     wx_stack_top--;
1104     wx_stack_count--;
1105     *x1 = wx_stack_top->x1;
1106     *y1 = wx_stack_top->y1;
1107     *x2 = wx_stack_top->x2;
1108     *y2 = wx_stack_top->y2;
1109     *x3 = wx_stack_top->x3;
1110     *y3 = wx_stack_top->y3;
1111     *x4 = wx_stack_top->x4;
1112     *y4 = wx_stack_top->y4;
1113     return (1);
1114 }
1115
1116 static bool wx_spline_add_point(double x, double y)
1117 {
1118     wxPoint *point = new wxPoint;
1119     point->x = (int) x;
1120     point->y = (int) y;
1121     wx_spline_point_list.Append((wxObject*)point);
1122     return TRUE;
1123 }
1124
1125 static void wx_spline_draw_point_array(wxDC *dc)
1126 {
1127     dc->DrawLines(&wx_spline_point_list, 0, 0);
1128     wxNode *node = wx_spline_point_list.First();
1129     while (node)
1130     {
1131         wxPoint *point = (wxPoint *)node->Data();
1132         delete point;
1133         delete node;
1134         node = wx_spline_point_list.First();
1135     }
1136 }
1137
1138 wxSpline::wxSpline(wxList *list)
1139 {
1140     points = list;
1141 }
1142
1143 wxSpline::~wxSpline()
1144 {
1145 }
1146
1147 void wxSpline::DeletePoints()
1148 {
1149     for(wxNode *node = points->First(); node; node = points->First())
1150     {
1151         wxPoint *point = (wxPoint *)node->Data();
1152         delete point;
1153         delete node;
1154     }
1155     delete points;
1156 }
1157
1158
1159 #endif // wxUSE_SPLINES
1160