src/common/dcbase.cpp

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