contrib/src/canvas/canvas.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        canvas.cpp
   3 // Author:      Robert Roebling
   4 // Created:     XX/XX/XX
   5 // Copyright:   2000 (c) Robert Roebling
   6 // Licence:     wxWindows Licence
   7 /////////////////////////////////////////////////////////////////////////////
   8
   9 #ifdef __GNUG__
  10     #pragma implementation "canvas.cpp"
  11 #endif
  12
  13 // For compilers that support precompilation, includes "wx/wx.h".
  14 #include "wx/wxprec.h"
  15
  16 #ifdef __BORLANDC__
  17     #pragma hdrstop
  18 #endif
  19
  20 #include "wx/canvas/canvas.h"
  21
  22 #ifdef __WXGTK__
  23     #include <gtk/gtk.h>
  24     #include <gdk/gdkrgb.h>
  25     #include "wx/gtk/win_gtk.h"
  26 #endif
  27
  28 #ifndef wxUSE_FREETYPE
  29     #define wxUSE_FREETYPE 1
  30 #endif
  31
  32 #if wxUSE_FREETYPE
  33     #include <freetype/freetype.h>
  34 #endif
  35
  36 //----------------------------------------------------------------------------
  37 // globals
  38 //----------------------------------------------------------------------------
  39
  40 #if wxUSE_FREETYPE
  41 FT_Library g_freetypeLibrary;
  42 #endif
  43
  44 //----------------------------------------------------------------------------
  45 // wxCanvasObject
  46 //----------------------------------------------------------------------------
  47
  48 wxCanvasObject::wxCanvasObject()
  49 {
  50     m_owner = NULL;
  51     m_area.x = -1;
  52     m_area.y = -1;
  53     m_area.width = -1;
  54     m_area.height = -1;
  55     m_isControl = FALSE;
  56     m_isVector = FALSE;
  57     m_isImage = FALSE;
  58 }
  59
  60 void wxCanvasObject::SetArea( int x, int y, int width, int height )
  61 {
  62     m_area.x = x;
  63     m_area.y = y;
  64     m_area.width = width;
  65     m_area.height = height;
  66 }
  67
  68 void wxCanvasObject::SetArea( wxRect rect )
  69 {
  70     m_area.x = rect.x;
  71     m_area.y = rect.y;
  72     m_area.width = rect.width;
  73     m_area.height = rect.height;
  74 }
  75
  76 void wxCanvasObject::Move( int x, int y )
  77 {
  78     int old_x = m_area.x;
  79     int old_y = m_area.y;
  80
  81     m_area.x = x;
  82     m_area.y = y;
  83
  84     if (!m_isControl)
  85     {
  86         // TODO: sometimes faster to merge into 1 Update or
  87         // to break up into four
  88         m_owner->Update( old_x, old_y, m_area.width, m_area.height );
  89         m_owner->Update( x, y, m_area.width, m_area.height );
  90     }
  91 }
  92
  93 bool wxCanvasObject::IsHit( int x, int y, int margin )
  94 {
  95     return ((x >= m_area.x-margin) &&
  96             (x <= m_area.x+m_area.width+margin) &&
  97             (y >= m_area.y-margin) &&
  98             (y <= m_area.y+m_area.height+margin));
  99 }
 100
 101 void wxCanvasObject::CaptureMouse()
 102 {
 103     m_owner->SetCaptureMouse( this );
 104 }
 105
 106 void wxCanvasObject::ReleaseMouse()
 107 {
 108     m_owner->SetCaptureMouse( NULL );
 109 }
 110
 111 bool wxCanvasObject::IsCapturedMouse()
 112 {
 113     return m_owner->m_captureMouse==this;
 114 }
 115
 116
 117 void wxCanvasObject::Render(int xabs, int yabs, int clip_x, int clip_y, int clip_width, int clip_height )
 118 {
 119 }
 120
 121 void wxCanvasObject::Recreate()
 122 {
 123 }
 124
 125 void wxCanvasObject::WriteSVG( wxTextOutputStream &stream )
 126 {
 127 }
 128
 129 //----------------------------------------------------------------------------
 130 // wxCanvasObjectGroup
 131 //----------------------------------------------------------------------------
 132
 133 wxCanvasObjectGroup::wxCanvasObjectGroup()
 134 {
 135     m_validbounds = FALSE;
 136 }
 137
 138 wxCanvasObjectGroup::~wxCanvasObjectGroup()
 139 {
 140 }
 141
 142 void wxCanvasObjectGroup::SetOwner(wxCanvas* canvas)
 143 {
 144     m_owner=canvas;
 145     wxNode *node = m_objects.First();
 146     while (node)
 147     {
 148         wxCanvasObject *obj = (wxCanvasObject*) node->Data();
 149
 150         obj->SetOwner(canvas);
 151
 152         node = node->Next();
 153     }
 154 }
 155
 156 void wxCanvasObjectGroup::ExtendArea(int x, int y)
 157 {
 158     if (m_validbounds)
 159     {
 160         if (x < m_minx) m_minx = x;
 161         if (y < m_miny) m_miny = y;
 162         if (x > m_maxx) m_maxx = x;
 163         if (y > m_maxy) m_maxy = y;
 164     }
 165     else
 166     {
 167         m_validbounds = TRUE;
 168
 169         m_minx = x;
 170         m_miny = y;
 171         m_maxx = x;
 172         m_maxy = y;
 173     }
 174 }
 175
 176 void wxCanvasObjectGroup::DeleteContents( bool flag)
 177 {
 178     m_objects.DeleteContents( flag );
 179     m_validbounds = FALSE;
 180 }
 181
 182 void wxCanvasObjectGroup::Prepend( wxCanvasObject* obj )
 183 {
 184     m_objects.Insert( obj );
 185     m_validbounds = FALSE;
 186 }
 187
 188 void wxCanvasObjectGroup::Append( wxCanvasObject* obj )
 189 {
 190     m_objects.Append( obj );
 191     m_validbounds = FALSE;
 192 }
 193
 194 void wxCanvasObjectGroup::Insert( size_t before, wxCanvasObject* obj )
 195 {
 196     m_objects.Insert( before, obj );
 197     m_validbounds = FALSE;
 198 }
 199
 200 void wxCanvasObjectGroup::Remove( wxCanvasObject* obj )
 201 {
 202     m_objects.DeleteObject( obj );
 203     m_validbounds = FALSE;
 204 }
 205
 206 void wxCanvasObjectGroup::Recreate()
 207 {
 208     m_validbounds = FALSE;
 209     wxNode *node = m_objects.First();
 210     while (node)
 211     {
 212         wxCanvasObject *obj = (wxCanvasObject*) node->Data();
 213
 214         obj->Recreate();
 215         ExtendArea(obj->GetX(),obj->GetY());
 216         ExtendArea(obj->GetX()+obj->GetWidth(),obj->GetY()+obj->GetHeight());
 217
 218         node = node->Next();
 219     }
 220 }
 221
 222 void wxCanvasObjectGroup::Render(int xabs, int yabs, int x, int y, int width, int height )
 223 {
 224     // cycle through all objects
 225     wxNode *node = m_objects.First();
 226     while (node)
 227     {
 228         wxCanvasObject *obj = (wxCanvasObject*) node->Data();
 229
 230         if (!obj->IsControl())
 231         {
 232             // If we have 10.000 objects, we will go through
 233             // this 10.000 times for each update, so we have
 234             // to optimise carefully.
 235             int clip_x = xabs + obj->GetX();
 236             int clip_width = obj->GetWidth();
 237             if (clip_x < x)
 238             {
 239                 clip_width -= x-clip_x;
 240                 clip_x = x;
 241             }
 242             if (clip_width > 0)
 243             {
 244                 if (clip_x + clip_width > x + width)
 245                     clip_width = x+width-clip_x;
 246
 247                 if (clip_width > 0)
 248                 {
 249                     int clip_y = yabs + obj->GetY();
 250                     int clip_height = obj->GetHeight();
 251                     if (clip_y < y)
 252                     {
 253                         clip_height -= y-clip_y;
 254                         clip_y = y;
 255                     }
 256                     if (clip_height > 0)
 257                     {
 258                         if (clip_y + clip_height > y + height)
 259                             clip_height = y+height-clip_y;
 260
 261                         if (clip_height > 0)
 262                             obj->Render(xabs,yabs, clip_x, clip_y, clip_width, clip_height );
 263                     }
 264                 }
 265             }
 266         }
 267
 268         node = node->Next();
 269     }
 270 }
 271
 272 void wxCanvasObjectGroup::WriteSVG( wxTextOutputStream &stream )
 273 {
 274 }
 275
 276 bool wxCanvasObjectGroup::IsHit( int x, int y, int margin )
 277 {
 278     wxNode *node = m_objects.Last();
 279     while (node)
 280     {
 281         wxCanvasObject *obj = (wxCanvasObject*) node->Data();
 282
 283         if (!obj->IsControl())
 284         {
 285             if (obj->IsHit(x,y,margin))
 286             {
 287                 return true;
 288             }
 289         }
 290         node = node->Previous();
 291     }
 292     return false;
 293 }
 294
 295 wxCanvasObject* wxCanvasObjectGroup::IsHitObject( int x, int y, int margin )
 296 {
 297     wxCanvasObject *obj=0;
 298     wxNode *node = m_objects.Last();
 299     while (node)
 300     {
 301         obj=(wxCanvasObject*) node->Data();
 302
 303         if (!obj->IsControl())
 304         {
 305             if (obj->IsHit(x,y,margin))
 306             {
 307                 return obj;
 308             }
 309         }
 310         node = node->Previous();
 311     }
 312
 313     return (wxCanvasObject*) NULL;
 314 }
 315
 316 //----------------------------------------------------------------------------
 317 // wxCanvasObjectGroupRef
 318 //----------------------------------------------------------------------------
 319
 320 wxCanvasObjectGroupRef::wxCanvasObjectGroupRef(double x, double y, wxCanvasObjectGroup* group)
 321    : wxCanvasObject()
 322 {
 323     m_x = x;
 324     m_y = y;
 325     m_validbounds=false;
 326     m_group=group;
 327 }
 328
 329 void wxCanvasObjectGroupRef::SetOwner(wxCanvas* canvas)
 330 {
 331     m_owner=canvas;
 332     m_group->SetOwner(canvas);
 333 }
 334
 335 void wxCanvasObjectGroupRef::ExtendArea(int x, int y)
 336 {
 337    if (m_validbounds)
 338    {
 339      if ( x < m_minx ) m_minx = x;
 340      if ( y < m_miny ) m_miny = y;
 341      if ( x > m_maxx ) m_maxx = x;
 342      if ( y > m_maxy ) m_maxy = y;
 343    }
 344    else
 345    {
 346       m_validbounds = true;
 347
 348       m_minx = x;
 349       m_miny = y;
 350       m_maxx = x;
 351       m_maxy = y;
 352    }
 353
 354 }
 355
 356 void wxCanvasObjectGroupRef::Recreate()
 357 {
 358     m_validbounds=false;
 359     m_group->Recreate();
 360     ExtendArea(m_group->GetXMin(),m_group->GetYMin());
 361     ExtendArea(m_group->GetXMax(),m_group->GetYMax());
 362
 363     //set the area in pixels relative to the parent
 364     SetArea( m_owner->GetDeviceX( m_x + m_minx ),
 365              m_owner->GetDeviceY( m_y + m_miny ),
 366              m_owner->GetDeviceWidth( m_maxx-m_minx ),
 367              m_owner->GetDeviceHeight( m_maxy-m_miny ) );
 368 }
 369
 370 void wxCanvasObjectGroupRef::Render(int xabs, int yabs, int x, int y, int width, int height )
 371 {
 372     xabs += m_owner->GetDeviceX(GetPosX());
 373     yabs += m_owner->GetDeviceY(GetPosY());
 374
 375     int clip_x = xabs + m_group->GetXMin();
 376     int clip_width = m_group->GetXMax()-m_group->GetXMin();
 377     if (clip_x < x)
 378     {
 379         clip_width -= x-clip_x;
 380         clip_x = x;
 381     }
 382     if (clip_width > 0)
 383     {
 384         if (clip_x + clip_width > x + width)
 385             clip_width = x+width-clip_x;
 386
 387         if (clip_width > 0)
 388         {
 389             int clip_y = yabs + m_group->GetYMin();
 390             int clip_height = m_group->GetYMax()-m_group->GetYMin();
 391             if (clip_y < y)
 392             {
 393                 clip_height -= y-clip_y;
 394                 clip_y = y;
 395             }
 396             if (clip_height > 0)
 397             {
 398                 if (clip_y + clip_height > y + height)
 399                     clip_height = y+height-clip_y;
 400
 401                 if (clip_height > 0)
 402                     m_group->Render(xabs,yabs, clip_x, clip_y, clip_width, clip_height );
 403             }
 404         }
 405     }
 406 }
 407
 408 void wxCanvasObjectGroupRef::WriteSVG( wxTextOutputStream &stream )
 409 {
 410 }
 411
 412 bool wxCanvasObjectGroupRef::IsHit( int x, int y, int margin )
 413 {
 414     return m_group->IsHit(x-GetPosX(),y-GetPosY(),margin);
 415 }
 416
 417 wxCanvasObject* wxCanvasObjectGroupRef::IsHitObject( int x, int y, int margin )
 418 {
 419     return m_group->IsHitObject(x-GetPosX(),y-GetPosY(),margin);
 420 }
 421
 422 void wxCanvasObjectGroupRef::Move( int x, int y )
 423 {
 424     m_x = x;
 425     m_y = y;
 426
 427     if (!m_isControl)
 428     {
 429         // TODO: sometimes faster to merge into 1 Update or
 430         // to break up into four
 431         m_owner->Update(m_area.x, m_area.y, m_area.width, m_area.height );
 432         //calculate the new area in pixels relative to the parent
 433         SetArea( m_owner->GetDeviceX(  m_x + m_minx ),
 434                  m_owner->GetDeviceY(  m_y + m_miny ),
 435                  m_owner->GetDeviceWidth( m_maxx-m_minx ),
 436                  m_owner->GetDeviceHeight( m_maxy-m_miny ) );
 437         m_owner->Update( m_area.x, m_area.y, m_area.width, m_area.height );
 438     }
 439 }
 440
 441
 442 //----------------------------------------------------------------------------
 443 // wxCanvasRect
 444 //----------------------------------------------------------------------------
 445
 446 wxCanvasRect::wxCanvasRect( double x, double y, double w, double h,
 447                             unsigned char red, unsigned char green, unsigned char blue )
 448    : wxCanvasObject()
 449 {
 450     m_x = x;
 451     m_y = y;
 452     m_width = w;
 453     m_height = h;
 454
 455     m_red = red;
 456     m_green = green;
 457     m_blue = blue;
 458 }
 459
 460 void wxCanvasRect::Recreate()
 461 {
 462     SetArea( m_owner->GetDeviceX( m_x ),
 463              m_owner->GetDeviceY( m_y ),
 464              m_owner->GetDeviceWidth( m_width ),
 465              m_owner->GetDeviceHeight( m_height ) );
 466 }
 467
 468 void wxCanvasRect::Render(int xabs, int yabs, int clip_x, int clip_y, int clip_width, int clip_height )
 469 {
 470     wxImage *image = m_owner->GetBuffer();
 471     int buffer_x = m_owner->GetBufferX();
 472     int buffer_y = m_owner->GetBufferY();
 473
 474     int start_y = clip_y - buffer_y;
 475     int end_y = clip_y+clip_height - buffer_y;
 476
 477     int start_x = clip_x - buffer_x;
 478     int end_x = clip_x+clip_width - buffer_x;
 479
 480     // speed up later
 481     for (int y = start_y; y < end_y; y++)
 482         for (int x = start_x; x < end_x; x++)
 483             image->SetRGB( x, y, m_red, m_green, m_blue );
 484 }
 485
 486 void wxCanvasRect::WriteSVG( wxTextOutputStream &stream )
 487 {
 488 }
 489
 490 //----------------------------------------------------------------------------
 491 // wxCanvasLine
 492 //----------------------------------------------------------------------------
 493
 494 wxCanvasLine::wxCanvasLine( double x1, double y1, double x2, double y2,
 495                             unsigned char red, unsigned char green, unsigned char blue )
 496    : wxCanvasObject()
 497 {
 498     m_x1 = x1;
 499     m_y1 = y1;
 500     m_x2 = x2;
 501     m_y2 = y2;
 502
 503     m_red = red;
 504     m_green = green;
 505     m_blue = blue;
 506 }
 507
 508 void wxCanvasLine::Recreate()
 509 {
 510     int x1 = m_owner->GetDeviceX( m_x1 );
 511     int y1 = m_owner->GetDeviceY( m_y1 );
 512     int x2 = m_owner->GetDeviceX( m_x2 );
 513     int y2 = m_owner->GetDeviceY( m_y2 );
 514     if (x1 > x2)
 515     {
 516         int tmp = x1;
 517         x1 = x2;
 518         x2 = tmp;
 519     }
 520     if (y1 > y2)
 521     {
 522         int tmp = y1;
 523         y1 = y2;
 524         y2 = tmp;
 525     }
 526     SetArea( x1, y1, x2-x1+1, y2-y1+1 );
 527 }
 528
 529 void wxCanvasLine::Render(int xabs, int yabs, int clip_x, int clip_y, int clip_width, int clip_height )
 530 {
 531     wxImage *image = m_owner->GetBuffer();
 532     int buffer_x = m_owner->GetBufferX();
 533     int buffer_y = m_owner->GetBufferY();
 534
 535     if ((m_area.width == 0) && (m_area.height == 0))
 536     {
 537         image->SetRGB( m_area.x-buffer_x, m_area.y-buffer_y, m_red, m_green, m_blue );
 538     }
 539     else
 540     {
 541         int x1 = xabs + m_owner->GetDeviceX( m_x1 );
 542         int y1 = yabs + m_owner->GetDeviceY( m_y1 );
 543         int x2 = xabs + m_owner->GetDeviceX( m_x2 );
 544         int y2 = yabs + m_owner->GetDeviceY( m_y2 );
 545
 546         wxInt32 d, ii, jj, di, ai, si, dj, aj, sj;
 547         di = x1 - x2;
 548         ai = abs(di) << 1;
 549         si = (di < 0)? -1 : 1;
 550         dj = y1 - y2;
 551         aj = abs(dj) << 1;
 552         sj = (dj < 0)? -1 : 1;
 553
 554         ii = x2;
 555         jj = y2;
 556
 557         if (ai > aj)
 558         {
 559             // iterate over i
 560             d = aj - (ai >> 1);
 561
 562             while (ii != x1)
 563             {
 564                 if ((ii >= clip_x) && (ii < clip_x+clip_width) &&
 565                     (jj >= clip_y) && (jj < clip_y+clip_height))
 566                 {
 567                     image->SetRGB( ii-buffer_x, jj-buffer_y, m_red, m_blue, m_green );
 568                 }
 569                 if (d >= 0)
 570                 {
 571                     jj += sj;
 572                     d  -= ai;
 573                 }
 574                 ii += si;
 575                 d  += aj;
 576             }
 577         }
 578         else
 579         {
 580             // iterate over j
 581             d = ai - (aj >> 1);
 582
 583             while (jj != y1)
 584             {
 585                 if ((ii >= clip_x) && (ii < clip_x+clip_width) &&
 586                     (jj >= clip_y) && (jj < clip_y+clip_height))
 587                 {
 588                     image->SetRGB( ii-buffer_x, jj-buffer_y, m_red, m_blue, m_green );
 589                 }
 590                 if (d >= 0)
 591                 {
 592                     ii += si;
 593                     d  -= aj;
 594                 }
 595                 jj += sj;
 596                 d  += ai;
 597             }
 598         }
 599     }
 600 }
 601
 602 void wxCanvasLine::WriteSVG( wxTextOutputStream &stream )
 603 {
 604     // no idea
 605 }
 606
 607 //----------------------------------------------------------------------------
 608 // wxCanvasImage
 609 //----------------------------------------------------------------------------
 610
 611 wxCanvasImage::wxCanvasImage( const wxImage &image, double x, double y, double w, double h )
 612    : wxCanvasObject()
 613 {
 614     m_x = x;
 615     m_y = y;
 616     m_width = w;
 617     m_height = h;
 618
 619     m_image = image;
 620     m_isImage = TRUE;
 621 }
 622
 623 void wxCanvasImage::Recreate()
 624 {
 625     SetArea( m_owner->GetDeviceX( m_x ),
 626              m_owner->GetDeviceY( m_y ),
 627              m_owner->GetDeviceWidth( m_width ),
 628              m_owner->GetDeviceHeight( m_height ) );
 629
 630     if ((m_area.width == m_image.GetWidth()) &&
 631         (m_area.width == m_image.GetWidth()))
 632         m_tmp = m_image;
 633     else
 634         m_tmp = m_image.Scale( m_area.width, m_area.height );
 635 }
 636
 637 void wxCanvasImage::Render(int xabs, int yabs, int clip_x, int clip_y, int clip_width, int clip_height )
 638 {
 639     int buffer_x = m_owner->GetBufferX();
 640     int buffer_y = m_owner->GetBufferY();
 641
 642     if ((clip_x == xabs + m_area.x) &&
 643         (clip_y == yabs + m_area.y) &&
 644         (clip_width == m_area.width) &&
 645         (clip_height == m_area.height))
 646     {
 647         m_owner->GetBuffer()->Paste( m_tmp, clip_x-buffer_x, clip_y-buffer_y );
 648     }
 649     else
 650     {
 651         // local coordinates
 652         int start_x = clip_x - (xabs + m_area.x);
 653         int start_y = clip_y - (yabs + m_area.y);
 654
 655         wxRect rect( start_x, start_y, clip_width, clip_height );
 656         wxImage sub_image( m_tmp.GetSubImage( rect ) );
 657         m_owner->GetBuffer()->Paste( sub_image, clip_x-buffer_x, clip_y-buffer_y );
 658     }
 659 }
 660
 661 void wxCanvasImage::WriteSVG( wxTextOutputStream &stream )
 662 {
 663     // no idea
 664 }
 665
 666 //----------------------------------------------------------------------------
 667 // wxCanvasCtrl
 668 //----------------------------------------------------------------------------
 669
 670 wxCanvasControl::wxCanvasControl( wxWindow *control )
 671    : wxCanvasObject()
 672 {
 673     m_isControl = TRUE;
 674     m_control = control;
 675 }
 676
 677 wxCanvasControl::~wxCanvasControl()
 678 {
 679     m_control->Destroy();
 680 }
 681
 682 void wxCanvasControl::Recreate()
 683 {
 684     m_control->GetSize( &m_area.width, &m_area.height );
 685     m_control->GetPosition( &m_area.x, &m_area.y );
 686 }
 687
 688 void wxCanvasControl::Move( int x, int y )
 689 {
 690     m_control->Move( x, y );
 691 }
 692
 693 //----------------------------------------------------------------------------
 694 // wxCanvasText
 695 //----------------------------------------------------------------------------
 696
 697 class wxFaceData
 698 {
 699 public:
 700 #if wxUSE_FREETYPE
 701      FT_Face   m_face;
 702 #else
 703      void     *m_dummy;
 704 #endif
 705 };
 706
 707 wxCanvasText::wxCanvasText( const wxString &text, double x, double y, const wxString &fontFile, int size )
 708    : wxCanvasObject()
 709 {
 710     m_text = text;
 711     m_fontFileName = fontFile;
 712     m_size = size;
 713
 714     m_red = 0;
 715     m_green = 0;
 716     m_blue = 0;
 717
 718     m_alpha = NULL;
 719
 720     m_x = x;
 721     m_y = y;
 722
 723 #if wxUSE_FREETYPE
 724     wxFaceData *data = new wxFaceData;
 725     m_faceData = data;
 726
 727     int error = FT_New_Face( g_freetypeLibrary,
 728                              m_fontFileName,
 729                              0,
 730                              &(data->m_face) );
 731
 732     error = FT_Set_Char_Size( data->m_face,
 733                               0,
 734                               m_size*64,
 735                               96,    // screen dpi
 736                               96 );
 737 #endif
 738 }
 739
 740 wxCanvasText::~wxCanvasText()
 741 {
 742 #if wxUSE_FREETYPE
 743     wxFaceData *data = (wxFaceData*) m_faceData;
 744     delete data;
 745 #endif
 746
 747     if (m_alpha) delete [] m_alpha;
 748 }
 749
 750 void wxCanvasText::SetRGB( unsigned char red, unsigned char green, unsigned char blue )
 751 {
 752     m_red = red;
 753     m_green = green;
 754     m_blue = blue;
 755 }
 756
 757 void wxCanvasText::SetFlag( int flag )
 758 {
 759     m_flag = flag;
 760 }
 761
 762 void wxCanvasText::Render(int xabs, int yabs, int clip_x, int clip_y, int clip_width, int clip_height )
 763 {
 764     if (!m_alpha) return;
 765
 766     wxImage *image = m_owner->GetBuffer();
 767     int buffer_x = m_owner->GetBufferX();
 768     int buffer_y = m_owner->GetBufferY();
 769
 770     // local coordinates
 771     int start_x = clip_x - m_area.x;
 772     int end_x = clip_width + start_x;
 773     int start_y = clip_y - m_area.y;
 774     int end_y = clip_height + start_y;
 775
 776     for (int y = start_y; y < end_y; y++)
 777         for (int x = start_x; x < end_x; x++)
 778         {
 779             int alpha = m_alpha[y*m_area.width + x];
 780             if (alpha)
 781             {
 782                 int image_x = m_area.x+x - buffer_x;
 783                 int image_y = m_area.y+y - buffer_y;
 784                 if (alpha == 255)
 785                 {
 786                     image->SetRGB( image_x, image_y, m_red, m_green, m_blue );
 787                     continue;
 788                 }
 789                 int red1 = (m_red * alpha) / 255;
 790                 int green1 = (m_green * alpha) / 255;
 791                 int blue1 = (m_blue * alpha) / 255;
 792
 793                 alpha = 255-alpha;
 794                 int red2 = image->GetRed( image_x, image_y );
 795                 int green2 = image->GetGreen( image_x, image_y );
 796                 int blue2 = image->GetBlue( image_x, image_y );
 797                 red2 = (red2 * alpha) / 255;
 798                 green2 = (green2 * alpha) / 255;
 799                 blue2 = (blue2 * alpha) / 255;
 800
 801                 image->SetRGB( image_x, image_y, red1+red2, green1+green2, blue1+blue2 );
 802             }
 803         }
 804 }
 805
 806 void wxCanvasText::WriteSVG( wxTextOutputStream &stream )
 807 {
 808 }
 809
 810 void wxCanvasText::Recreate()
 811 {
 812     if (m_alpha) delete [] m_alpha;
 813
 814     m_area.x = m_owner->GetDeviceX( m_x );
 815     m_area.y = m_owner->GetDeviceY( m_y );
 816
 817     m_area.width = 100;  // TODO, calculate length
 818     m_area.height = m_size;
 819     m_alpha = new unsigned char[100*m_size];
 820     memset( m_alpha, 0, m_area.width*m_area.height );
 821
 822 #if wxUSE_FREETYPE
 823     FT_Face face = ((wxFaceData*)m_faceData)->m_face;
 824     FT_GlyphSlot slot = face->glyph;
 825     int pen_x = 0;
 826     int pen_y = m_size;
 827
 828     for (int n = 0; n < (int)m_text.Len(); n++)
 829     {
 830         FT_UInt index = FT_Get_Char_Index( face, m_text[n] );
 831
 832         int error = FT_Load_Glyph( face, index, FT_LOAD_DEFAULT );
 833         if (error) continue;
 834
 835         error = FT_Render_Glyph( face->glyph, ft_render_mode_normal );
 836         if (error) continue;
 837
 838         FT_Bitmap *bitmap = &slot->bitmap;
 839         unsigned char* buffer = bitmap->buffer;
 840         for (int y = 0; y < bitmap->rows; y++)
 841             for (int x = 0; x < bitmap->width; x++)
 842             {
 843                 unsigned char alpha = buffer[ y*bitmap->pitch + x ];
 844                 if (alpha == 0) continue;
 845
 846                 int xx = pen_x + slot->bitmap_left + x;
 847                 int yy = pen_y - slot->bitmap_top + y;
 848                 m_alpha[ yy * m_area.width + xx ] = alpha;
 849             }
 850
 851         pen_x += slot->advance.x >> 6;
 852         pen_y += slot->advance.y >> 6;
 853     }
 854 #endif
 855 }
 856
 857 //----------------------------------------------------------------------------
 858 // wxCanvas
 859 //----------------------------------------------------------------------------
 860
 861 IMPLEMENT_CLASS(wxCanvas,wxScrolledWindow)
 862
 863 BEGIN_EVENT_TABLE(wxCanvas,wxScrolledWindow)
 864     EVT_CHAR( wxCanvas::OnChar )
 865     EVT_PAINT( wxCanvas::OnPaint )
 866     EVT_SIZE( wxCanvas::OnSize )
 867     EVT_IDLE( wxCanvas::OnIdle )
 868     EVT_MOUSE_EVENTS( wxCanvas::OnMouse )
 869     EVT_SET_FOCUS( wxCanvas::OnSetFocus )
 870     EVT_KILL_FOCUS( wxCanvas::OnKillFocus )
 871     EVT_ERASE_BACKGROUND( wxCanvas::OnEraseBackground )
 872 END_EVENT_TABLE()
 873
 874 wxCanvas::wxCanvas( wxWindow *parent, wxWindowID id,
 875     const wxPoint &position, const wxSize& size, long style ) :
 876     wxScrolledWindow( parent, id, position, size, style )
 877 {
 878     m_bufferX = 0;
 879     m_bufferY = 0;
 880     m_needUpdate = FALSE;
 881     m_red = 0;
 882     m_green = 0;
 883     m_blue = 0;
 884     m_lastMouse = (wxCanvasObject*)NULL;
 885     m_captureMouse = (wxCanvasObject*)NULL;
 886     m_frozen = TRUE;
 887     m_requestNewBuffer = TRUE;
 888
 889     //root group always at 0,0
 890     m_root = new wxCanvasObjectGroup();
 891     m_root->DeleteContents( TRUE );
 892     m_root->SetOwner(this);
 893 }
 894
 895 wxCanvas::~wxCanvas()
 896 {
 897     wxNode *node = m_updateRects.First();
 898     while (node)
 899     {
 900         wxRect *rect = (wxRect*) node->Data();
 901         delete rect;
 902         m_updateRects.DeleteNode( node );
 903         node = m_updateRects.First();
 904     }
 905 }
 906
 907 void wxCanvas::SetArea( int width, int height )
 908 {
 909     SetScrollbars( 10, 10, width/10, height/10 );
 910 }
 911
 912 void wxCanvas::SetColour( unsigned char red, unsigned char green, unsigned char blue )
 913 {
 914     m_red = red;
 915     m_green = green;
 916     m_blue = blue;
 917
 918     SetBackgroundColour( wxColour( red, green, blue ) );
 919
 920     if (m_frozen) return;
 921
 922     unsigned char *data = m_buffer.GetData();
 923
 924     for (int y = 0; y < m_buffer.GetHeight(); y++)
 925         for (int x = 0; x < m_buffer.GetWidth(); x++)
 926         {
 927             data[0] = red;
 928             data++;
 929             data[0] = green;
 930             data++;
 931             data[0] = blue;
 932             data++;
 933         }
 934 }
 935
 936 void wxCanvas::SetCaptureMouse( wxCanvasObject *obj )
 937 {
 938     if (obj)
 939     {
 940         wxWindow::CaptureMouse();
 941         m_captureMouse = obj;
 942     }
 943     else
 944     {
 945         wxWindow::ReleaseMouse();
 946         m_captureMouse = NULL;
 947     }
 948 }
 949
 950 void wxCanvas::Freeze()
 951 {
 952     m_frozen = TRUE;
 953 }
 954
 955 void wxCanvas::Thaw()
 956 {
 957     wxNode *node = m_updateRects.First();
 958     while (node)
 959     {
 960         wxRect *rect = (wxRect*) node->Data();
 961         delete rect;
 962         m_updateRects.DeleteNode( node );
 963         node = m_updateRects.First();
 964     }
 965
 966     m_frozen = FALSE;
 967
 968     if (m_buffer.Ok())
 969         Update( m_bufferX, m_bufferY, m_buffer.GetWidth(), m_buffer.GetHeight() );
 970 }
 971
 972 void wxCanvas::Update( int x, int y, int width, int height, bool blit )
 973 {
 974     if (m_frozen) return;
 975
 976     // clip to buffer
 977     if (x < m_bufferX)
 978     {
 979         width -= m_bufferX-x;
 980         x = m_bufferX;
 981     }
 982     if (width < 0) return;
 983
 984     if (y < m_bufferY)
 985     {
 986         height -= m_bufferY-y;
 987         y = m_bufferY;
 988     }
 989     if (height < 0) return;
 990
 991     if (x+width > m_bufferX+m_buffer.GetWidth())
 992     {
 993         width = m_bufferX+m_buffer.GetWidth() - x;
 994     }
 995     if (width < 0) return;
 996
 997     if (y+height > m_bufferY+m_buffer.GetHeight())
 998     {
 999         height = m_bufferY+m_buffer.GetHeight() - y;
1000     }
1001     if (height < 0) return;
1002
1003     // update is within the buffer
1004     m_needUpdate = TRUE;
1005
1006     // has to be blitted to screen later
1007     if (blit)
1008     {
1009         m_updateRects.Append(
1010             (wxObject*) new wxRect( x,y,width,height ) );
1011     }
1012
1013     // speed up with direct access, maybe add wxImage::Clear(x,y,w,h,r,g,b)
1014     int start_y = y - m_bufferY;
1015     int end_y = y+height - m_bufferY;
1016     int start_x = x - m_bufferX;
1017     int end_x = x+width - m_bufferX;
1018     for (int yy = start_y; yy < end_y; yy++)
1019         for (int xx = start_x; xx < end_x; xx++)
1020             m_buffer.SetRGB( xx, yy, m_red, m_green, m_blue );
1021
1022     m_root->Render(0,0, x, y, width, height );
1023
1024 }
1025
1026 void wxCanvas::BlitBuffer( wxDC &dc )
1027 {
1028     wxNode *node = m_updateRects.First();
1029     while (node)
1030     {
1031         wxRect *rect = (wxRect*) node->Data();
1032
1033         wxRect sub_rect( *rect );
1034         sub_rect.x -= m_bufferX;
1035         sub_rect.y -= m_bufferY;
1036
1037         wxImage sub_image( m_buffer.GetSubImage( sub_rect ) );
1038
1039 #ifdef __WXGTK__
1040         int bpp = wxDisplayDepth();
1041         if (bpp > 8)
1042         {
1043             // the init code is doubled in wxImage
1044             static bool s_hasInitialized = FALSE;
1045
1046             if (!s_hasInitialized)
1047             {
1048                 gdk_rgb_init();
1049                 s_hasInitialized = TRUE;
1050             }
1051
1052             gdk_draw_rgb_image( GTK_PIZZA(m_wxwindow)->bin_window,
1053                             m_wxwindow->style->black_gc,
1054                             sub_rect.x, sub_rect.y,
1055                             sub_image.GetWidth(), sub_image.GetHeight(),
1056                             GDK_RGB_DITHER_NONE,
1057                             sub_image.GetData(),
1058                             sub_image.GetWidth()*3 );
1059         }
1060         else
1061         {
1062             wxBitmap bitmap( sub_image.ConvertToBitmap() );
1063             dc.DrawBitmap( bitmap, rect->x, rect->y );
1064         }
1065 #endif
1066
1067 #ifndef __WXGTK__
1068         wxBitmap bitmap( sub_image.ConvertToBitmap() );
1069         dc.DrawBitmap( bitmap, rect->x, rect->y );
1070 #endif
1071
1072         delete rect;
1073         m_updateRects.DeleteNode( node );
1074         node = m_updateRects.First();
1075     }
1076
1077     m_needUpdate = FALSE;
1078 }
1079
1080 void wxCanvas::UpdateNow()
1081 {
1082     if (m_frozen) return;
1083
1084     if (!m_needUpdate) return;
1085
1086     wxClientDC dc( this );
1087     PrepareDC( dc );
1088
1089     BlitBuffer( dc );
1090 }
1091
1092 int wxCanvas::GetDeviceX( double x )
1093 {
1094     return (int) x;
1095 }
1096
1097 int wxCanvas::GetDeviceY( double y )
1098 {
1099     return (int) y;
1100 }
1101
1102 int wxCanvas::GetDeviceWidth( double width )
1103 {
1104     return (int) width;
1105 }
1106
1107 int wxCanvas::GetDeviceHeight( double height )
1108 {
1109     return (int) height;
1110 }
1111
1112 void wxCanvas::Recreate()
1113 {
1114     m_root->Recreate();
1115 }
1116
1117 void wxCanvas::Prepend( wxCanvasObject* obj )
1118 {
1119     m_root->Prepend( obj );
1120     obj->SetOwner(this);
1121
1122     m_root->Recreate();
1123
1124     if (!obj->IsControl())
1125         Update( obj->GetX(), obj->GetY(), obj->GetWidth(), obj->GetHeight() );
1126 }
1127
1128 void wxCanvas::Append( wxCanvasObject* obj )
1129 {
1130     m_root->Append( obj );
1131     obj->SetOwner(this);
1132
1133     m_root->Recreate();
1134
1135     if (!obj->IsControl())
1136         Update( obj->GetX(), obj->GetY(), obj->GetWidth(), obj->GetHeight() );
1137 }
1138
1139 void wxCanvas::Insert( size_t before, wxCanvasObject* obj )
1140 {
1141     m_root->Insert( before, obj );
1142     obj->SetOwner(this);
1143
1144     m_root->Recreate();
1145
1146     if (!obj->IsControl())
1147         Update( obj->GetX(), obj->GetY(), obj->GetWidth(), obj->GetHeight() );
1148 }
1149
1150 void wxCanvas::Remove( wxCanvasObject* obj )
1151 {
1152     int x = obj->GetX();
1153     int y = obj->GetY();
1154     int w = obj->GetWidth();
1155     int h = obj->GetHeight();
1156     bool ic = obj->IsControl();
1157
1158     m_root->Remove( obj );
1159
1160     if (!ic)
1161         Update( x, y, w, h );
1162 }
1163
1164 void wxCanvas::OnPaint(wxPaintEvent &event)
1165 {
1166     wxPaintDC dc(this);
1167     PrepareDC( dc );
1168
1169     if (!m_buffer.Ok()) return;
1170
1171     if (m_frozen) return;
1172
1173     m_needUpdate = TRUE;
1174
1175     wxRegionIterator it( GetUpdateRegion() );
1176     while (it)
1177     {
1178         int x = it.GetX();
1179         int y = it.GetY();
1180
1181         int w = it.GetWidth();
1182         int h = it.GetHeight();
1183
1184         if (x+w > m_buffer.GetWidth())
1185             w = m_buffer.GetWidth() - x;
1186         if (y+h > m_buffer.GetHeight())
1187             h = m_buffer.GetHeight() - y;
1188
1189         if ((w > 0) && (h > 0))
1190         {
1191             CalcUnscrolledPosition( x, y, &x, &y );
1192             m_updateRects.Append( (wxObject*) new wxRect( x, y, w, h ) );
1193         }
1194
1195         it++;
1196     }
1197
1198     BlitBuffer( dc );
1199 }
1200
1201 void wxCanvas::ScrollWindow( int dx, int dy, const wxRect* rect )
1202 {
1203     // If any updates are pending, do them now since they will
1204     // expect the previous m_bufferX and m_bufferY values.
1205     UpdateNow();
1206
1207     // The buffer always starts at the top left corner of the
1208     // client area. Indeed, it is the client area.
1209     CalcUnscrolledPosition( 0, 0, &m_bufferX, &m_bufferY );
1210
1211     unsigned char* data = m_buffer.GetData();
1212
1213     if (dy != 0)
1214     {
1215         if (dy > 0)
1216         {
1217             unsigned char *source = data;
1218             unsigned char *dest = data + (dy * m_buffer.GetWidth() * 3);
1219             size_t count = (size_t) (m_buffer.GetWidth() * 3 * (m_buffer.GetHeight()-dy));
1220             memmove( dest, source, count );
1221
1222             // We update the new buffer area, but there is no need to
1223             // blit (last param FALSE) since the ensuing paint event will
1224             // do that anyway.
1225             Update( m_bufferX, m_bufferY, m_buffer.GetWidth(), dy, FALSE );
1226         }
1227         else
1228         {
1229             unsigned char *dest = data;
1230             unsigned char *source = data + (-dy * m_buffer.GetWidth() * 3);
1231             size_t count = (size_t) (m_buffer.GetWidth() * 3 * (m_buffer.GetHeight()+dy));
1232             memmove( dest, source, count );
1233
1234             // We update the new buffer area, but there is no need to
1235             // blit (last param FALSE) since the ensuing paint event will
1236             // do that anyway.
1237             Update( m_bufferX, m_bufferY+m_buffer.GetHeight()+dy, m_buffer.GetWidth(), -dy, FALSE );
1238         }
1239     }
1240
1241     if (dx != 0)
1242     {
1243         if (dx > 0)
1244         {
1245             unsigned char *source = data;
1246             for (int y = 0; y < m_buffer.GetHeight(); y++)
1247             {
1248                 unsigned char *dest = source + dx*3;
1249                 memmove( dest, source, (m_buffer.GetWidth()-dx) * 3 );
1250                 source += m_buffer.GetWidth()*3;
1251             }
1252
1253             // We update the new buffer area, but there is no need to
1254             // blit (last param FALSE) since the ensuing paint event will
1255             // do that anyway.
1256             Update( m_bufferX, m_bufferY, dx, m_buffer.GetHeight(), FALSE );
1257         }
1258         else
1259         {
1260             unsigned char *dest = data;
1261             for (int y = 0; y < m_buffer.GetHeight(); y++)
1262             {
1263                 unsigned char *source = dest - dx*3;
1264                 memmove( dest, source, (m_buffer.GetWidth()+dx) * 3 );
1265                 dest += m_buffer.GetWidth()*3;
1266             }
1267
1268             // We update the new buffer area, but there is no need to
1269             // blit (last param FALSE) since the ensuing paint event will
1270             // do that anyway.
1271             Update( m_bufferX+m_buffer.GetWidth()+dx, m_bufferY, -dx, m_buffer.GetHeight(), FALSE );
1272         }
1273     }
1274
1275     wxWindow::ScrollWindow( dx, dy, rect );
1276 }
1277
1278 void wxCanvas::OnMouse(wxMouseEvent &event)
1279 {
1280     int x = event.GetX();
1281     int y = event.GetY();
1282     CalcUnscrolledPosition( x, y, &x, &y );
1283
1284     if (event.GetEventType() == wxEVT_MOTION)
1285     {
1286         if (m_captureMouse) //no matter what go to this one
1287         {
1288             wxMouseEvent child_event( wxEVT_MOTION );
1289             child_event.SetEventObject(m_captureMouse);
1290             child_event.m_x = x - m_captureMouse->GetX();
1291             child_event.m_y = y - m_captureMouse->GetY();
1292             child_event.m_leftDown = event.m_leftDown;
1293             child_event.m_rightDown = event.m_rightDown;
1294             child_event.m_middleDown = event.m_middleDown;
1295             child_event.m_controlDown = event.m_controlDown;
1296             child_event.m_shiftDown = event.m_shiftDown;
1297             child_event.m_altDown = event.m_altDown;
1298             child_event.m_metaDown = event.m_metaDown;
1299             m_captureMouse->ProcessEvent( child_event );
1300         }
1301         else
1302         {
1303             wxCanvasObject *obj = m_root->IsHitObject(x,y,0);
1304
1305             if (obj && !obj->IsControl())
1306             {
1307                 wxMouseEvent child_event( wxEVT_MOTION );
1308                 child_event.SetEventObject( obj );
1309                 child_event.m_x = x - obj->GetX();
1310                 child_event.m_y = y - obj->GetY();
1311                 child_event.m_leftDown = event.m_leftDown;
1312                 child_event.m_rightDown = event.m_rightDown;
1313                 child_event.m_middleDown = event.m_middleDown;
1314                 child_event.m_controlDown = event.m_controlDown;
1315                 child_event.m_shiftDown = event.m_shiftDown;
1316                 child_event.m_altDown = event.m_altDown;
1317                 child_event.m_metaDown = event.m_metaDown;
1318
1319                 if ((obj != m_lastMouse) && (m_lastMouse != NULL))
1320                 {
1321                     child_event.SetEventType( wxEVT_LEAVE_WINDOW );
1322                     child_event.SetEventObject( m_lastMouse );
1323                     child_event.m_x = x - m_lastMouse->GetX();
1324                     child_event.m_y = y - m_lastMouse->GetY();
1325                     m_lastMouse->ProcessEvent( child_event );
1326
1327                     m_lastMouse = obj;
1328                     child_event.SetEventType( wxEVT_ENTER_WINDOW );
1329                     child_event.SetEventObject( m_lastMouse );
1330                     child_event.m_x = x - m_lastMouse->GetX();
1331                     child_event.m_y = y - m_lastMouse->GetY();
1332                     m_lastMouse->ProcessEvent( child_event );
1333
1334                     child_event.SetEventType( wxEVT_MOTION );
1335                     child_event.SetEventObject( obj );
1336                 }
1337                 obj->ProcessEvent( child_event );
1338                 return;
1339             }
1340         }
1341         if (m_lastMouse)
1342         {
1343             wxMouseEvent child_event( wxEVT_LEAVE_WINDOW );
1344             child_event.SetEventObject( m_lastMouse );
1345             child_event.m_x = x - m_lastMouse->GetX();
1346             child_event.m_y = y - m_lastMouse->GetY();
1347             child_event.m_leftDown = event.m_leftDown;
1348             child_event.m_rightDown = event.m_rightDown;
1349             child_event.m_middleDown = event.m_middleDown;
1350             child_event.m_controlDown = event.m_controlDown;
1351             child_event.m_shiftDown = event.m_shiftDown;
1352             child_event.m_altDown = event.m_altDown;
1353             child_event.m_metaDown = event.m_metaDown;
1354             m_lastMouse->ProcessEvent( child_event );
1355
1356             m_lastMouse = (wxCanvasObject*) NULL;
1357             return;
1358         }
1359     }
1360
1361     event.Skip();
1362 }
1363
1364 void wxCanvas::OnSize(wxSizeEvent &event)
1365 {
1366     int w,h;
1367     GetClientSize( &w, &h );
1368     m_buffer = wxImage( w, h );
1369
1370     CalcUnscrolledPosition( 0, 0, &m_bufferX, &m_bufferY );
1371
1372     wxNode *node = m_updateRects.First();
1373     while (node)
1374     {
1375         wxRect *rect = (wxRect*) node->Data();
1376         delete rect;
1377         m_updateRects.DeleteNode( node );
1378         node = m_updateRects.First();
1379     }
1380
1381     m_frozen = FALSE;
1382
1383     Update( m_bufferX, m_bufferY, m_buffer.GetWidth(), m_buffer.GetHeight(), FALSE );
1384
1385     event.Skip();
1386 }
1387
1388 void wxCanvas::OnIdle(wxIdleEvent &event)
1389 {
1390     UpdateNow();
1391     event.Skip();
1392 }
1393
1394 void wxCanvas::OnSetFocus(wxFocusEvent &event)
1395 {
1396 }
1397
1398 void wxCanvas::OnKillFocus(wxFocusEvent &event)
1399 {
1400 }
1401
1402 void wxCanvas::OnChar(wxKeyEvent &event)
1403 {
1404     event.Skip();
1405 }
1406
1407 void wxCanvas::OnEraseBackground(wxEraseEvent &event)
1408 {
1409 }
1410
1411 //--------------------------------------------------------------------
1412 // wxCanvasModule
1413 //--------------------------------------------------------------------
1414
1415 class wxCanvasModule : public wxModule
1416 {
1417 public:
1418     virtual bool OnInit();
1419     virtual void OnExit();
1420
1421 private:
1422     DECLARE_DYNAMIC_CLASS(wxCanvasModule)
1423 };
1424
1425 IMPLEMENT_DYNAMIC_CLASS(wxCanvasModule, wxModule)
1426
1427 bool wxCanvasModule::OnInit()
1428 {
1429 #if wxUSE_FREETYPE
1430     int error = FT_Init_FreeType( &g_freetypeLibrary );
1431     if (error) return FALSE;
1432 #endif
1433
1434     return TRUE;
1435 }
1436
1437 void wxCanvasModule::OnExit()
1438 {
1439 #if wxUSE_FREETYPE
1440     FT_Done_FreeType( g_freetypeLibrary );
1441 #endif
1442 }