src/common/dcbase.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        common/dcbase.cpp
   3 // Purpose:     generic methods of the wxDC Class
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     05/25/99
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) wxWidgets team
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 // For compilers that support precompilation, includes "wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifdef __BORLANDC__
  24     #pragma hdrstop
  25 #endif
  26
  27 #include "wx/dc.h"
  28 #include "wx/math.h"
  29
  30 // bool wxDCBase::sm_cacheing = false;
  31
  32 // ============================================================================
  33 // implementation
  34 // ============================================================================
  35
  36 #if WXWIN_COMPATIBILITY_2_6
  37 void wxDCBase::BeginDrawing()
  38 {
  39 }
  40
  41 void wxDCBase::EndDrawing()
  42 {
  43 }
  44 #endif // WXWIN_COMPATIBILITY_2_6
  45
  46 // ----------------------------------------------------------------------------
  47 // special symbols
  48 // ----------------------------------------------------------------------------
  49
  50 void wxDCBase::DoDrawCheckMark(wxCoord x1, wxCoord y1,
  51                                wxCoord width, wxCoord height)
  52 {
  53     wxCHECK_RET( Ok(), wxT("invalid window dc") );
  54
  55     wxCoord x2 = x1 + width,
  56             y2 = y1 + height;
  57
  58     // this is to yield width of 3 for width == height == 10
  59     SetPen(wxPen(GetTextForeground(), (width + height + 1) / 7, wxSOLID));
  60
  61     // we're drawing a scaled version of wx/generic/tick.xpm here
  62     wxCoord x3 = x1 + (4*width) / 10,   // x of the tick bottom
  63             y3 = y1 + height / 2;       // y of the left tick branch
  64     DoDrawLine(x1, y3, x3, y2);
  65     DoDrawLine(x3, y2, x2, y1);
  66
  67     CalcBoundingBox(x1, y1);
  68     CalcBoundingBox(x2, y2);
  69 }
  70
  71 // ----------------------------------------------------------------------------
  72 // line/polygons
  73 // ----------------------------------------------------------------------------
  74
  75 void wxDCBase::DrawLines(const wxList *list, wxCoord xoffset, wxCoord yoffset)
  76 {
  77     int n = list->GetCount();
  78     wxPoint *points = new wxPoint[n];
  79
  80     int i = 0;
  81     for ( wxList::compatibility_iterator node = list->GetFirst(); node; node = node->GetNext(), i++ )
  82     {
  83         wxPoint *point = (wxPoint *)node->GetData();
  84         points[i].x = point->x;
  85         points[i].y = point->y;
  86     }
  87
  88     DoDrawLines(n, points, xoffset, yoffset);
  89
  90     delete [] points;
  91 }
  92
  93
  94 void wxDCBase::DrawPolygon(const wxList *list,
  95                            wxCoord xoffset, wxCoord yoffset,
  96                            int fillStyle)
  97 {
  98     int n = list->GetCount();
  99     wxPoint *points = new wxPoint[n];
 100
 101     int i = 0;
 102     for ( wxList::compatibility_iterator node = list->GetFirst(); node; node = node->GetNext(), i++ )
 103     {
 104         wxPoint *point = (wxPoint *)node->GetData();
 105         points[i].x = point->x;
 106         points[i].y = point->y;
 107     }
 108
 109     DoDrawPolygon(n, points, xoffset, yoffset, fillStyle);
 110
 111     delete [] points;
 112 }
 113
 114 void
 115 wxDCBase::DoDrawPolyPolygon(int n,
 116                             int count[],
 117                             wxPoint points[],
 118                             wxCoord xoffset, wxCoord yoffset,
 119                             int fillStyle)
 120 {
 121     if ( n == 1 )
 122     {
 123         DoDrawPolygon(count[0], points, xoffset, yoffset, fillStyle);
 124         return;
 125     }
 126
 127     int      i, j, lastOfs;
 128     wxPoint* pts;
 129     wxPen    pen;
 130
 131     for (i = j = lastOfs = 0; i < n; i++)
 132     {
 133         lastOfs = j;
 134         j      += count[i];
 135     }
 136     pts = new wxPoint[j+n-1];
 137     for (i = 0; i < j; i++)
 138         pts[i] = points[i];
 139     for (i = 2; i <= n; i++)
 140     {
 141         lastOfs -= count[n-i];
 142         pts[j++] = pts[lastOfs];
 143     }
 144
 145     pen = GetPen();
 146     SetPen(wxPen(*wxBLACK, 0, wxTRANSPARENT));
 147     DoDrawPolygon(j, pts, xoffset, yoffset, fillStyle);
 148     SetPen(pen);
 149     for (i = j = 0; i < n; i++)
 150     {
 151         DoDrawLines(count[i], pts+j, xoffset, yoffset);
 152         j += count[i];
 153     }
 154     delete[] pts;
 155 }
 156
 157 // ----------------------------------------------------------------------------
 158 // splines
 159 // ----------------------------------------------------------------------------
 160
 161 #if wxUSE_SPLINES
 162
 163 // TODO: this API needs fixing (wxPointList, why (!const) "wxList *"?)
 164 void wxDCBase::DrawSpline(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCoord x3, wxCoord y3)
 165 {
 166     wxList point_list;
 167
 168     wxPoint *point1 = new wxPoint;
 169     point1->x = x1; point1->y = y1;
 170     point_list.Append((wxObject*)point1);
 171
 172     wxPoint *point2 = new wxPoint;
 173     point2->x = x2; point2->y = y2;
 174     point_list.Append((wxObject*)point2);
 175
 176     wxPoint *point3 = new wxPoint;
 177     point3->x = x3; point3->y = y3;
 178     point_list.Append((wxObject*)point3);
 179
 180     DrawSpline(&point_list);
 181
 182     for( wxList::compatibility_iterator node = point_list.GetFirst(); node; node = node->GetNext() )
 183     {
 184         wxPoint *p = (wxPoint *)node->GetData();
 185         delete p;
 186     }
 187 }
 188
 189 void wxDCBase::DrawSpline(int n, wxPoint points[])
 190 {
 191     wxList list;
 192     for (int i =0; i < n; i++)
 193     {
 194         list.Append((wxObject*)&points[i]);
 195     }
 196
 197     DrawSpline(&list);
 198 }
 199
 200 // ----------------------------------- spline code ----------------------------------------
 201
 202 void wx_quadratic_spline(double a1, double b1, double a2, double b2,
 203                          double a3, double b3, double a4, double b4);
 204 void wx_clear_stack();
 205 int wx_spline_pop(double *x1, double *y1, double *x2, double *y2, double *x3,
 206         double *y3, double *x4, double *y4);
 207 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3,
 208           double x4, double y4);
 209 static bool wx_spline_add_point(double x, double y);
 210 static void wx_spline_draw_point_array(wxDCBase *dc);
 211
 212 wxList wx_spline_point_list;
 213
 214 #define                half(z1, z2)        ((z1+z2)/2.0)
 215 #define                THRESHOLD        5
 216
 217 /* iterative version */
 218
 219 void wx_quadratic_spline(double a1, double b1, double a2, double b2, double a3, double b3, double a4,
 220                  double b4)
 221 {
 222     register double  xmid, ymid;
 223     double           x1, y1, x2, y2, x3, y3, x4, y4;
 224
 225     wx_clear_stack();
 226     wx_spline_push(a1, b1, a2, b2, a3, b3, a4, b4);
 227
 228     while (wx_spline_pop(&x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4)) {
 229         xmid = (double)half(x2, x3);
 230         ymid = (double)half(y2, y3);
 231         if (fabs(x1 - xmid) < THRESHOLD && fabs(y1 - ymid) < THRESHOLD &&
 232             fabs(xmid - x4) < THRESHOLD && fabs(ymid - y4) < THRESHOLD) {
 233             wx_spline_add_point( x1, y1 );
 234             wx_spline_add_point( xmid, ymid );
 235         } else {
 236             wx_spline_push(xmid, ymid, (double)half(xmid, x3), (double)half(ymid, y3),
 237                  (double)half(x3, x4), (double)half(y3, y4), x4, y4);
 238             wx_spline_push(x1, y1, (double)half(x1, x2), (double)half(y1, y2),
 239                  (double)half(x2, xmid), (double)half(y2, ymid), xmid, ymid);
 240         }
 241     }
 242 }
 243
 244 /* utilities used by spline drawing routines */
 245
 246 typedef struct wx_spline_stack_struct {
 247     double           x1, y1, x2, y2, x3, y3, x4, y4;
 248 } Stack;
 249
 250 #define         SPLINE_STACK_DEPTH             20
 251 static Stack    wx_spline_stack[SPLINE_STACK_DEPTH];
 252 static Stack   *wx_stack_top;
 253 static int      wx_stack_count;
 254
 255 void wx_clear_stack()
 256 {
 257     wx_stack_top = wx_spline_stack;
 258     wx_stack_count = 0;
 259 }
 260
 261 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
 262 {
 263     wx_stack_top->x1 = x1;
 264     wx_stack_top->y1 = y1;
 265     wx_stack_top->x2 = x2;
 266     wx_stack_top->y2 = y2;
 267     wx_stack_top->x3 = x3;
 268     wx_stack_top->y3 = y3;
 269     wx_stack_top->x4 = x4;
 270     wx_stack_top->y4 = y4;
 271     wx_stack_top++;
 272     wx_stack_count++;
 273 }
 274
 275 int wx_spline_pop(double *x1, double *y1, double *x2, double *y2,
 276                   double *x3, double *y3, double *x4, double *y4)
 277 {
 278     if (wx_stack_count == 0)
 279         return (0);
 280     wx_stack_top--;
 281     wx_stack_count--;
 282     *x1 = wx_stack_top->x1;
 283     *y1 = wx_stack_top->y1;
 284     *x2 = wx_stack_top->x2;
 285     *y2 = wx_stack_top->y2;
 286     *x3 = wx_stack_top->x3;
 287     *y3 = wx_stack_top->y3;
 288     *x4 = wx_stack_top->x4;
 289     *y4 = wx_stack_top->y4;
 290     return (1);
 291 }
 292
 293 static bool wx_spline_add_point(double x, double y)
 294 {
 295   wxPoint *point = new wxPoint ;
 296   point->x = (int) x;
 297   point->y = (int) y;
 298   wx_spline_point_list.Append((wxObject*)point);
 299   return true;
 300 }
 301
 302 static void wx_spline_draw_point_array(wxDCBase *dc)
 303 {
 304   dc->DrawLines(&wx_spline_point_list, 0, 0 );
 305   wxList::compatibility_iterator node = wx_spline_point_list.GetFirst();
 306   while (node)
 307   {
 308     wxPoint *point = (wxPoint *)node->GetData();
 309     delete point;
 310     wx_spline_point_list.Erase(node);
 311     node = wx_spline_point_list.GetFirst();
 312   }
 313 }
 314
 315 void wxDCBase::DoDrawSpline( wxList *points )
 316 {
 317     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 318
 319     wxPoint *p;
 320     double           cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4;
 321     double           x1, y1, x2, y2;
 322
 323     wxList::compatibility_iterator node = points->GetFirst();
 324     if (node == wxList::compatibility_iterator())
 325         // empty list
 326         return;
 327
 328     p = (wxPoint *)node->GetData();
 329
 330     x1 = p->x;
 331     y1 = p->y;
 332
 333     node = node->GetNext();
 334     p = (wxPoint *)node->GetData();
 335
 336     x2 = p->x;
 337     y2 = p->y;
 338     cx1 = (double)((x1 + x2) / 2);
 339     cy1 = (double)((y1 + y2) / 2);
 340     cx2 = (double)((cx1 + x2) / 2);
 341     cy2 = (double)((cy1 + y2) / 2);
 342
 343     wx_spline_add_point(x1, y1);
 344
 345     while ((node = node->GetNext())
 346 #if !wxUSE_STL
 347            != NULL
 348 #endif // !wxUSE_STL
 349           )
 350     {
 351         p = (wxPoint *)node->GetData();
 352         x1 = x2;
 353         y1 = y2;
 354         x2 = p->x;
 355         y2 = p->y;
 356         cx4 = (double)(x1 + x2) / 2;
 357         cy4 = (double)(y1 + y2) / 2;
 358         cx3 = (double)(x1 + cx4) / 2;
 359         cy3 = (double)(y1 + cy4) / 2;
 360
 361         wx_quadratic_spline(cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4);
 362
 363         cx1 = cx4;
 364         cy1 = cy4;
 365         cx2 = (double)(cx1 + x2) / 2;
 366         cy2 = (double)(cy1 + y2) / 2;
 367     }
 368
 369     wx_spline_add_point( cx1, cy1 );
 370     wx_spline_add_point( x2, y2 );
 371
 372     wx_spline_draw_point_array( this );
 373 }
 374
 375 #endif // wxUSE_SPLINES
 376
 377 // ----------------------------------------------------------------------------
 378 // Partial Text Extents
 379 // ----------------------------------------------------------------------------
 380
 381
 382 // Each element of the widths array will be the width of the string up to and
 383 // including the corresponding character in text.  This is the generic
 384 // implementation, the port-specific classes should do this with native APIs
 385 // if available and if faster.  Note: pango_layout_index_to_pos is much slower
 386 // than calling GetTextExtent!!
 387
 388 #define FWC_SIZE 256
 389
 390 class FontWidthCache
 391 {
 392 public:
 393     FontWidthCache() : m_scaleX(1), m_widths(NULL) { }
 394     ~FontWidthCache() { delete []m_widths; }
 395
 396     void Reset()
 397     {
 398         if (!m_widths)
 399             m_widths = new int[FWC_SIZE];
 400
 401         memset(m_widths, 0, sizeof(int)*FWC_SIZE);
 402     }
 403
 404     wxFont m_font;
 405     double m_scaleX;
 406     int *m_widths;
 407 };
 408
 409 static FontWidthCache s_fontWidthCache;
 410
 411 bool wxDCBase::DoGetPartialTextExtents(const wxString& text, wxArrayInt& widths) const
 412 {
 413     int totalWidth = 0;
 414
 415     const size_t len = text.Length();
 416     widths.Empty();
 417     widths.Add(0, len);
 418
 419     // reset the cache if font or horizontal scale have changed
 420     if ( !s_fontWidthCache.m_widths ||
 421          !wxIsSameDouble(s_fontWidthCache.m_scaleX, m_scaleX) ||
 422          (s_fontWidthCache.m_font != GetFont()) )
 423     {
 424         s_fontWidthCache.Reset();
 425         s_fontWidthCache.m_font = GetFont();
 426         s_fontWidthCache.m_scaleX = m_scaleX;
 427     }
 428
 429     // Calculate the position of each character based on the widths of
 430     // the previous characters
 431     int w, h;
 432     for ( size_t i = 0; i < len; i++ )
 433     {
 434         const wxChar c = text[i];
 435         unsigned int c_int = (unsigned int)c;
 436
 437         if ((c_int < FWC_SIZE) && (s_fontWidthCache.m_widths[c_int] != 0))
 438         {
 439             w = s_fontWidthCache.m_widths[c_int];
 440         }
 441         else
 442         {
 443             GetTextExtent(c, &w, &h);
 444             if (c_int < FWC_SIZE)
 445                 s_fontWidthCache.m_widths[c_int] = w;
 446         }
 447
 448         totalWidth += w;
 449         widths[i] = totalWidth;
 450     }
 451
 452     return true;
 453 }
 454
 455
 456 // ----------------------------------------------------------------------------
 457 // enhanced text drawing
 458 // ----------------------------------------------------------------------------
 459
 460 void wxDCBase::GetMultiLineTextExtent(const wxString& text,
 461                                       wxCoord *x,
 462                                       wxCoord *y,
 463                                       wxCoord *h,
 464                                       wxFont *font)
 465 {
 466     wxCoord widthTextMax = 0, widthLine,
 467             heightTextTotal = 0, heightLineDefault = 0, heightLine = 0;
 468
 469     wxString curLine;
 470     for ( const wxChar *pc = text; ; pc++ )
 471     {
 472         if ( *pc == _T('\n') || *pc == _T('\0') )
 473         {
 474             if ( curLine.empty() )
 475             {
 476                 // we can't use GetTextExtent - it will return 0 for both width
 477                 // and height and an empty line should count in height
 478                 // calculation
 479
 480                 // assume that this line has the same height as the previous
 481                 // one
 482                 if ( !heightLineDefault )
 483                     heightLineDefault = heightLine;
 484
 485                 if ( !heightLineDefault )
 486                 {
 487                     // but we don't know it yet - choose something reasonable
 488                     GetTextExtent(_T("W"), NULL, &heightLineDefault,
 489                                   NULL, NULL, font);
 490                 }
 491
 492                 heightTextTotal += heightLineDefault;
 493             }
 494             else
 495             {
 496                 GetTextExtent(curLine, &widthLine, &heightLine,
 497                               NULL, NULL, font);
 498                 if ( widthLine > widthTextMax )
 499                     widthTextMax = widthLine;
 500                 heightTextTotal += heightLine;
 501             }
 502
 503             if ( *pc == _T('\n') )
 504             {
 505                curLine.clear();
 506             }
 507             else
 508             {
 509                // the end of string
 510                break;
 511             }
 512         }
 513         else
 514         {
 515             curLine += *pc;
 516         }
 517     }
 518
 519     if ( x )
 520         *x = widthTextMax;
 521     if ( y )
 522         *y = heightTextTotal;
 523     if ( h )
 524         *h = heightLine;
 525 }
 526
 527 void wxDCBase::DrawLabel(const wxString& text,
 528                          const wxBitmap& bitmap,
 529                          const wxRect& rect,
 530                          int alignment,
 531                          int indexAccel,
 532                          wxRect *rectBounding)
 533 {
 534     // find the text position
 535     wxCoord widthText, heightText, heightLine;
 536     GetMultiLineTextExtent(text, &widthText, &heightText, &heightLine);
 537
 538     wxCoord width, height;
 539     if ( bitmap.Ok() )
 540     {
 541         width = widthText + bitmap.GetWidth();
 542         height = bitmap.GetHeight();
 543     }
 544     else // no bitmap
 545     {
 546         width = widthText;
 547         height = heightText;
 548     }
 549
 550     wxCoord x, y;
 551     if ( alignment & wxALIGN_RIGHT )
 552     {
 553         x = rect.GetRight() - width;
 554     }
 555     else if ( alignment & wxALIGN_CENTRE_HORIZONTAL )
 556     {
 557         x = (rect.GetLeft() + rect.GetRight() + 1 - width) / 2;
 558     }
 559     else // alignment & wxALIGN_LEFT
 560     {
 561         x = rect.GetLeft();
 562     }
 563
 564     if ( alignment & wxALIGN_BOTTOM )
 565     {
 566         y = rect.GetBottom() - height;
 567     }
 568     else if ( alignment & wxALIGN_CENTRE_VERTICAL )
 569     {
 570         y = (rect.GetTop() + rect.GetBottom() + 1 - height) / 2;
 571     }
 572     else // alignment & wxALIGN_TOP
 573     {
 574         y = rect.GetTop();
 575     }
 576
 577     // draw the bitmap first
 578     wxCoord x0 = x,
 579             y0 = y,
 580             width0 = width;
 581     if ( bitmap.Ok() )
 582     {
 583         DrawBitmap(bitmap, x, y, true /* use mask */);
 584
 585         wxCoord offset = bitmap.GetWidth() + 4;
 586         x += offset;
 587         width -= offset;
 588
 589         y += (height - heightText) / 2;
 590     }
 591
 592     // we will draw the underscore under the accel char later
 593     wxCoord startUnderscore = 0,
 594             endUnderscore = 0,
 595             yUnderscore = 0;
 596
 597     // split the string into lines and draw each of them separately
 598     wxString curLine;
 599     for ( const wxChar *pc = text; ; pc++ )
 600     {
 601         if ( *pc == _T('\n') || *pc == _T('\0') )
 602         {
 603             int xRealStart = x; // init it here to avoid compielr warnings
 604
 605             if ( !curLine.empty() )
 606             {
 607                 // NB: can't test for !(alignment & wxALIGN_LEFT) because
 608                 //     wxALIGN_LEFT is 0
 609                 if ( alignment & (wxALIGN_RIGHT | wxALIGN_CENTRE_HORIZONTAL) )
 610                 {
 611                     wxCoord widthLine;
 612                     GetTextExtent(curLine, &widthLine, NULL);
 613
 614                     if ( alignment & wxALIGN_RIGHT )
 615                     {
 616                         xRealStart += width - widthLine;
 617                     }
 618                     else // if ( alignment & wxALIGN_CENTRE_HORIZONTAL )
 619                     {
 620                         xRealStart += (width - widthLine) / 2;
 621                     }
 622                 }
 623                 //else: left aligned, nothing to do
 624
 625                 DrawText(curLine, xRealStart, y);
 626             }
 627
 628             y += heightLine;
 629
 630             // do we have underscore in this line? we can check yUnderscore
 631             // because it is set below to just y + heightLine if we do
 632             if ( y == yUnderscore )
 633             {
 634                 // adjust the horz positions to account for the shift
 635                 startUnderscore += xRealStart;
 636                 endUnderscore += xRealStart;
 637             }
 638
 639             if ( *pc == _T('\0') )
 640                 break;
 641
 642             curLine.clear();
 643         }
 644         else // not end of line
 645         {
 646             if ( pc - text.c_str() == indexAccel )
 647             {
 648                 // remeber to draw underscore here
 649                 GetTextExtent(curLine, &startUnderscore, NULL);
 650                 curLine += *pc;
 651                 GetTextExtent(curLine, &endUnderscore, NULL);
 652
 653                 yUnderscore = y + heightLine;
 654             }
 655             else
 656             {
 657                 curLine += *pc;
 658             }
 659         }
 660     }
 661
 662     // draw the underscore if found
 663     if ( startUnderscore != endUnderscore )
 664     {
 665         // it should be of the same colour as text
 666         SetPen(wxPen(GetTextForeground(), 0, wxSOLID));
 667
 668         yUnderscore--;
 669
 670         DrawLine(startUnderscore, yUnderscore, endUnderscore, yUnderscore);
 671     }
 672
 673     // return bounding rect if requested
 674     if ( rectBounding )
 675     {
 676         *rectBounding = wxRect(x, y - heightText, widthText, heightText);
 677     }
 678
 679     CalcBoundingBox(x0, y0);
 680     CalcBoundingBox(x0 + width0, y0 + height);
 681 }
 682
 683
 684 void wxDCBase::DoGradientFillLinear(const wxRect& rect,
 685                                     const wxColour& initialColour,
 686                                     const wxColour& destColour,
 687                                     wxDirection nDirection)
 688 {
 689     // save old pen
 690     wxPen oldPen = m_pen;
 691
 692     wxUint8 nR1 = destColour.Red();
 693     wxUint8 nG1 = destColour.Green();
 694     wxUint8 nB1 = destColour.Blue();
 695     wxUint8 nR2 = initialColour.Red();
 696     wxUint8 nG2 = initialColour.Green();
 697     wxUint8 nB2 = initialColour.Blue();
 698     wxUint8 nR, nG, nB;
 699
 700     if ( nDirection == wxEAST || nDirection == wxWEST )
 701     {
 702         wxInt32 x = rect.GetWidth();
 703         wxInt32 w = x;              // width of area to shade
 704         wxInt32 xDelta = w/256;     // height of one shade bend
 705         if (xDelta < 1)
 706             xDelta = 1;
 707
 708         while (x >= xDelta)
 709         {
 710             x -= xDelta;
 711             if (nR1 > nR2)
 712                 nR = nR1 - (nR1-nR2)*(w-x)/w;
 713             else
 714                 nR = nR1 + (nR2-nR1)*(w-x)/w;
 715
 716             if (nG1 > nG2)
 717                 nG = nG1 - (nG1-nG2)*(w-x)/w;
 718             else
 719                 nG = nG1 + (nG2-nG1)*(w-x)/w;
 720
 721             if (nB1 > nB2)
 722                 nB = nB1 - (nB1-nB2)*(w-x)/w;
 723             else
 724                 nB = nB1 + (nB2-nB1)*(w-x)/w;
 725
 726             SetPen(wxPen(wxColour(nR, nG, nB), 1, wxSOLID));
 727             if(nDirection == wxEAST)
 728                 DrawRectangle(rect.GetLeft()+x, rect.GetTop(),
 729                         xDelta, rect.GetHeight());
 730             else //nDirection == wxWEST
 731                 DrawRectangle(rect.GetRight()-x-xDelta, rect.GetTop(),
 732                         xDelta, rect.GetHeight());
 733         }
 734     }
 735     else  // nDirection == wxNORTH || nDirection == wxSOUTH
 736     {
 737         wxInt32 y = rect.GetHeight();
 738         wxInt32 w = y;              // height of area to shade
 739         wxInt32 yDelta = w/255;     // height of one shade bend
 740         if (yDelta < 1)
 741             yDelta = 1;
 742
 743         while (y > 0)
 744         {
 745             y -= yDelta;
 746             if (nR1 > nR2)
 747                 nR = nR1 - (nR1-nR2)*(w-y)/w;
 748             else
 749                 nR = nR1 + (nR2-nR1)*(w-y)/w;
 750
 751             if (nG1 > nG2)
 752                 nG = nG1 - (nG1-nG2)*(w-y)/w;
 753             else
 754                 nG = nG1 + (nG2-nG1)*(w-y)/w;
 755
 756             if (nB1 > nB2)
 757                 nB = nB1 - (nB1-nB2)*(w-y)/w;
 758             else
 759                 nB = nB1 + (nB2-nB1)*(w-y)/w;
 760
 761             SetPen(wxPen(wxColour(nR, nG, nB), 1, wxSOLID));
 762             if(nDirection == wxNORTH)
 763                 DrawRectangle(rect.GetLeft(), rect.GetTop()+y,
 764                         rect.GetWidth(), yDelta);
 765             else //nDirection == wxSOUTH
 766                 DrawRectangle(rect.GetLeft(), rect.GetBottom()-y-yDelta,
 767                         rect.GetWidth(), yDelta);
 768         }
 769     }
 770
 771     SetPen(oldPen);
 772 }
 773
 774 void wxDCBase::GradientFillConcentric(const wxRect& rect,
 775                                       const wxColour& initialColour,
 776                                       const wxColour& destColour,
 777                                       const wxPoint& circleCenter)
 778 {
 779     //save the old pen color
 780     wxColour oldPenColour = m_pen.GetColour();
 781
 782     wxUint8 nR1 = destColour.Red();
 783     wxUint8 nG1 = destColour.Green();
 784     wxUint8 nB1 = destColour.Blue();
 785     wxUint8 nR2 = initialColour.Red();
 786     wxUint8 nG2 = initialColour.Green();
 787     wxUint8 nB2 = initialColour.Blue();
 788     wxUint8 nR, nG, nB;
 789
 790
 791     //Radius
 792     wxInt32 cx = rect.GetWidth() / 2;
 793     wxInt32 cy = rect.GetHeight() / 2;
 794     wxInt32 nRadius;
 795     if (cx < cy)
 796         nRadius = cx;
 797     else
 798         nRadius = cy;
 799
 800     //Offset of circle
 801     wxInt32 nCircleOffX = circleCenter.x - (rect.GetWidth() / 2);
 802     wxInt32 nCircleOffY = circleCenter.y - (rect.GetHeight() / 2);
 803
 804     for ( wxInt32 x = 0; x < rect.GetWidth(); x++ )
 805     {
 806         for ( wxInt32 y = 0; y < rect.GetHeight(); y++ )
 807         {
 808             //get color difference
 809             wxInt32 nGradient = ((nRadius -
 810                                   (wxInt32)sqrt(
 811                                     pow((double)(x - cx - nCircleOffX), 2) +
 812                                     pow((double)(y - cy - nCircleOffY), 2)
 813                                   )) * 100) / nRadius;
 814
 815             //normalize Gradient
 816             if (nGradient < 0 )
 817                 nGradient = 0;
 818
 819             //get dest colors
 820             nR = nR1 + ((nR2 - nR1) * nGradient / 100);
 821             nG = nG1 + ((nG2 - nG1) * nGradient / 100);
 822             nB = nB1 + ((nB2 - nB1) * nGradient / 100);
 823
 824             //set the pixel
 825             m_pen.SetColour(wxColour(nR,nG,nB));
 826             DrawPoint(wxPoint(x + rect.GetLeft(), y + rect.GetTop()));
 827         }
 828     }
 829     //return old pen color
 830     m_pen.SetColour(oldPenColour);
 831 }
 832
 833 /*
 834 Notes for wxWidgets DrawEllipticArcRot(...)
 835
 836 wxDCBase::DrawEllipticArcRot(...) draws a rotated elliptic arc or an ellipse.
 837 It uses wxDCBase::CalculateEllipticPoints(...) and wxDCBase::Rotate(...),
 838 which are also new.
 839
 840 All methods are generic, so they can be implemented in wxDCBase.
 841 DoDrawEllipticArcRot(...) is virtual, so it can be called from deeper
 842 methods like (WinCE) wxDC::DoDrawArc(...).
 843
 844 CalculateEllipticPoints(...) fills a given list of wxPoints with some points
 845 of an elliptic arc. The algorithm is pixel-based: In every row (in flat
 846 parts) or every column (in steep parts) only one pixel is calculated.
 847 Trigonometric calculation (sin, cos, tan, atan) is only done if the
 848 starting angle is not equal to the ending angle. The calculation of the
 849 pixels is done using simple arithmetic only and should perform not too
 850 bad even on devices without floating point processor. I didn't test this yet.
 851
 852 Rotate(...) rotates a list of point pixel-based, you will see rounding errors.
 853 For instance: an ellipse rotated 180 degrees is drawn
 854 slightly different from the original.
 855
 856 The points are then moved to an array and used to draw a polyline and/or polygon
 857 (with center added, the pie).
 858 The result looks quite similar to the native ellipse, only e few pixels differ.
 859
 860 The performance on a desktop system (Athlon 1800, WinXP) is about 7 times
 861 slower as DrawEllipse(...), which calls the native API.
 862 An rotated ellipse outside the clipping region takes nearly the same time,
 863 while an native ellipse outside takes nearly no time to draw.
 864
 865 If you draw an arc with this new method, you will see the starting and ending angles
 866 are calculated properly.
 867 If you use DrawEllipticArc(...), you will see they are only correct for circles
 868 and not properly calculated for ellipses.
 869
 870 Peter Lenhard
 871 p.lenhard@t-online.de
 872 */
 873
 874 #ifdef __WXWINCE__
 875 void wxDCBase::DoDrawEllipticArcRot( wxCoord x, wxCoord y,
 876                                      wxCoord w, wxCoord h,
 877                                      double sa, double ea, double angle )
 878 {
 879     wxList list;
 880
 881     CalculateEllipticPoints( &list, x, y, w, h, sa, ea );
 882     Rotate( &list, angle, wxPoint( x+w/2, y+h/2 ) );
 883
 884     // Add center (for polygon/pie)
 885     list.Append( (wxObject*) new wxPoint( x+w/2, y+h/2 ) );
 886
 887     // copy list into array and delete list elements
 888     int n = list.Number();
 889     wxPoint *points = new wxPoint[n];
 890     int i = 0;
 891     wxNode* node = 0;
 892     for ( node = list.First(); node; node = node->Next(), i++ )
 893     {
 894         wxPoint *point = (wxPoint *)node->Data();
 895         points[i].x = point->x;
 896         points[i].y = point->y;
 897         delete point;
 898     }
 899
 900     // first draw the pie without pen, if necessary
 901     if( GetBrush() != *wxTRANSPARENT_BRUSH )
 902     {
 903         wxPen tempPen( GetPen() );
 904         SetPen( *wxTRANSPARENT_PEN );
 905         DoDrawPolygon( n, points, 0, 0 );
 906         SetPen( tempPen );
 907     }
 908
 909     // then draw the arc without brush, if necessary
 910     if( GetPen() != *wxTRANSPARENT_PEN )
 911     {
 912         // without center
 913         DoDrawLines( n-1, points, 0, 0 );
 914     }
 915
 916     delete [] points;
 917
 918 } // DrawEllipticArcRot
 919
 920 void wxDCBase::Rotate( wxList* points, double angle, wxPoint center )
 921 {
 922     if( angle != 0.0 )
 923     {
 924         double pi(M_PI);
 925         double dSinA = -sin(angle*2.0*pi/360.0);
 926         double dCosA = cos(angle*2.0*pi/360.0);
 927         for ( wxNode* node = points->First(); node; node = node->Next() )
 928         {
 929             wxPoint* point = (wxPoint*)node->Data();
 930
 931             // transform coordinates, if necessary
 932             if( center.x ) point->x -= center.x;
 933             if( center.y ) point->y -= center.y;
 934
 935             // calculate rotation, rounding simply by implicit cast to integer
 936             int xTemp = point->x * dCosA - point->y * dSinA;
 937             point->y = point->x * dSinA + point->y * dCosA;
 938             point->x = xTemp;
 939
 940             // back transform coordinates, if necessary
 941             if( center.x ) point->x += center.x;
 942             if( center.y ) point->y += center.y;
 943         }
 944     }
 945 }
 946
 947 void wxDCBase::CalculateEllipticPoints( wxList* points,
 948                                         wxCoord xStart, wxCoord yStart,
 949                                         wxCoord w, wxCoord h,
 950                                         double sa, double ea )
 951 {
 952     double pi = M_PI;
 953     double sar = 0;
 954     double ear = 0;
 955     int xsa = 0;
 956     int ysa = 0;
 957     int xea = 0;
 958     int yea = 0;
 959     int sq = 0;
 960     int eq = 0;
 961     bool bUseAngles = false;
 962     if( w<0 ) w = -w;
 963     if( h<0 ) h = -h;
 964     // half-axes
 965     wxCoord a = w/2;
 966     wxCoord b = h/2;
 967     // decrement 1 pixel if ellipse is smaller than 2*a, 2*b
 968     int decrX = 0;
 969     if( 2*a == w ) decrX = 1;
 970     int decrY = 0;
 971     if( 2*b == h ) decrY = 1;
 972     // center
 973     wxCoord xCenter = xStart + a;
 974     wxCoord yCenter = yStart + b;
 975     // calculate data for start and end, if necessary
 976     if( sa != ea )
 977     {
 978         bUseAngles = true;
 979         // normalisation of angles
 980         while( sa<0 ) sa += 360;
 981         while( ea<0 ) ea += 360;
 982         while( sa>=360 ) sa -= 360;
 983         while( ea>=360 ) ea -= 360;
 984         // calculate quadrant numbers
 985         if( sa > 270 ) sq = 3;
 986         else if( sa > 180 ) sq = 2;
 987         else if( sa > 90 ) sq = 1;
 988         if( ea > 270 ) eq = 3;
 989         else if( ea > 180 ) eq = 2;
 990         else if( ea > 90 ) eq = 1;
 991         sar = sa * pi / 180.0;
 992         ear = ea * pi / 180.0;
 993         // correct angle circle -> ellipse
 994         sar = atan( -a/(double)b * tan( sar ) );
 995         if ( sq == 1 || sq == 2 ) sar += pi;
 996         ear = atan( -a/(double)b * tan( ear ) );
 997         if ( eq == 1 || eq == 2 ) ear += pi;
 998         // coordinates of points
 999         xsa = xCenter + a * cos( sar );
1000         if( sq == 0 || sq == 3 ) xsa -= decrX;
1001         ysa = yCenter + b * sin( sar );
1002         if( sq == 2 || sq == 3 ) ysa -= decrY;
1003         xea = xCenter + a * cos( ear );
1004         if( eq == 0 || eq == 3 ) xea -= decrX;
1005         yea = yCenter + b * sin( ear );
1006         if( eq == 2 || eq == 3 ) yea -= decrY;
1007     } // if iUseAngles
1008     // calculate c1 = b^2, c2 = b^2/a^2 with a = w/2, b = h/2
1009     double c1 = b * b;
1010     double c2 = 2.0 / w;
1011     c2 *= c2;
1012     c2 *= c1;
1013     wxCoord x = 0;
1014     wxCoord y = b;
1015     long x2 = 1;
1016     long y2 = y*y;
1017     long y2_old = 0;
1018     long y_old = 0;
1019     // Lists for quadrant 1 to 4
1020     wxList pointsarray[4];
1021     // Calculate points for first quadrant and set in all quadrants
1022     for( x = 0; x <= a; ++x )
1023     {
1024         x2 = x2+x+x-1;
1025         y2_old = y2;
1026         y_old = y;
1027         bool bNewPoint = false;
1028         while( y2 > c1 - c2 * x2 && y > 0 )
1029         {
1030             bNewPoint = true;
1031             y2 = y2-y-y+1;
1032             --y;
1033         }
1034         // old y now to big: set point with old y, old x
1035         if( bNewPoint && x>1)
1036         {
1037             int x1 = x - 1;
1038             // remove points on the same line
1039             pointsarray[0].Insert( (wxObject*) new wxPoint( xCenter + x1 - decrX, yCenter - y_old ) );
1040             pointsarray[1].Append( (wxObject*) new wxPoint( xCenter - x1, yCenter - y_old ) );
1041             pointsarray[2].Insert( (wxObject*) new wxPoint( xCenter - x1, yCenter + y_old - decrY ) );
1042             pointsarray[3].Append( (wxObject*) new wxPoint( xCenter + x1 - decrX, yCenter + y_old - decrY ) );
1043         } // set point
1044     } // calculate point
1045
1046     // Starting and/or ending points for the quadrants, first quadrant gets both.
1047     pointsarray[0].Insert( (wxObject*) new wxPoint( xCenter + a - decrX, yCenter ) );
1048     pointsarray[0].Append( (wxObject*) new wxPoint( xCenter, yCenter - b ) );
1049     pointsarray[1].Append( (wxObject*) new wxPoint( xCenter - a, yCenter ) );
1050     pointsarray[2].Append( (wxObject*) new wxPoint( xCenter, yCenter + b - decrY ) );
1051     pointsarray[3].Append( (wxObject*) new wxPoint( xCenter + a - decrX, yCenter ) );
1052
1053     // copy quadrants in original list
1054     if( bUseAngles )
1055     {
1056         // Copy the right part of the points in the lists
1057         // and delete the wxPoints, because they do not leave this method.
1058         points->Append( (wxObject*) new wxPoint( xsa, ysa ) );
1059         int q = sq;
1060         bool bStarted = false;
1061         bool bReady = false;
1062         bool bForceTurn = ( sq == eq && sa > ea );
1063         while( !bReady )
1064         {
1065             for( wxNode *node = pointsarray[q].First(); node; node = node->Next() )
1066             {
1067                 // once: go to starting point in start quadrant
1068                 if( !bStarted &&
1069                     (
1070                       ( (wxPoint*) node->Data() )->x < xsa+1 && q <= 1
1071                       ||
1072                       ( (wxPoint*) node->Data() )->x > xsa-1 && q >= 2
1073                     )
1074                   )
1075                 {
1076                     bStarted = true;
1077                 }
1078
1079                 // copy point, if not at ending point
1080                 if( bStarted )
1081                 {
1082                     if( q != eq || bForceTurn
1083                         ||
1084                         ( (wxPoint*) node->Data() )->x > xea+1 && q <= 1
1085                         ||
1086                         ( (wxPoint*) node->Data() )->x < xea-1 && q >= 2
1087                       )
1088                     {
1089                         // copy point
1090                         wxPoint* pPoint = new wxPoint( *((wxPoint*) node->Data() ) );
1091                         points->Append( (wxObject*) pPoint );
1092                     }
1093                     else if( q == eq && !bForceTurn || ( (wxPoint*) node->Data() )->x == xea)
1094                     {
1095                         bReady = true;
1096                     }
1097                 }
1098             } // for node
1099             ++q;
1100             if( q > 3 ) q = 0;
1101             bForceTurn = false;
1102             bStarted = true;
1103         } // while not bReady
1104         points->Append( (wxObject*) new wxPoint( xea, yea ) );
1105
1106         // delete points
1107         for( q = 0; q < 4; ++q )
1108         {
1109             for( wxNode *node = pointsarray[q].First(); node; node = node->Next() )
1110             {
1111                 wxPoint *p = (wxPoint *)node->Data();
1112                 delete p;
1113             }
1114         }
1115     }
1116     else
1117     {
1118         // copy whole ellipse, wxPoints will be deleted outside
1119         for( wxNode *node = pointsarray[0].First(); node; node = node->Next() )
1120         {
1121             wxObject *p = node->Data();
1122             points->Append( p );
1123         }
1124         for( node = pointsarray[1].First(); node; node = node->Next() )
1125         {
1126             wxObject *p = node->Data();
1127             points->Append( p );
1128         }
1129         for( node = pointsarray[2].First(); node; node = node->Next() )
1130         {
1131             wxObject *p = node->Data();
1132             points->Append( p );
1133         }
1134         for( node = pointsarray[3].First(); node; node = node->Next() )
1135         {
1136             wxObject *p = node->Data();
1137             points->Append( p );
1138         }
1139     } // not iUseAngles
1140 } // CalculateEllipticPoints
1141
1142 #endif
1143