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     wxBrush oldBrush = m_brush;
 702
 703     wxUint8 nR1 = initialColour.Red();
 704     wxUint8 nG1 = initialColour.Green();
 705     wxUint8 nB1 = initialColour.Blue();
 706     wxUint8 nR2 = destColour.Red();
 707     wxUint8 nG2 = destColour.Green();
 708     wxUint8 nB2 = destColour.Blue();
 709     wxUint8 nR, nG, nB;
 710
 711     if ( nDirection == wxEAST || nDirection == wxWEST )
 712     {
 713         wxInt32 x = rect.GetWidth();
 714         wxInt32 w = x;              // width of area to shade
 715         wxInt32 xDelta = w/256;     // height of one shade bend
 716         if (xDelta < 1)
 717             xDelta = 1;
 718
 719         while (x >= xDelta)
 720         {
 721             x -= xDelta;
 722             if (nR1 > nR2)
 723                 nR = nR1 - (nR1-nR2)*(w-x)/w;
 724             else
 725                 nR = nR1 + (nR2-nR1)*(w-x)/w;
 726
 727             if (nG1 > nG2)
 728                 nG = nG1 - (nG1-nG2)*(w-x)/w;
 729             else
 730                 nG = nG1 + (nG2-nG1)*(w-x)/w;
 731
 732             if (nB1 > nB2)
 733                 nB = nB1 - (nB1-nB2)*(w-x)/w;
 734             else
 735                 nB = nB1 + (nB2-nB1)*(w-x)/w;
 736
 737             wxColour colour(nR,nG,nB);
 738             SetPen(wxPen(colour, 1, wxSOLID));
 739             SetBrush(wxBrush(colour));
 740             if(nDirection == wxEAST)
 741                 DrawRectangle(rect.GetRight()-x-xDelta, rect.GetTop(),
 742                         xDelta, rect.GetHeight());
 743             else //nDirection == wxWEST
 744                 DrawRectangle(rect.GetLeft()+x, rect.GetTop(),
 745                         xDelta, rect.GetHeight());
 746         }
 747     }
 748     else  // nDirection == wxNORTH || nDirection == wxSOUTH
 749     {
 750         wxInt32 y = rect.GetHeight();
 751         wxInt32 w = y;              // height of area to shade
 752         wxInt32 yDelta = w/255;     // height of one shade bend
 753         if (yDelta < 1)
 754             yDelta = 1;
 755
 756         while (y > 0)
 757         {
 758             y -= yDelta;
 759             if (nR1 > nR2)
 760                 nR = nR1 - (nR1-nR2)*(w-y)/w;
 761             else
 762                 nR = nR1 + (nR2-nR1)*(w-y)/w;
 763
 764             if (nG1 > nG2)
 765                 nG = nG1 - (nG1-nG2)*(w-y)/w;
 766             else
 767                 nG = nG1 + (nG2-nG1)*(w-y)/w;
 768
 769             if (nB1 > nB2)
 770                 nB = nB1 - (nB1-nB2)*(w-y)/w;
 771             else
 772                 nB = nB1 + (nB2-nB1)*(w-y)/w;
 773
 774             wxColour colour(nR,nG,nB);
 775             SetPen(wxPen(colour, 1, wxSOLID));
 776             SetBrush(wxBrush(colour));
 777             if(nDirection == wxNORTH)
 778                 DrawRectangle(rect.GetLeft(), rect.GetTop()+y,
 779                         rect.GetWidth(), yDelta);
 780             else //nDirection == wxSOUTH
 781                 DrawRectangle(rect.GetLeft(), rect.GetBottom()-y-yDelta,
 782                         rect.GetWidth(), yDelta);
 783         }
 784     }
 785
 786     SetPen(oldPen);
 787     SetBrush(oldBrush);
 788 }
 789
 790 void wxDCBase::DoGradientFillConcentric(const wxRect& rect,
 791                                       const wxColour& initialColour,
 792                                       const wxColour& destColour,
 793                                       const wxPoint& circleCenter)
 794 {
 795     //save the old pen color
 796     wxColour oldPenColour = m_pen.GetColour();
 797
 798     wxUint8 nR1 = destColour.Red();
 799     wxUint8 nG1 = destColour.Green();
 800     wxUint8 nB1 = destColour.Blue();
 801     wxUint8 nR2 = initialColour.Red();
 802     wxUint8 nG2 = initialColour.Green();
 803     wxUint8 nB2 = initialColour.Blue();
 804     wxUint8 nR, nG, nB;
 805
 806
 807     //Radius
 808     wxInt32 cx = rect.GetWidth() / 2;
 809     wxInt32 cy = rect.GetHeight() / 2;
 810     wxInt32 nRadius;
 811     if (cx < cy)
 812         nRadius = cx;
 813     else
 814         nRadius = cy;
 815
 816     //Offset of circle
 817     wxInt32 nCircleOffX = circleCenter.x - (rect.GetWidth() / 2);
 818     wxInt32 nCircleOffY = circleCenter.y - (rect.GetHeight() / 2);
 819
 820     for ( wxInt32 x = 0; x < rect.GetWidth(); x++ )
 821     {
 822         for ( wxInt32 y = 0; y < rect.GetHeight(); y++ )
 823         {
 824             //get color difference
 825             wxInt32 nGradient = ((nRadius -
 826                                   (wxInt32)sqrt(
 827                                     pow((double)(x - cx - nCircleOffX), 2) +
 828                                     pow((double)(y - cy - nCircleOffY), 2)
 829                                   )) * 100) / nRadius;
 830
 831             //normalize Gradient
 832             if (nGradient < 0 )
 833                 nGradient = 0;
 834
 835             //get dest colors
 836             nR = (wxUint8)(nR1 + ((nR2 - nR1) * nGradient / 100));
 837             nG = (wxUint8)(nG1 + ((nG2 - nG1) * nGradient / 100));
 838             nB = (wxUint8)(nB1 + ((nB2 - nB1) * nGradient / 100));
 839
 840             //set the pixel
 841             m_pen.SetColour(wxColour(nR,nG,nB));
 842             DrawPoint(wxPoint(x + rect.GetLeft(), y + rect.GetTop()));
 843         }
 844     }
 845     //return old pen color
 846     m_pen.SetColour(oldPenColour);
 847 }
 848
 849 /*
 850 Notes for wxWidgets DrawEllipticArcRot(...)
 851
 852 wxDCBase::DrawEllipticArcRot(...) draws a rotated elliptic arc or an ellipse.
 853 It uses wxDCBase::CalculateEllipticPoints(...) and wxDCBase::Rotate(...),
 854 which are also new.
 855
 856 All methods are generic, so they can be implemented in wxDCBase.
 857 DoDrawEllipticArcRot(...) is virtual, so it can be called from deeper
 858 methods like (WinCE) wxDC::DoDrawArc(...).
 859
 860 CalculateEllipticPoints(...) fills a given list of wxPoints with some points
 861 of an elliptic arc. The algorithm is pixel-based: In every row (in flat
 862 parts) or every column (in steep parts) only one pixel is calculated.
 863 Trigonometric calculation (sin, cos, tan, atan) is only done if the
 864 starting angle is not equal to the ending angle. The calculation of the
 865 pixels is done using simple arithmetic only and should perform not too
 866 bad even on devices without floating point processor. I didn't test this yet.
 867
 868 Rotate(...) rotates a list of point pixel-based, you will see rounding errors.
 869 For instance: an ellipse rotated 180 degrees is drawn
 870 slightly different from the original.
 871
 872 The points are then moved to an array and used to draw a polyline and/or polygon
 873 (with center added, the pie).
 874 The result looks quite similar to the native ellipse, only e few pixels differ.
 875
 876 The performance on a desktop system (Athlon 1800, WinXP) is about 7 times
 877 slower as DrawEllipse(...), which calls the native API.
 878 An rotated ellipse outside the clipping region takes nearly the same time,
 879 while an native ellipse outside takes nearly no time to draw.
 880
 881 If you draw an arc with this new method, you will see the starting and ending angles
 882 are calculated properly.
 883 If you use DrawEllipticArc(...), you will see they are only correct for circles
 884 and not properly calculated for ellipses.
 885
 886 Peter Lenhard
 887 p.lenhard@t-online.de
 888 */
 889
 890 #ifdef __WXWINCE__
 891 void wxDCBase::DoDrawEllipticArcRot( wxCoord x, wxCoord y,
 892                                      wxCoord w, wxCoord h,
 893                                      double sa, double ea, double angle )
 894 {
 895     wxList list;
 896
 897     CalculateEllipticPoints( &list, x, y, w, h, sa, ea );
 898     Rotate( &list, angle, wxPoint( x+w/2, y+h/2 ) );
 899
 900     // Add center (for polygon/pie)
 901     list.Append( (wxObject*) new wxPoint( x+w/2, y+h/2 ) );
 902
 903     // copy list into array and delete list elements
 904     int n = list.GetCount();
 905     wxPoint *points = new wxPoint[n];
 906     int i = 0;
 907     wxNode* node = 0;
 908     for ( node = list.GetFirst(); node; node = node->GetNext(), i++ )
 909     {
 910         wxPoint *point = (wxPoint *)node->GetData();
 911         points[i].x = point->x;
 912         points[i].y = point->y;
 913         delete point;
 914     }
 915
 916     // first draw the pie without pen, if necessary
 917     if( GetBrush() != *wxTRANSPARENT_BRUSH )
 918     {
 919         wxPen tempPen( GetPen() );
 920         SetPen( *wxTRANSPARENT_PEN );
 921         DoDrawPolygon( n, points, 0, 0 );
 922         SetPen( tempPen );
 923     }
 924
 925     // then draw the arc without brush, if necessary
 926     if( GetPen() != *wxTRANSPARENT_PEN )
 927     {
 928         // without center
 929         DoDrawLines( n-1, points, 0, 0 );
 930     }
 931
 932     delete [] points;
 933
 934 } // DrawEllipticArcRot
 935
 936 void wxDCBase::Rotate( wxList* points, double angle, wxPoint center )
 937 {
 938     if( angle != 0.0 )
 939     {
 940         double pi(M_PI);
 941         double dSinA = -sin(angle*2.0*pi/360.0);
 942         double dCosA = cos(angle*2.0*pi/360.0);
 943         for ( wxNode* node = points->GetFirst(); node; node = node->GetNext() )
 944         {
 945             wxPoint* point = (wxPoint*)node->GetData();
 946
 947             // transform coordinates, if necessary
 948             if( center.x ) point->x -= center.x;
 949             if( center.y ) point->y -= center.y;
 950
 951             // calculate rotation, rounding simply by implicit cast to integer
 952             int xTemp = point->x * dCosA - point->y * dSinA;
 953             point->y = point->x * dSinA + point->y * dCosA;
 954             point->x = xTemp;
 955
 956             // back transform coordinates, if necessary
 957             if( center.x ) point->x += center.x;
 958             if( center.y ) point->y += center.y;
 959         }
 960     }
 961 }
 962
 963 void wxDCBase::CalculateEllipticPoints( wxList* points,
 964                                         wxCoord xStart, wxCoord yStart,
 965                                         wxCoord w, wxCoord h,
 966                                         double sa, double ea )
 967 {
 968     double pi = M_PI;
 969     double sar = 0;
 970     double ear = 0;
 971     int xsa = 0;
 972     int ysa = 0;
 973     int xea = 0;
 974     int yea = 0;
 975     int sq = 0;
 976     int eq = 0;
 977     bool bUseAngles = false;
 978     if( w<0 ) w = -w;
 979     if( h<0 ) h = -h;
 980     // half-axes
 981     wxCoord a = w/2;
 982     wxCoord b = h/2;
 983     // decrement 1 pixel if ellipse is smaller than 2*a, 2*b
 984     int decrX = 0;
 985     if( 2*a == w ) decrX = 1;
 986     int decrY = 0;
 987     if( 2*b == h ) decrY = 1;
 988     // center
 989     wxCoord xCenter = xStart + a;
 990     wxCoord yCenter = yStart + b;
 991     // calculate data for start and end, if necessary
 992     if( sa != ea )
 993     {
 994         bUseAngles = true;
 995         // normalisation of angles
 996         while( sa<0 ) sa += 360;
 997         while( ea<0 ) ea += 360;
 998         while( sa>=360 ) sa -= 360;
 999         while( ea>=360 ) ea -= 360;
1000         // calculate quadrant numbers
1001         if( sa > 270 ) sq = 3;
1002         else if( sa > 180 ) sq = 2;
1003         else if( sa > 90 ) sq = 1;
1004         if( ea > 270 ) eq = 3;
1005         else if( ea > 180 ) eq = 2;
1006         else if( ea > 90 ) eq = 1;
1007         sar = sa * pi / 180.0;
1008         ear = ea * pi / 180.0;
1009         // correct angle circle -> ellipse
1010         sar = atan( -a/(double)b * tan( sar ) );
1011         if ( sq == 1 || sq == 2 ) sar += pi;
1012         ear = atan( -a/(double)b * tan( ear ) );
1013         if ( eq == 1 || eq == 2 ) ear += pi;
1014         // coordinates of points
1015         xsa = xCenter + a * cos( sar );
1016         if( sq == 0 || sq == 3 ) xsa -= decrX;
1017         ysa = yCenter + b * sin( sar );
1018         if( sq == 2 || sq == 3 ) ysa -= decrY;
1019         xea = xCenter + a * cos( ear );
1020         if( eq == 0 || eq == 3 ) xea -= decrX;
1021         yea = yCenter + b * sin( ear );
1022         if( eq == 2 || eq == 3 ) yea -= decrY;
1023     } // if iUseAngles
1024     // calculate c1 = b^2, c2 = b^2/a^2 with a = w/2, b = h/2
1025     double c1 = b * b;
1026     double c2 = 2.0 / w;
1027     c2 *= c2;
1028     c2 *= c1;
1029     wxCoord x = 0;
1030     wxCoord y = b;
1031     long x2 = 1;
1032     long y2 = y*y;
1033     long y2_old = 0;
1034     long y_old = 0;
1035     // Lists for quadrant 1 to 4
1036     wxList pointsarray[4];
1037     // Calculate points for first quadrant and set in all quadrants
1038     for( x = 0; x <= a; ++x )
1039     {
1040         x2 = x2+x+x-1;
1041         y2_old = y2;
1042         y_old = y;
1043         bool bNewPoint = false;
1044         while( y2 > c1 - c2 * x2 && y > 0 )
1045         {
1046             bNewPoint = true;
1047             y2 = y2-y-y+1;
1048             --y;
1049         }
1050         // old y now to big: set point with old y, old x
1051         if( bNewPoint && x>1)
1052         {
1053             int x1 = x - 1;
1054             // remove points on the same line
1055             pointsarray[0].Insert( (wxObject*) new wxPoint( xCenter + x1 - decrX, yCenter - y_old ) );
1056             pointsarray[1].Append( (wxObject*) new wxPoint( xCenter - x1, yCenter - y_old ) );
1057             pointsarray[2].Insert( (wxObject*) new wxPoint( xCenter - x1, yCenter + y_old - decrY ) );
1058             pointsarray[3].Append( (wxObject*) new wxPoint( xCenter + x1 - decrX, yCenter + y_old - decrY ) );
1059         } // set point
1060     } // calculate point
1061
1062     // Starting and/or ending points for the quadrants, first quadrant gets both.
1063     pointsarray[0].Insert( (wxObject*) new wxPoint( xCenter + a - decrX, yCenter ) );
1064     pointsarray[0].Append( (wxObject*) new wxPoint( xCenter, yCenter - b ) );
1065     pointsarray[1].Append( (wxObject*) new wxPoint( xCenter - a, yCenter ) );
1066     pointsarray[2].Append( (wxObject*) new wxPoint( xCenter, yCenter + b - decrY ) );
1067     pointsarray[3].Append( (wxObject*) new wxPoint( xCenter + a - decrX, yCenter ) );
1068
1069     // copy quadrants in original list
1070     if( bUseAngles )
1071     {
1072         // Copy the right part of the points in the lists
1073         // and delete the wxPoints, because they do not leave this method.
1074         points->Append( (wxObject*) new wxPoint( xsa, ysa ) );
1075         int q = sq;
1076         bool bStarted = false;
1077         bool bReady = false;
1078         bool bForceTurn = ( sq == eq && sa > ea );
1079         while( !bReady )
1080         {
1081             for( wxNode *node = pointsarray[q].GetFirst(); node; node = node->GetNext() )
1082             {
1083                 // once: go to starting point in start quadrant
1084                 if( !bStarted &&
1085                     (
1086                       ( (wxPoint*) node->GetData() )->x < xsa+1 && q <= 1
1087                       ||
1088                       ( (wxPoint*) node->GetData() )->x > xsa-1 && q >= 2
1089                     )
1090                   )
1091                 {
1092                     bStarted = true;
1093                 }
1094
1095                 // copy point, if not at ending point
1096                 if( bStarted )
1097                 {
1098                     if( q != eq || bForceTurn
1099                         ||
1100                         ( (wxPoint*) node->GetData() )->x > xea+1 && q <= 1
1101                         ||
1102                         ( (wxPoint*) node->GetData() )->x < xea-1 && q >= 2
1103                       )
1104                     {
1105                         // copy point
1106                         wxPoint* pPoint = new wxPoint( *((wxPoint*) node->GetData() ) );
1107                         points->Append( (wxObject*) pPoint );
1108                     }
1109                     else if( q == eq && !bForceTurn || ( (wxPoint*) node->GetData() )->x == xea)
1110                     {
1111                         bReady = true;
1112                     }
1113                 }
1114             } // for node
1115             ++q;
1116             if( q > 3 ) q = 0;
1117             bForceTurn = false;
1118             bStarted = true;
1119         } // while not bReady
1120         points->Append( (wxObject*) new wxPoint( xea, yea ) );
1121
1122         // delete points
1123         for( q = 0; q < 4; ++q )
1124         {
1125             for( wxNode *node = pointsarray[q].GetFirst(); node; node = node->GetNext() )
1126             {
1127                 wxPoint *p = (wxPoint *)node->GetData();
1128                 delete p;
1129             }
1130         }
1131     }
1132     else
1133     {
1134         wxNode* node;
1135         // copy whole ellipse, wxPoints will be deleted outside
1136         for( node = pointsarray[0].GetFirst(); node; node = node->GetNext() )
1137         {
1138             wxObject *p = node->GetData();
1139             points->Append( p );
1140         }
1141         for( node = pointsarray[1].GetFirst(); node; node = node->GetNext() )
1142         {
1143             wxObject *p = node->GetData();
1144             points->Append( p );
1145         }
1146         for( node = pointsarray[2].GetFirst(); node; node = node->GetNext() )
1147         {
1148             wxObject *p = node->GetData();
1149             points->Append( p );
1150         }
1151         for( node = pointsarray[3].GetFirst(); node; node = node->GetNext() )
1152         {
1153             wxObject *p = node->GetData();
1154             points->Append( p );
1155         }
1156     } // not iUseAngles
1157 } // CalculateEllipticPoints
1158
1159 #endif