src/common/image.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/image.cpp
   3 // Purpose:     wxImage
   4 // Author:      Robert Roebling
   5 // RCS-ID:      $Id$
   6 // Copyright:   (c) Robert Roebling
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 // For compilers that support precompilation, includes "wx.h".
  11 #include "wx/wxprec.h"
  12
  13 #ifdef __BORLANDC__
  14     #pragma hdrstop
  15 #endif
  16
  17 #if wxUSE_IMAGE
  18
  19 #include "wx/image.h"
  20
  21 #ifndef WX_PRECOMP
  22     #include "wx/log.h"
  23     #include "wx/hash.h"
  24     #include "wx/utils.h"
  25     #include "wx/math.h"
  26     #include "wx/module.h"
  27     #include "wx/palette.h"
  28     #include "wx/intl.h"
  29     #include "wx/colour.h"
  30 #endif
  31
  32 #include "wx/wfstream.h"
  33 #include "wx/xpmdecod.h"
  34
  35 // For memcpy
  36 #include <string.h>
  37
  38 // make the code compile with either wxFile*Stream or wxFFile*Stream:
  39 #define HAS_FILE_STREAMS (wxUSE_STREAMS && (wxUSE_FILE || wxUSE_FFILE))
  40
  41 #if HAS_FILE_STREAMS
  42     #if wxUSE_FFILE
  43         typedef wxFFileInputStream wxImageFileInputStream;
  44         typedef wxFFileOutputStream wxImageFileOutputStream;
  45     #elif wxUSE_FILE
  46         typedef wxFileInputStream wxImageFileInputStream;
  47         typedef wxFileOutputStream wxImageFileOutputStream;
  48     #endif // wxUSE_FILE/wxUSE_FFILE
  49 #endif // HAS_FILE_STREAMS
  50
  51 #if wxUSE_VARIANT
  52 IMPLEMENT_VARIANT_OBJECT_EXPORTED_SHALLOWCMP(wxImage,WXDLLEXPORT)
  53 #endif
  54
  55 //-----------------------------------------------------------------------------
  56 // global data
  57 //-----------------------------------------------------------------------------
  58
  59 wxList wxImage::sm_handlers;
  60 wxImage wxNullImage;
  61
  62 //-----------------------------------------------------------------------------
  63 // wxImageRefData
  64 //-----------------------------------------------------------------------------
  65
  66 class wxImageRefData: public wxObjectRefData
  67 {
  68 public:
  69     wxImageRefData();
  70     virtual ~wxImageRefData();
  71
  72     int             m_width;
  73     int             m_height;
  74     wxBitmapType    m_type;
  75     unsigned char  *m_data;
  76
  77     bool            m_hasMask;
  78     unsigned char   m_maskRed,m_maskGreen,m_maskBlue;
  79
  80     // alpha channel data, may be NULL for the formats without alpha support
  81     unsigned char  *m_alpha;
  82
  83     bool            m_ok;
  84
  85     // if true, m_data is pointer to static data and shouldn't be freed
  86     bool            m_static;
  87
  88     // same as m_static but for m_alpha
  89     bool            m_staticAlpha;
  90
  91 #if wxUSE_PALETTE
  92     wxPalette       m_palette;
  93 #endif // wxUSE_PALETTE
  94
  95     wxArrayString   m_optionNames;
  96     wxArrayString   m_optionValues;
  97
  98     wxDECLARE_NO_COPY_CLASS(wxImageRefData);
  99 };
 100
 101 wxImageRefData::wxImageRefData()
 102 {
 103     m_width = 0;
 104     m_height = 0;
 105     m_type = wxBITMAP_TYPE_INVALID;
 106     m_data =
 107     m_alpha = (unsigned char *) NULL;
 108
 109     m_maskRed = 0;
 110     m_maskGreen = 0;
 111     m_maskBlue = 0;
 112     m_hasMask = false;
 113
 114     m_ok = false;
 115     m_static =
 116     m_staticAlpha = false;
 117 }
 118
 119 wxImageRefData::~wxImageRefData()
 120 {
 121     if ( !m_static )
 122         free( m_data );
 123     if ( !m_staticAlpha )
 124         free( m_alpha );
 125 }
 126
 127
 128 //-----------------------------------------------------------------------------
 129 // wxImage
 130 //-----------------------------------------------------------------------------
 131
 132 #define M_IMGDATA static_cast<wxImageRefData*>(m_refData)
 133
 134 IMPLEMENT_DYNAMIC_CLASS(wxImage, wxObject)
 135
 136 bool wxImage::Create(const char* const* xpmData)
 137 {
 138 #if wxUSE_XPM
 139     UnRef();
 140
 141     wxXPMDecoder decoder;
 142     (*this) = decoder.ReadData(xpmData);
 143     return Ok();
 144 #else
 145     return false;
 146 #endif
 147 }
 148
 149 bool wxImage::Create( int width, int height, bool clear )
 150 {
 151     UnRef();
 152
 153     m_refData = new wxImageRefData();
 154
 155     M_IMGDATA->m_data = (unsigned char *) malloc( width*height*3 );
 156     if (!M_IMGDATA->m_data)
 157     {
 158         UnRef();
 159         return false;
 160     }
 161
 162     M_IMGDATA->m_width = width;
 163     M_IMGDATA->m_height = height;
 164     M_IMGDATA->m_ok = true;
 165
 166     if (clear)
 167     {
 168         Clear();
 169     }
 170
 171     return true;
 172 }
 173
 174 bool wxImage::Create( int width, int height, unsigned char* data, bool static_data )
 175 {
 176     UnRef();
 177
 178     wxCHECK_MSG( data, false, wxT("NULL data in wxImage::Create") );
 179
 180     m_refData = new wxImageRefData();
 181
 182     M_IMGDATA->m_data = data;
 183     M_IMGDATA->m_width = width;
 184     M_IMGDATA->m_height = height;
 185     M_IMGDATA->m_ok = true;
 186     M_IMGDATA->m_static = static_data;
 187
 188     return true;
 189 }
 190
 191 bool wxImage::Create( int width, int height, unsigned char* data, unsigned char* alpha, bool static_data )
 192 {
 193     UnRef();
 194
 195     wxCHECK_MSG( data, false, wxT("NULL data in wxImage::Create") );
 196
 197     m_refData = new wxImageRefData();
 198
 199     M_IMGDATA->m_data = data;
 200     M_IMGDATA->m_alpha = alpha;
 201     M_IMGDATA->m_width = width;
 202     M_IMGDATA->m_height = height;
 203     M_IMGDATA->m_ok = true;
 204     M_IMGDATA->m_static = static_data;
 205     M_IMGDATA->m_staticAlpha = static_data;
 206
 207     return true;
 208 }
 209
 210 void wxImage::Destroy()
 211 {
 212     UnRef();
 213 }
 214
 215 void wxImage::Clear(unsigned char value)
 216 {
 217     memset(M_IMGDATA->m_data, value, M_IMGDATA->m_width*M_IMGDATA->m_height*3);
 218 }
 219
 220 wxObjectRefData* wxImage::CreateRefData() const
 221 {
 222     return new wxImageRefData;
 223 }
 224
 225 wxObjectRefData* wxImage::CloneRefData(const wxObjectRefData* that) const
 226 {
 227     const wxImageRefData* refData = static_cast<const wxImageRefData*>(that);
 228     wxCHECK_MSG(refData->m_ok, NULL, wxT("invalid image") );
 229
 230     wxImageRefData* refData_new = new wxImageRefData;
 231     refData_new->m_width = refData->m_width;
 232     refData_new->m_height = refData->m_height;
 233     refData_new->m_maskRed = refData->m_maskRed;
 234     refData_new->m_maskGreen = refData->m_maskGreen;
 235     refData_new->m_maskBlue = refData->m_maskBlue;
 236     refData_new->m_hasMask = refData->m_hasMask;
 237     refData_new->m_ok = true;
 238     unsigned size = unsigned(refData->m_width) * unsigned(refData->m_height);
 239     if (refData->m_alpha != NULL)
 240     {
 241         refData_new->m_alpha = (unsigned char*)malloc(size);
 242         memcpy(refData_new->m_alpha, refData->m_alpha, size);
 243     }
 244     size *= 3;
 245     refData_new->m_data = (unsigned char*)malloc(size);
 246     memcpy(refData_new->m_data, refData->m_data, size);
 247 #if wxUSE_PALETTE
 248     refData_new->m_palette = refData->m_palette;
 249 #endif
 250     refData_new->m_optionNames = refData->m_optionNames;
 251     refData_new->m_optionValues = refData->m_optionValues;
 252     return refData_new;
 253 }
 254
 255 // returns a new image with the same dimensions, alpha, and mask as *this
 256 // if on_its_side is true, width and height are swapped
 257 wxImage wxImage::MakeEmptyClone(int flags) const
 258 {
 259     wxImage image;
 260
 261     wxCHECK_MSG( Ok(), image, wxS("invalid image") );
 262
 263     long height = M_IMGDATA->m_height;
 264     long width  = M_IMGDATA->m_width;
 265
 266     if ( flags & Clone_SwapOrientation )
 267         wxSwap( width, height );
 268
 269     if ( !image.Create( width, height, false ) )
 270     {
 271         wxFAIL_MSG( wxS("unable to create image") );
 272         return image;
 273     }
 274
 275     if ( M_IMGDATA->m_alpha )
 276     {
 277         image.SetAlpha();
 278         wxCHECK2_MSG( image.GetAlpha(), return wxImage(),
 279                       wxS("unable to create alpha channel") );
 280     }
 281
 282     if ( M_IMGDATA->m_hasMask )
 283     {
 284         image.SetMaskColour( M_IMGDATA->m_maskRed,
 285                              M_IMGDATA->m_maskGreen,
 286                              M_IMGDATA->m_maskBlue );
 287     }
 288
 289     return image;
 290 }
 291
 292 wxImage wxImage::Copy() const
 293 {
 294     wxImage image;
 295
 296     wxCHECK_MSG( Ok(), image, wxT("invalid image") );
 297
 298     image.m_refData = CloneRefData(m_refData);
 299
 300     return image;
 301 }
 302
 303 wxImage wxImage::ShrinkBy( int xFactor , int yFactor ) const
 304 {
 305     if( xFactor == 1 && yFactor == 1 )
 306         return *this;
 307
 308     wxImage image;
 309
 310     wxCHECK_MSG( Ok(), image, wxT("invalid image") );
 311
 312     // can't scale to/from 0 size
 313     wxCHECK_MSG( (xFactor > 0) && (yFactor > 0), image,
 314                  wxT("invalid new image size") );
 315
 316     long old_height = M_IMGDATA->m_height,
 317          old_width  = M_IMGDATA->m_width;
 318
 319     wxCHECK_MSG( (old_height > 0) && (old_width > 0), image,
 320                  wxT("invalid old image size") );
 321
 322     long width = old_width / xFactor ;
 323     long height = old_height / yFactor ;
 324
 325     image.Create( width, height, false );
 326
 327     char unsigned *data = image.GetData();
 328
 329     wxCHECK_MSG( data, image, wxT("unable to create image") );
 330
 331     bool hasMask = false ;
 332     unsigned char maskRed = 0;
 333     unsigned char maskGreen = 0;
 334     unsigned char maskBlue = 0 ;
 335
 336     const unsigned char *source_data = M_IMGDATA->m_data;
 337     unsigned char *target_data = data;
 338     const unsigned char *source_alpha = 0 ;
 339     unsigned char *target_alpha = 0 ;
 340     if (M_IMGDATA->m_hasMask)
 341     {
 342         hasMask = true ;
 343         maskRed = M_IMGDATA->m_maskRed;
 344         maskGreen = M_IMGDATA->m_maskGreen;
 345         maskBlue =M_IMGDATA->m_maskBlue ;
 346
 347         image.SetMaskColour( M_IMGDATA->m_maskRed,
 348                              M_IMGDATA->m_maskGreen,
 349                              M_IMGDATA->m_maskBlue );
 350     }
 351     else
 352     {
 353         source_alpha = M_IMGDATA->m_alpha ;
 354         if ( source_alpha )
 355         {
 356             image.SetAlpha() ;
 357             target_alpha = image.GetAlpha() ;
 358         }
 359     }
 360
 361     for (long y = 0; y < height; y++)
 362     {
 363         for (long x = 0; x < width; x++)
 364         {
 365             unsigned long avgRed = 0 ;
 366             unsigned long avgGreen = 0;
 367             unsigned long avgBlue = 0;
 368             unsigned long avgAlpha = 0 ;
 369             unsigned long counter = 0 ;
 370             // determine average
 371             for ( int y1 = 0 ; y1 < yFactor ; ++y1 )
 372             {
 373                 long y_offset = (y * yFactor + y1) * old_width;
 374                 for ( int x1 = 0 ; x1 < xFactor ; ++x1 )
 375                 {
 376                     const unsigned char *pixel = source_data + 3 * ( y_offset + x * xFactor + x1 ) ;
 377                     unsigned char red = pixel[0] ;
 378                     unsigned char green = pixel[1] ;
 379                     unsigned char blue = pixel[2] ;
 380                     unsigned char alpha = 255  ;
 381                     if ( source_alpha )
 382                         alpha = *(source_alpha + y_offset + x * xFactor + x1) ;
 383                     if ( !hasMask || red != maskRed || green != maskGreen || blue != maskBlue )
 384                     {
 385                         if ( alpha > 0 )
 386                         {
 387                             avgRed += red ;
 388                             avgGreen += green ;
 389                             avgBlue += blue ;
 390                         }
 391                         avgAlpha += alpha ;
 392                         counter++ ;
 393                     }
 394                 }
 395             }
 396             if ( counter == 0 )
 397             {
 398                 *(target_data++) = M_IMGDATA->m_maskRed ;
 399                 *(target_data++) = M_IMGDATA->m_maskGreen ;
 400                 *(target_data++) = M_IMGDATA->m_maskBlue ;
 401             }
 402             else
 403             {
 404                 if ( source_alpha )
 405                     *(target_alpha++) = (unsigned char)(avgAlpha / counter ) ;
 406                 *(target_data++) = (unsigned char)(avgRed / counter);
 407                 *(target_data++) = (unsigned char)(avgGreen / counter);
 408                 *(target_data++) = (unsigned char)(avgBlue / counter);
 409             }
 410         }
 411     }
 412
 413     // In case this is a cursor, make sure the hotspot is scaled accordingly:
 414     if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_X) )
 415         image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X,
 416                 (GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_X))/xFactor);
 417     if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y) )
 418         image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y,
 419                 (GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_Y))/yFactor);
 420
 421     return image;
 422 }
 423
 424 wxImage
 425 wxImage::Scale( int width, int height, wxImageResizeQuality quality ) const
 426 {
 427     wxImage image;
 428
 429     wxCHECK_MSG( Ok(), image, wxT("invalid image") );
 430
 431     // can't scale to/from 0 size
 432     wxCHECK_MSG( (width > 0) && (height > 0), image,
 433                  wxT("invalid new image size") );
 434
 435     long old_height = M_IMGDATA->m_height,
 436          old_width  = M_IMGDATA->m_width;
 437     wxCHECK_MSG( (old_height > 0) && (old_width > 0), image,
 438                  wxT("invalid old image size") );
 439
 440     // If the image's new width and height are the same as the original, no
 441     // need to waste time or CPU cycles
 442     if ( old_width == width && old_height == height )
 443         return *this;
 444
 445     if (quality == wxIMAGE_QUALITY_HIGH)
 446     {
 447         quality = (width < old_width && height < old_height)
 448             ? wxIMAGE_QUALITY_BOX_AVERAGE
 449             : wxIMAGE_QUALITY_BICUBIC;
 450     }
 451
 452     // Resample the image using the method as specified.
 453     switch ( quality )
 454     {
 455         case wxIMAGE_QUALITY_NEAREST:
 456             if ( old_width % width == 0 && old_width >= width &&
 457                 old_height % height == 0 && old_height >= height )
 458             {
 459                 return ShrinkBy( old_width / width , old_height / height );
 460             }
 461
 462             image = ResampleNearest(width, height);
 463             break;
 464
 465         case wxIMAGE_QUALITY_BILINEAR:
 466             image = ResampleBilinear(width, height);
 467             break;
 468
 469         case wxIMAGE_QUALITY_BICUBIC:
 470             image = ResampleBicubic(width, height);
 471             break;
 472
 473         case wxIMAGE_QUALITY_BOX_AVERAGE:
 474             image = ResampleBox(width, height);
 475             break;
 476     }
 477
 478     // If the original image has a mask, apply the mask to the new image
 479     if (M_IMGDATA->m_hasMask)
 480     {
 481         image.SetMaskColour( M_IMGDATA->m_maskRed,
 482                             M_IMGDATA->m_maskGreen,
 483                             M_IMGDATA->m_maskBlue );
 484     }
 485
 486     // In case this is a cursor, make sure the hotspot is scaled accordingly:
 487     if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_X) )
 488         image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X,
 489                 (GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_X)*width)/old_width);
 490     if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y) )
 491         image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y,
 492                 (GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_Y)*height)/old_height);
 493
 494     return image;
 495 }
 496
 497 wxImage wxImage::ResampleNearest(int width, int height) const
 498 {
 499     wxImage image;
 500     image.Create( width, height, false );
 501
 502     unsigned char *data = image.GetData();
 503
 504     wxCHECK_MSG( data, image, wxT("unable to create image") );
 505
 506     const unsigned char *source_data = M_IMGDATA->m_data;
 507     unsigned char *target_data = data;
 508     const unsigned char *source_alpha = 0 ;
 509     unsigned char *target_alpha = 0 ;
 510
 511     if ( !M_IMGDATA->m_hasMask )
 512     {
 513         source_alpha = M_IMGDATA->m_alpha ;
 514         if ( source_alpha )
 515         {
 516             image.SetAlpha() ;
 517             target_alpha = image.GetAlpha() ;
 518         }
 519     }
 520
 521     long old_height = M_IMGDATA->m_height,
 522          old_width  = M_IMGDATA->m_width;
 523     long x_delta = (old_width<<16) / width;
 524     long y_delta = (old_height<<16) / height;
 525
 526     unsigned char* dest_pixel = target_data;
 527
 528     long y = 0;
 529     for ( long j = 0; j < height; j++ )
 530     {
 531         const unsigned char* src_line = &source_data[(y>>16)*old_width*3];
 532         const unsigned char* src_alpha_line = source_alpha ? &source_alpha[(y>>16)*old_width] : 0 ;
 533
 534         long x = 0;
 535         for ( long i = 0; i < width; i++ )
 536         {
 537             const unsigned char* src_pixel = &src_line[(x>>16)*3];
 538             const unsigned char* src_alpha_pixel = source_alpha ? &src_alpha_line[(x>>16)] : 0 ;
 539             dest_pixel[0] = src_pixel[0];
 540             dest_pixel[1] = src_pixel[1];
 541             dest_pixel[2] = src_pixel[2];
 542             dest_pixel += 3;
 543             if ( source_alpha )
 544                 *(target_alpha++) = *src_alpha_pixel ;
 545             x += x_delta;
 546         }
 547
 548         y += y_delta;
 549     }
 550
 551     return image;
 552 }
 553
 554 wxImage wxImage::ResampleBox(int width, int height) const
 555 {
 556     // This function implements a simple pre-blur/box averaging method for
 557     // downsampling that gives reasonably smooth results To scale the image
 558     // down we will need to gather a grid of pixels of the size of the scale
 559     // factor in each direction and then do an averaging of the pixels.
 560
 561     wxImage ret_image(width, height, false);
 562
 563     const double scale_factor_x = double(M_IMGDATA->m_width) / width;
 564     const double scale_factor_y = double(M_IMGDATA->m_height) / height;
 565
 566     const int scale_factor_x_2 = (int)(scale_factor_x / 2);
 567     const int scale_factor_y_2 = (int)(scale_factor_y / 2);
 568
 569     const unsigned char* src_data = M_IMGDATA->m_data;
 570     const unsigned char* src_alpha = M_IMGDATA->m_alpha;
 571     unsigned char* dst_data = ret_image.GetData();
 572     unsigned char* dst_alpha = NULL;
 573
 574     if ( src_alpha )
 575     {
 576         ret_image.SetAlpha();
 577         dst_alpha = ret_image.GetAlpha();
 578     }
 579
 580     int averaged_pixels, src_pixel_index;
 581     double sum_r, sum_g, sum_b, sum_a;
 582
 583     for ( int y = 0; y < height; y++ )         // Destination image - Y direction
 584     {
 585         // Source pixel in the Y direction
 586         int src_y = (int)(y * scale_factor_y);
 587
 588         for ( int x = 0; x < width; x++ )      // Destination image - X direction
 589         {
 590             // Source pixel in the X direction
 591             int src_x = (int)(x * scale_factor_x);
 592
 593             // Box of pixels to average
 594             averaged_pixels = 0;
 595             sum_r = sum_g = sum_b = sum_a = 0.0;
 596
 597             for ( int j = int(src_y - scale_factor_y/2.0 + 1), k = j;
 598                   j <= int(src_y + scale_factor_y_2) || j < k + 2;
 599                   j++ )
 600             {
 601                 // We don't care to average pixels that don't exist (edges)
 602                 if ( j < 0 || j > M_IMGDATA->m_height - 1 )
 603                     continue;
 604
 605                 for ( int i = int(src_x - scale_factor_x/2.0 + 1), e = i;
 606                       i <= src_x + scale_factor_x_2 || i < e + 2;
 607                       i++ )
 608                 {
 609                     // Don't average edge pixels
 610                     if ( i < 0 || i > M_IMGDATA->m_width - 1 )
 611                         continue;
 612
 613                     // Calculate the actual index in our source pixels
 614                     src_pixel_index = j * M_IMGDATA->m_width + i;
 615
 616                     sum_r += src_data[src_pixel_index * 3 + 0];
 617                     sum_g += src_data[src_pixel_index * 3 + 1];
 618                     sum_b += src_data[src_pixel_index * 3 + 2];
 619                     if ( src_alpha )
 620                         sum_a += src_alpha[src_pixel_index];
 621
 622                     averaged_pixels++;
 623                 }
 624             }
 625
 626             // Calculate the average from the sum and number of averaged pixels
 627             dst_data[0] = (unsigned char)(sum_r / averaged_pixels);
 628             dst_data[1] = (unsigned char)(sum_g / averaged_pixels);
 629             dst_data[2] = (unsigned char)(sum_b / averaged_pixels);
 630             dst_data += 3;
 631             if ( src_alpha )
 632                 *dst_alpha++ = (unsigned char)(sum_a / averaged_pixels);
 633         }
 634     }
 635
 636     return ret_image;
 637 }
 638
 639 wxImage wxImage::ResampleBilinear(int width, int height) const
 640 {
 641     // This function implements a Bilinear algorithm for resampling.
 642     wxImage ret_image(width, height, false);
 643     const unsigned char* src_data = M_IMGDATA->m_data;
 644     const unsigned char* src_alpha = M_IMGDATA->m_alpha;
 645     unsigned char* dst_data = ret_image.GetData();
 646     unsigned char* dst_alpha = NULL;
 647
 648     if ( src_alpha )
 649     {
 650         ret_image.SetAlpha();
 651         dst_alpha = ret_image.GetAlpha();
 652     }
 653     double HFactor = double(M_IMGDATA->m_height) / height;
 654     double WFactor = double(M_IMGDATA->m_width) / width;
 655
 656     int srcpixymax = M_IMGDATA->m_height - 1;
 657     int srcpixxmax = M_IMGDATA->m_width - 1;
 658
 659     double srcpixy, srcpixy1, srcpixy2, dy, dy1;
 660     double srcpixx, srcpixx1, srcpixx2, dx, dx1;
 661
 662     // initialize alpha values to avoid g++ warnings about possibly
 663     // uninitialized variables
 664     double r1, g1, b1, a1 = 0;
 665     double r2, g2, b2, a2 = 0;
 666
 667     for ( int dsty = 0; dsty < height; dsty++ )
 668     {
 669         // We need to calculate the source pixel to interpolate from - Y-axis
 670         srcpixy = double(dsty) * HFactor;
 671         srcpixy1 = int(srcpixy);
 672         srcpixy2 = ( srcpixy1 == srcpixymax ) ? srcpixy1 : srcpixy1 + 1.0;
 673         dy = srcpixy - (int)srcpixy;
 674         dy1 = 1.0 - dy;
 675
 676
 677         for ( int dstx = 0; dstx < width; dstx++ )
 678         {
 679             // X-axis of pixel to interpolate from
 680             srcpixx = double(dstx) * WFactor;
 681             srcpixx1 = int(srcpixx);
 682             srcpixx2 = ( srcpixx1 == srcpixxmax ) ? srcpixx1 : srcpixx1 + 1.0;
 683             dx = srcpixx - (int)srcpixx;
 684             dx1 = 1.0 - dx;
 685
 686             int x_offset1 = srcpixx1 < 0.0 ? 0 : srcpixx1 > srcpixxmax ? srcpixxmax : (int)srcpixx1;
 687             int x_offset2 = srcpixx2 < 0.0 ? 0 : srcpixx2 > srcpixxmax ? srcpixxmax : (int)srcpixx2;
 688             int y_offset1 = srcpixy1 < 0.0 ? 0 : srcpixy1 > srcpixymax ? srcpixymax : (int)srcpixy1;
 689             int y_offset2 = srcpixy2 < 0.0 ? 0 : srcpixy2 > srcpixymax ? srcpixymax : (int)srcpixy2;
 690
 691             int src_pixel_index00 = y_offset1 * M_IMGDATA->m_width + x_offset1;
 692             int src_pixel_index01 = y_offset1 * M_IMGDATA->m_width + x_offset2;
 693             int src_pixel_index10 = y_offset2 * M_IMGDATA->m_width + x_offset1;
 694             int src_pixel_index11 = y_offset2 * M_IMGDATA->m_width + x_offset2;
 695
 696             // first line
 697             r1 = src_data[src_pixel_index00 * 3 + 0] * dx1 + src_data[src_pixel_index01 * 3 + 0] * dx;
 698             g1 = src_data[src_pixel_index00 * 3 + 1] * dx1 + src_data[src_pixel_index01 * 3 + 1] * dx;
 699             b1 = src_data[src_pixel_index00 * 3 + 2] * dx1 + src_data[src_pixel_index01 * 3 + 2] * dx;
 700             if ( src_alpha )
 701                 a1 = src_alpha[src_pixel_index00] * dx1 + src_alpha[src_pixel_index01] * dx;
 702
 703             // second line
 704             r2 = src_data[src_pixel_index10 * 3 + 0] * dx1 + src_data[src_pixel_index11 * 3 + 0] * dx;
 705             g2 = src_data[src_pixel_index10 * 3 + 1] * dx1 + src_data[src_pixel_index11 * 3 + 1] * dx;
 706             b2 = src_data[src_pixel_index10 * 3 + 2] * dx1 + src_data[src_pixel_index11 * 3 + 2] * dx;
 707             if ( src_alpha )
 708                 a2 = src_alpha[src_pixel_index10] * dx1 + src_alpha[src_pixel_index11] * dx;
 709
 710             // result lines
 711
 712             dst_data[0] = static_cast<unsigned char>(r1 * dy1 + r2 * dy);
 713             dst_data[1] = static_cast<unsigned char>(g1 * dy1 + g2 * dy);
 714             dst_data[2] = static_cast<unsigned char>(b1 * dy1 + b2 * dy);
 715             dst_data += 3;
 716
 717             if ( src_alpha )
 718                 *dst_alpha++ = static_cast<unsigned char>(a1 * dy1 + a2 * dy);
 719         }
 720     }
 721
 722     return ret_image;
 723 }
 724
 725 // The following two local functions are for the B-spline weighting of the
 726 // bicubic sampling algorithm
 727 static inline double spline_cube(double value)
 728 {
 729     return value <= 0.0 ? 0.0 : value * value * value;
 730 }
 731
 732 static inline double spline_weight(double value)
 733 {
 734     return (spline_cube(value + 2) -
 735             4 * spline_cube(value + 1) +
 736             6 * spline_cube(value) -
 737             4 * spline_cube(value - 1)) / 6;
 738 }
 739
 740 // This is the bicubic resampling algorithm
 741 wxImage wxImage::ResampleBicubic(int width, int height) const
 742 {
 743     // This function implements a Bicubic B-Spline algorithm for resampling.
 744     // This method is certainly a little slower than wxImage's default pixel
 745     // replication method, however for most reasonably sized images not being
 746     // upsampled too much on a fairly average CPU this difference is hardly
 747     // noticeable and the results are far more pleasing to look at.
 748     //
 749     // This particular bicubic algorithm does pixel weighting according to a
 750     // B-Spline that basically implements a Gaussian bell-like weighting
 751     // kernel. Because of this method the results may appear a bit blurry when
 752     // upsampling by large factors.  This is basically because a slight
 753     // gaussian blur is being performed to get the smooth look of the upsampled
 754     // image.
 755
 756     // Edge pixels: 3-4 possible solutions
 757     // - (Wrap/tile) Wrap the image, take the color value from the opposite
 758     // side of the image.
 759     // - (Mirror)    Duplicate edge pixels, so that pixel at coordinate (2, n),
 760     // where n is nonpositive, will have the value of (2, 1).
 761     // - (Ignore)    Simply ignore the edge pixels and apply the kernel only to
 762     // pixels which do have all neighbours.
 763     // - (Clamp)     Choose the nearest pixel along the border. This takes the
 764     // border pixels and extends them out to infinity.
 765     //
 766     // NOTE: below the y_offset and x_offset variables are being set for edge
 767     // pixels using the "Mirror" method mentioned above
 768
 769     wxImage ret_image;
 770
 771     ret_image.Create(width, height, false);
 772
 773     const unsigned char* src_data = M_IMGDATA->m_data;
 774     const unsigned char* src_alpha = M_IMGDATA->m_alpha;
 775     unsigned char* dst_data = ret_image.GetData();
 776     unsigned char* dst_alpha = NULL;
 777
 778     if ( src_alpha )
 779     {
 780         ret_image.SetAlpha();
 781         dst_alpha = ret_image.GetAlpha();
 782     }
 783
 784     for ( int dsty = 0; dsty < height; dsty++ )
 785     {
 786         // We need to calculate the source pixel to interpolate from - Y-axis
 787         double srcpixy = double(dsty * M_IMGDATA->m_height) / height;
 788         double dy = srcpixy - (int)srcpixy;
 789
 790         for ( int dstx = 0; dstx < width; dstx++ )
 791         {
 792             // X-axis of pixel to interpolate from
 793             double srcpixx = double(dstx * M_IMGDATA->m_width) / width;
 794             double dx = srcpixx - (int)srcpixx;
 795
 796             // Sums for each color channel
 797             double sum_r = 0, sum_g = 0, sum_b = 0, sum_a = 0;
 798
 799             // Here we actually determine the RGBA values for the destination pixel
 800             for ( int k = -1; k <= 2; k++ )
 801             {
 802                 // Y offset
 803                 int y_offset = srcpixy + k < 0.0
 804                                 ? 0
 805                                 : srcpixy + k >= M_IMGDATA->m_height
 806                                        ? M_IMGDATA->m_height - 1
 807                                        : (int)(srcpixy + k);
 808
 809                 // Loop across the X axis
 810                 for ( int i = -1; i <= 2; i++ )
 811                 {
 812                     // X offset
 813                     int x_offset = srcpixx + i < 0.0
 814                                     ? 0
 815                                     : srcpixx + i >= M_IMGDATA->m_width
 816                                             ? M_IMGDATA->m_width - 1
 817                                             : (int)(srcpixx + i);
 818
 819                     // Calculate the exact position where the source data
 820                     // should be pulled from based on the x_offset and y_offset
 821                     int src_pixel_index = y_offset*M_IMGDATA->m_width + x_offset;
 822
 823                     // Calculate the weight for the specified pixel according
 824                     // to the bicubic b-spline kernel we're using for
 825                     // interpolation
 826                     double
 827                         pixel_weight = spline_weight(i - dx)*spline_weight(k - dy);
 828
 829                     // Create a sum of all velues for each color channel
 830                     // adjusted for the pixel's calculated weight
 831                     sum_r += src_data[src_pixel_index * 3 + 0] * pixel_weight;
 832                     sum_g += src_data[src_pixel_index * 3 + 1] * pixel_weight;
 833                     sum_b += src_data[src_pixel_index * 3 + 2] * pixel_weight;
 834                     if ( src_alpha )
 835                         sum_a += src_alpha[src_pixel_index] * pixel_weight;
 836                 }
 837             }
 838
 839             // Put the data into the destination image.  The summed values are
 840             // of double data type and are rounded here for accuracy
 841             dst_data[0] = (unsigned char)(sum_r + 0.5);
 842             dst_data[1] = (unsigned char)(sum_g + 0.5);
 843             dst_data[2] = (unsigned char)(sum_b + 0.5);
 844             dst_data += 3;
 845
 846             if ( src_alpha )
 847                 *dst_alpha++ = (unsigned char)sum_a;
 848         }
 849     }
 850
 851     return ret_image;
 852 }
 853
 854 // Blur in the horizontal direction
 855 wxImage wxImage::BlurHorizontal(int blurRadius) const
 856 {
 857     wxImage ret_image(MakeEmptyClone());
 858
 859     wxCHECK( ret_image.Ok(), ret_image );
 860
 861     const unsigned char* src_data = M_IMGDATA->m_data;
 862     unsigned char* dst_data = ret_image.GetData();
 863     const unsigned char* src_alpha = M_IMGDATA->m_alpha;
 864     unsigned char* dst_alpha = ret_image.GetAlpha();
 865
 866     // number of pixels we average over
 867     const int blurArea = blurRadius*2 + 1;
 868
 869     // Horizontal blurring algorithm - average all pixels in the specified blur
 870     // radius in the X or horizontal direction
 871     for ( int y = 0; y < M_IMGDATA->m_height; y++ )
 872     {
 873         // Variables used in the blurring algorithm
 874         long sum_r = 0,
 875              sum_g = 0,
 876              sum_b = 0,
 877              sum_a = 0;
 878
 879         long pixel_idx;
 880         const unsigned char *src;
 881         unsigned char *dst;
 882
 883         // Calculate the average of all pixels in the blur radius for the first
 884         // pixel of the row
 885         for ( int kernel_x = -blurRadius; kernel_x <= blurRadius; kernel_x++ )
 886         {
 887             // To deal with the pixels at the start of a row so it's not
 888             // grabbing GOK values from memory at negative indices of the
 889             // image's data or grabbing from the previous row
 890             if ( kernel_x < 0 )
 891                 pixel_idx = y * M_IMGDATA->m_width;
 892             else
 893                 pixel_idx = kernel_x + y * M_IMGDATA->m_width;
 894
 895             src = src_data + pixel_idx*3;
 896             sum_r += src[0];
 897             sum_g += src[1];
 898             sum_b += src[2];
 899             if ( src_alpha )
 900                 sum_a += src_alpha[pixel_idx];
 901         }
 902
 903         dst = dst_data + y * M_IMGDATA->m_width*3;
 904         dst[0] = (unsigned char)(sum_r / blurArea);
 905         dst[1] = (unsigned char)(sum_g / blurArea);
 906         dst[2] = (unsigned char)(sum_b / blurArea);
 907         if ( src_alpha )
 908             dst_alpha[y * M_IMGDATA->m_width] = (unsigned char)(sum_a / blurArea);
 909
 910         // Now average the values of the rest of the pixels by just moving the
 911         // blur radius box along the row
 912         for ( int x = 1; x < M_IMGDATA->m_width; x++ )
 913         {
 914             // Take care of edge pixels on the left edge by essentially
 915             // duplicating the edge pixel
 916             if ( x - blurRadius - 1 < 0 )
 917                 pixel_idx = y * M_IMGDATA->m_width;
 918             else
 919                 pixel_idx = (x - blurRadius - 1) + y * M_IMGDATA->m_width;
 920
 921             // Subtract the value of the pixel at the left side of the blur
 922             // radius box
 923             src = src_data + pixel_idx*3;
 924             sum_r -= src[0];
 925             sum_g -= src[1];
 926             sum_b -= src[2];
 927             if ( src_alpha )
 928                 sum_a -= src_alpha[pixel_idx];
 929
 930             // Take care of edge pixels on the right edge
 931             if ( x + blurRadius > M_IMGDATA->m_width - 1 )
 932                 pixel_idx = M_IMGDATA->m_width - 1 + y * M_IMGDATA->m_width;
 933             else
 934                 pixel_idx = x + blurRadius + y * M_IMGDATA->m_width;
 935
 936             // Add the value of the pixel being added to the end of our box
 937             src = src_data + pixel_idx*3;
 938             sum_r += src[0];
 939             sum_g += src[1];
 940             sum_b += src[2];
 941             if ( src_alpha )
 942                 sum_a += src_alpha[pixel_idx];
 943
 944             // Save off the averaged data
 945             dst = dst_data + x*3 + y*M_IMGDATA->m_width*3;
 946             dst[0] = (unsigned char)(sum_r / blurArea);
 947             dst[1] = (unsigned char)(sum_g / blurArea);
 948             dst[2] = (unsigned char)(sum_b / blurArea);
 949             if ( src_alpha )
 950                 dst_alpha[x + y * M_IMGDATA->m_width] = (unsigned char)(sum_a / blurArea);
 951         }
 952     }
 953
 954     return ret_image;
 955 }
 956
 957 // Blur in the vertical direction
 958 wxImage wxImage::BlurVertical(int blurRadius) const
 959 {
 960     wxImage ret_image(MakeEmptyClone());
 961
 962     wxCHECK( ret_image.Ok(), ret_image );
 963
 964     const unsigned char* src_data = M_IMGDATA->m_data;
 965     unsigned char* dst_data = ret_image.GetData();
 966     const unsigned char* src_alpha = M_IMGDATA->m_alpha;
 967     unsigned char* dst_alpha = ret_image.GetAlpha();
 968
 969     // number of pixels we average over
 970     const int blurArea = blurRadius*2 + 1;
 971
 972     // Vertical blurring algorithm - same as horizontal but switched the
 973     // opposite direction
 974     for ( int x = 0; x < M_IMGDATA->m_width; x++ )
 975     {
 976         // Variables used in the blurring algorithm
 977         long sum_r = 0,
 978              sum_g = 0,
 979              sum_b = 0,
 980              sum_a = 0;
 981
 982         long pixel_idx;
 983         const unsigned char *src;
 984         unsigned char *dst;
 985
 986         // Calculate the average of all pixels in our blur radius box for the
 987         // first pixel of the column
 988         for ( int kernel_y = -blurRadius; kernel_y <= blurRadius; kernel_y++ )
 989         {
 990             // To deal with the pixels at the start of a column so it's not
 991             // grabbing GOK values from memory at negative indices of the
 992             // image's data or grabbing from the previous column
 993             if ( kernel_y < 0 )
 994                 pixel_idx = x;
 995             else
 996                 pixel_idx = x + kernel_y * M_IMGDATA->m_width;
 997
 998             src = src_data + pixel_idx*3;
 999             sum_r += src[0];
1000             sum_g += src[1];
1001             sum_b += src[2];
1002             if ( src_alpha )
1003                 sum_a += src_alpha[pixel_idx];
1004         }
1005
1006         dst = dst_data + x*3;
1007         dst[0] = (unsigned char)(sum_r / blurArea);
1008         dst[1] = (unsigned char)(sum_g / blurArea);
1009         dst[2] = (unsigned char)(sum_b / blurArea);
1010         if ( src_alpha )
1011             dst_alpha[x] = (unsigned char)(sum_a / blurArea);
1012
1013         // Now average the values of the rest of the pixels by just moving the
1014         // box along the column from top to bottom
1015         for ( int y = 1; y < M_IMGDATA->m_height; y++ )
1016         {
1017             // Take care of pixels that would be beyond the top edge by
1018             // duplicating the top edge pixel for the column
1019             if ( y - blurRadius - 1 < 0 )
1020                 pixel_idx = x;
1021             else
1022                 pixel_idx = x + (y - blurRadius - 1) * M_IMGDATA->m_width;
1023
1024             // Subtract the value of the pixel at the top of our blur radius box
1025             src = src_data + pixel_idx*3;
1026             sum_r -= src[0];
1027             sum_g -= src[1];
1028             sum_b -= src[2];
1029             if ( src_alpha )
1030                 sum_a -= src_alpha[pixel_idx];
1031
1032             // Take care of the pixels that would be beyond the bottom edge of
1033             // the image similar to the top edge
1034             if ( y + blurRadius > M_IMGDATA->m_height - 1 )
1035                 pixel_idx = x + (M_IMGDATA->m_height - 1) * M_IMGDATA->m_width;
1036             else
1037                 pixel_idx = x + (blurRadius + y) * M_IMGDATA->m_width;
1038
1039             // Add the value of the pixel being added to the end of our box
1040             src = src_data + pixel_idx*3;
1041             sum_r += src[0];
1042             sum_g += src[1];
1043             sum_b += src[2];
1044             if ( src_alpha )
1045                 sum_a += src_alpha[pixel_idx];
1046
1047             // Save off the averaged data
1048             dst = dst_data + (x + y * M_IMGDATA->m_width) * 3;
1049             dst[0] = (unsigned char)(sum_r / blurArea);
1050             dst[1] = (unsigned char)(sum_g / blurArea);
1051             dst[2] = (unsigned char)(sum_b / blurArea);
1052             if ( src_alpha )
1053                 dst_alpha[x + y * M_IMGDATA->m_width] = (unsigned char)(sum_a / blurArea);
1054         }
1055     }
1056
1057     return ret_image;
1058 }
1059
1060 // The new blur function
1061 wxImage wxImage::Blur(int blurRadius) const
1062 {
1063     wxImage ret_image;
1064     ret_image.Create(M_IMGDATA->m_width, M_IMGDATA->m_height, false);
1065
1066     // Blur the image in each direction
1067     ret_image = BlurHorizontal(blurRadius);
1068     ret_image = ret_image.BlurVertical(blurRadius);
1069
1070     return ret_image;
1071 }
1072
1073 wxImage wxImage::Rotate90( bool clockwise ) const
1074 {
1075     wxImage image(MakeEmptyClone(Clone_SwapOrientation));
1076
1077     wxCHECK( image.Ok(), image );
1078
1079     long height = M_IMGDATA->m_height;
1080     long width  = M_IMGDATA->m_width;
1081
1082     if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_X) )
1083     {
1084         int hot_x = GetOptionInt( wxIMAGE_OPTION_CUR_HOTSPOT_X );
1085         image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y,
1086                         clockwise ? hot_x : width - 1 - hot_x);
1087     }
1088
1089     if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y) )
1090     {
1091         int hot_y = GetOptionInt( wxIMAGE_OPTION_CUR_HOTSPOT_Y );
1092         image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X,
1093                         clockwise ? height - 1 - hot_y : hot_y);
1094     }
1095
1096     unsigned char *data = image.GetData();
1097     unsigned char *target_data;
1098
1099     // we rotate the image in 21-pixel (63-byte) wide strips
1100     // to make better use of cpu cache - memory transfers
1101     // (note: while much better than single-pixel "strips",
1102     //  our vertical strips will still generally straddle 64-byte cachelines)
1103     for (long ii = 0; ii < width; )
1104     {
1105         long next_ii = wxMin(ii + 21, width);
1106
1107         for (long j = 0; j < height; j++)
1108         {
1109             const unsigned char *source_data
1110                                      = M_IMGDATA->m_data + (j*width + ii)*3;
1111
1112             for (long i = ii; i < next_ii; i++)
1113             {
1114                 if ( clockwise )
1115                 {
1116                     target_data = data + ((i + 1)*height - j - 1)*3;
1117                 }
1118                 else
1119                 {
1120                     target_data = data + (height*(width - 1 - i) + j)*3;
1121                 }
1122                 memcpy( target_data, source_data, 3 );
1123                 source_data += 3;
1124             }
1125         }
1126
1127         ii = next_ii;
1128     }
1129
1130     const unsigned char *source_alpha = M_IMGDATA->m_alpha;
1131
1132     if ( source_alpha )
1133     {
1134         unsigned char *alpha_data = image.GetAlpha();
1135         unsigned char *target_alpha = 0 ;
1136
1137         for (long ii = 0; ii < width; )
1138         {
1139             long next_ii = wxMin(ii + 64, width);
1140
1141             for (long j = 0; j < height; j++)
1142             {
1143                 source_alpha = M_IMGDATA->m_alpha + j*width + ii;
1144
1145                 for (long i = ii; i < next_ii; i++)
1146                 {
1147                     if ( clockwise )
1148                     {
1149                         target_alpha = alpha_data + (i+1)*height - j - 1;
1150                     }
1151                     else
1152                     {
1153                         target_alpha = alpha_data + height*(width - i - 1) + j;
1154                     }
1155
1156                     *target_alpha = *source_alpha++;
1157                 }
1158             }
1159
1160             ii = next_ii;
1161         }
1162     }
1163
1164     return image;
1165 }
1166
1167 wxImage wxImage::Rotate180() const
1168 {
1169     wxImage image(MakeEmptyClone());
1170
1171     wxCHECK( image.Ok(), image );
1172
1173     long height = M_IMGDATA->m_height;
1174     long width  = M_IMGDATA->m_width;
1175
1176     if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_X) )
1177     {
1178         image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X,
1179                         width - 1 - GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_X));
1180     }
1181
1182     if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y) )
1183     {
1184         image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y,
1185                         height - 1 - GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_Y));
1186     }
1187
1188     unsigned char *data = image.GetData();
1189     unsigned char *alpha = image.GetAlpha();
1190     const unsigned char *source_data = M_IMGDATA->m_data;
1191     unsigned char *target_data = data + width * height * 3;
1192
1193     for (long j = 0; j < height; j++)
1194     {
1195         for (long i = 0; i < width; i++)
1196         {
1197             target_data -= 3;
1198             memcpy( target_data, source_data, 3 );
1199             source_data += 3;
1200         }
1201     }
1202
1203     if ( alpha )
1204     {
1205         const unsigned char *src_alpha = M_IMGDATA->m_alpha;
1206         unsigned char *dest_alpha = alpha + width * height;
1207
1208         for (long j = 0; j < height; ++j)
1209         {
1210             for (long i = 0; i < width; ++i)
1211             {
1212                 *(--dest_alpha) = *(src_alpha++);
1213             }
1214         }
1215     }
1216
1217     return image;
1218 }
1219
1220 wxImage wxImage::Mirror( bool horizontally ) const
1221 {
1222     wxImage image(MakeEmptyClone());
1223
1224     wxCHECK( image.Ok(), image );
1225
1226     long height = M_IMGDATA->m_height;
1227     long width  = M_IMGDATA->m_width;
1228
1229     unsigned char *data = image.GetData();
1230     unsigned char *alpha = image.GetAlpha();
1231     const unsigned char *source_data = M_IMGDATA->m_data;
1232     unsigned char *target_data;
1233
1234     if (horizontally)
1235     {
1236         for (long j = 0; j < height; j++)
1237         {
1238             data += width*3;
1239             target_data = data-3;
1240             for (long i = 0; i < width; i++)
1241             {
1242                 memcpy( target_data, source_data, 3 );
1243                 source_data += 3;
1244                 target_data -= 3;
1245             }
1246         }
1247
1248         if (alpha != NULL)
1249         {
1250             // src_alpha starts at the first pixel and increases by 1 after each step
1251             // (a step here is the copy of the alpha value of one pixel)
1252             const unsigned char *src_alpha = M_IMGDATA->m_alpha;
1253             // dest_alpha starts just beyond the first line, decreases before each step,
1254             // and after each line is finished, increases by 2 widths (skipping the line
1255             // just copied and the line that will be copied next)
1256             unsigned char *dest_alpha = alpha + width;
1257
1258             for (long jj = 0; jj < height; ++jj)
1259             {
1260                 for (long i = 0; i < width; ++i) {
1261                     *(--dest_alpha) = *(src_alpha++); // copy one pixel
1262                 }
1263                 dest_alpha += 2 * width; // advance beyond the end of the next line
1264             }
1265         }
1266     }
1267     else
1268     {
1269         for (long i = 0; i < height; i++)
1270         {
1271             target_data = data + 3*width*(height-1-i);
1272             memcpy( target_data, source_data, (size_t)3*width );
1273             source_data += 3*width;
1274         }
1275
1276         if ( alpha )
1277         {
1278             // src_alpha starts at the first pixel and increases by 1 width after each step
1279             // (a step here is the copy of the alpha channel of an entire line)
1280             const unsigned char *src_alpha = M_IMGDATA->m_alpha;
1281             // dest_alpha starts just beyond the last line (beyond the whole image)
1282             // and decreases by 1 width before each step
1283             unsigned char *dest_alpha = alpha + width * height;
1284
1285             for (long jj = 0; jj < height; ++jj)
1286             {
1287                 dest_alpha -= width;
1288                 memcpy( dest_alpha, src_alpha, (size_t)width );
1289                 src_alpha += width;
1290             }
1291         }
1292     }
1293
1294     return image;
1295 }
1296
1297 wxImage wxImage::GetSubImage( const wxRect &rect ) const
1298 {
1299     wxImage image;
1300
1301     wxCHECK_MSG( Ok(), image, wxT("invalid image") );
1302
1303     wxCHECK_MSG( (rect.GetLeft()>=0) && (rect.GetTop()>=0) &&
1304                  (rect.GetRight()<=GetWidth()) && (rect.GetBottom()<=GetHeight()),
1305                  image, wxT("invalid subimage size") );
1306
1307     const int subwidth = rect.GetWidth();
1308     const int subheight = rect.GetHeight();
1309
1310     image.Create( subwidth, subheight, false );
1311
1312     const unsigned char *src_data = GetData();
1313     const unsigned char *src_alpha = M_IMGDATA->m_alpha;
1314     unsigned char *subdata = image.GetData();
1315     unsigned char *subalpha = NULL;
1316
1317     wxCHECK_MSG( subdata, image, wxT("unable to create image") );
1318
1319     if ( src_alpha ) {
1320         image.SetAlpha();
1321         subalpha = image.GetAlpha();
1322         wxCHECK_MSG( subalpha, image, wxT("unable to create alpha channel"));
1323     }
1324
1325     if (M_IMGDATA->m_hasMask)
1326         image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
1327
1328     const int width = GetWidth();
1329     const int pixsoff = rect.GetLeft() + width * rect.GetTop();
1330
1331     src_data += 3 * pixsoff;
1332     src_alpha += pixsoff; // won't be used if was NULL, so this is ok
1333
1334     for (long j = 0; j < subheight; ++j)
1335     {
1336         memcpy( subdata, src_data, 3 * subwidth );
1337         subdata += 3 * subwidth;
1338         src_data += 3 * width;
1339         if (subalpha != NULL) {
1340             memcpy( subalpha, src_alpha, subwidth );
1341             subalpha += subwidth;
1342             src_alpha += width;
1343         }
1344     }
1345
1346     return image;
1347 }
1348
1349 wxImage wxImage::Size( const wxSize& size, const wxPoint& pos,
1350                        int r_, int g_, int b_ ) const
1351 {
1352     wxImage image;
1353
1354     wxCHECK_MSG( Ok(), image, wxT("invalid image") );
1355     wxCHECK_MSG( (size.GetWidth() > 0) && (size.GetHeight() > 0), image, wxT("invalid size") );
1356
1357     int width = GetWidth(), height = GetHeight();
1358     image.Create(size.GetWidth(), size.GetHeight(), false);
1359
1360     unsigned char r = (unsigned char)r_;
1361     unsigned char g = (unsigned char)g_;
1362     unsigned char b = (unsigned char)b_;
1363     if ((r_ == -1) && (g_ == -1) && (b_ == -1))
1364     {
1365         GetOrFindMaskColour( &r, &g, &b );
1366         image.SetMaskColour(r, g, b);
1367     }
1368
1369     image.SetRGB(wxRect(), r, g, b);
1370
1371     // we have two coordinate systems:
1372     // source:     starting at 0,0 of source image
1373     // destination starting at 0,0 of destination image
1374     // Documentation says:
1375     // "The image is pasted into a new image [...] at the position pos relative
1376     // to the upper left of the new image." this means the transition rule is:
1377     // "dest coord" = "source coord" + pos;
1378
1379     // calculate the intersection using source coordinates:
1380     wxRect srcRect(0, 0, width, height);
1381     wxRect dstRect(-pos, size);
1382
1383     srcRect.Intersect(dstRect);
1384
1385     if (!srcRect.IsEmpty())
1386     {
1387         // insertion point is needed in destination coordinates.
1388         // NB: it is not always "pos"!
1389         wxPoint ptInsert = srcRect.GetTopLeft() + pos;
1390
1391         if ((srcRect.GetWidth() == width) && (srcRect.GetHeight() == height))
1392             image.Paste(*this, ptInsert.x, ptInsert.y);
1393         else
1394             image.Paste(GetSubImage(srcRect), ptInsert.x, ptInsert.y);
1395     }
1396
1397     return image;
1398 }
1399
1400 void wxImage::Paste( const wxImage &image, int x, int y )
1401 {
1402     wxCHECK_RET( Ok(), wxT("invalid image") );
1403     wxCHECK_RET( image.Ok(), wxT("invalid image") );
1404
1405     AllocExclusive();
1406
1407     int xx = 0;
1408     int yy = 0;
1409     int width = image.GetWidth();
1410     int height = image.GetHeight();
1411
1412     if (x < 0)
1413     {
1414         xx = -x;
1415         width += x;
1416     }
1417     if (y < 0)
1418     {
1419         yy = -y;
1420         height += y;
1421     }
1422
1423     if ((x+xx)+width > M_IMGDATA->m_width)
1424         width = M_IMGDATA->m_width - (x+xx);
1425     if ((y+yy)+height > M_IMGDATA->m_height)
1426         height = M_IMGDATA->m_height - (y+yy);
1427
1428     if (width < 1) return;
1429     if (height < 1) return;
1430
1431     if ((!HasMask() && !image.HasMask()) ||
1432         (HasMask() && !image.HasMask()) ||
1433        ((HasMask() && image.HasMask() &&
1434          (GetMaskRed()==image.GetMaskRed()) &&
1435          (GetMaskGreen()==image.GetMaskGreen()) &&
1436          (GetMaskBlue()==image.GetMaskBlue()))))
1437     {
1438         const unsigned char* source_data = image.GetData() + 3*(xx + yy*image.GetWidth());
1439         int source_step = image.GetWidth()*3;
1440
1441         unsigned char* target_data = GetData() + 3*((x+xx) + (y+yy)*M_IMGDATA->m_width);
1442         int target_step = M_IMGDATA->m_width*3;
1443         for (int j = 0; j < height; j++)
1444         {
1445             memcpy( target_data, source_data, width*3 );
1446             source_data += source_step;
1447             target_data += target_step;
1448         }
1449     }
1450
1451     // Copy over the alpha channel from the original image
1452     if ( image.HasAlpha() )
1453     {
1454         if ( !HasAlpha() )
1455             InitAlpha();
1456
1457         const unsigned char* source_data = image.GetAlpha() + xx + yy*image.GetWidth();
1458         int source_step = image.GetWidth();
1459
1460         unsigned char* target_data = GetAlpha() + (x+xx) + (y+yy)*M_IMGDATA->m_width;
1461         int target_step = M_IMGDATA->m_width;
1462
1463         for (int j = 0; j < height; j++,
1464                                     source_data += source_step,
1465                                     target_data += target_step)
1466         {
1467             memcpy( target_data, source_data, width );
1468         }
1469     }
1470
1471     if (!HasMask() && image.HasMask())
1472     {
1473         unsigned char r = image.GetMaskRed();
1474         unsigned char g = image.GetMaskGreen();
1475         unsigned char b = image.GetMaskBlue();
1476
1477         const unsigned char* source_data = image.GetData() + 3*(xx + yy*image.GetWidth());
1478         int source_step = image.GetWidth()*3;
1479
1480         unsigned char* target_data = GetData() + 3*((x+xx) + (y+yy)*M_IMGDATA->m_width);
1481         int target_step = M_IMGDATA->m_width*3;
1482
1483         for (int j = 0; j < height; j++)
1484         {
1485             for (int i = 0; i < width*3; i+=3)
1486             {
1487                 if ((source_data[i]   != r) ||
1488                     (source_data[i+1] != g) ||
1489                     (source_data[i+2] != b))
1490                 {
1491                     memcpy( target_data+i, source_data+i, 3 );
1492                 }
1493             }
1494             source_data += source_step;
1495             target_data += target_step;
1496         }
1497     }
1498 }
1499
1500 void wxImage::Replace( unsigned char r1, unsigned char g1, unsigned char b1,
1501                        unsigned char r2, unsigned char g2, unsigned char b2 )
1502 {
1503     wxCHECK_RET( Ok(), wxT("invalid image") );
1504
1505     AllocExclusive();
1506
1507     unsigned char *data = GetData();
1508
1509     const int w = GetWidth();
1510     const int h = GetHeight();
1511
1512     for (int j = 0; j < h; j++)
1513         for (int i = 0; i < w; i++)
1514         {
1515             if ((data[0] == r1) && (data[1] == g1) && (data[2] == b1))
1516             {
1517                 data[0] = r2;
1518                 data[1] = g2;
1519                 data[2] = b2;
1520             }
1521             data += 3;
1522         }
1523 }
1524
1525 wxImage wxImage::ConvertToGreyscale(void) const
1526 {
1527     return ConvertToGreyscale(0.299, 0.587, 0.114);
1528 }
1529
1530 wxImage wxImage::ConvertToGreyscale(double weight_r, double weight_g, double weight_b) const
1531 {
1532     wxImage image(MakeEmptyClone());
1533
1534     wxCHECK( image.Ok(), image );
1535
1536     const unsigned char *src = M_IMGDATA->m_data;
1537     unsigned char *dest = image.GetData();
1538
1539     const bool hasMask = M_IMGDATA->m_hasMask;
1540     const unsigned char maskRed = M_IMGDATA->m_maskRed;
1541     const unsigned char maskGreen = M_IMGDATA->m_maskGreen;
1542     const unsigned char maskBlue = M_IMGDATA->m_maskBlue;
1543
1544     const long size = M_IMGDATA->m_width * M_IMGDATA->m_height;
1545     for ( long i = 0; i < size; i++, src += 3, dest += 3 )
1546     {
1547         memcpy(dest, src, 3);
1548         // only modify non-masked pixels
1549         if ( !hasMask || src[0] != maskRed || src[1] != maskGreen || src[2] != maskBlue )
1550         {
1551             wxColour::MakeGrey(dest + 0, dest + 1, dest + 2, weight_r, weight_g, weight_b);
1552         }
1553     }
1554
1555     // copy the alpha channel, if any
1556     if ( image.HasAlpha() )
1557     {
1558         memcpy( image.GetAlpha(), GetAlpha(), GetWidth() * GetHeight() );
1559     }
1560
1561     return image;
1562 }
1563
1564 wxImage wxImage::ConvertToMono( unsigned char r, unsigned char g, unsigned char b ) const
1565 {
1566     wxImage image;
1567
1568     wxCHECK_MSG( Ok(), image, wxT("invalid image") );
1569
1570     image.Create( M_IMGDATA->m_width, M_IMGDATA->m_height, false );
1571
1572     unsigned char *data = image.GetData();
1573
1574     wxCHECK_MSG( data, image, wxT("unable to create image") );
1575
1576     if (M_IMGDATA->m_hasMask)
1577     {
1578         if (M_IMGDATA->m_maskRed == r && M_IMGDATA->m_maskGreen == g &&
1579                                          M_IMGDATA->m_maskBlue == b)
1580             image.SetMaskColour( 255, 255, 255 );
1581         else
1582             image.SetMaskColour( 0, 0, 0 );
1583     }
1584
1585     long size = M_IMGDATA->m_height * M_IMGDATA->m_width;
1586
1587     unsigned char *srcd = M_IMGDATA->m_data;
1588     unsigned char *tard = image.GetData();
1589
1590     for ( long i = 0; i < size; i++, srcd += 3, tard += 3 )
1591     {
1592         bool on = (srcd[0] == r) && (srcd[1] == g) && (srcd[2] == b);
1593         wxColourBase::MakeMono(tard + 0, tard + 1, tard + 2, on);
1594     }
1595
1596     return image;
1597 }
1598
1599 wxImage wxImage::ConvertToDisabled(unsigned char brightness) const
1600 {
1601     wxImage image = *this;
1602
1603     unsigned char mr = image.GetMaskRed();
1604     unsigned char mg = image.GetMaskGreen();
1605     unsigned char mb = image.GetMaskBlue();
1606
1607     int width = image.GetWidth();
1608     int height = image.GetHeight();
1609     bool has_mask = image.HasMask();
1610
1611     for (int y = height-1; y >= 0; --y)
1612     {
1613         for (int x = width-1; x >= 0; --x)
1614         {
1615             unsigned char* data = image.GetData() + (y*(width*3))+(x*3);
1616             unsigned char* r = data;
1617             unsigned char* g = data+1;
1618             unsigned char* b = data+2;
1619
1620             if (has_mask && (*r == mr) && (*g == mg) && (*b == mb))
1621                 continue;
1622
1623             wxColour::MakeDisabled(r, g, b, brightness);
1624         }
1625     }
1626     return image;
1627 }
1628
1629 int wxImage::GetWidth() const
1630 {
1631     wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
1632
1633     return M_IMGDATA->m_width;
1634 }
1635
1636 int wxImage::GetHeight() const
1637 {
1638     wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
1639
1640     return M_IMGDATA->m_height;
1641 }
1642
1643 wxBitmapType wxImage::GetType() const
1644 {
1645     wxCHECK_MSG( IsOk(), wxBITMAP_TYPE_INVALID, wxT("invalid image") );
1646
1647     return M_IMGDATA->m_type;
1648 }
1649
1650 void wxImage::SetType(wxBitmapType type)
1651 {
1652     wxCHECK_RET( IsOk(), "must create the image before setting its type");
1653
1654     // type can be wxBITMAP_TYPE_INVALID to reset the image type to default
1655     wxASSERT_MSG( type != wxBITMAP_TYPE_MAX, "invalid bitmap type" );
1656
1657     M_IMGDATA->m_type = type;
1658 }
1659
1660 long wxImage::XYToIndex(int x, int y) const
1661 {
1662     if ( Ok() &&
1663             x >= 0 && y >= 0 &&
1664                 x < M_IMGDATA->m_width && y < M_IMGDATA->m_height )
1665     {
1666         return y*M_IMGDATA->m_width + x;
1667     }
1668
1669     return -1;
1670 }
1671
1672 void wxImage::SetRGB( int x, int y, unsigned char r, unsigned char g, unsigned char b )
1673 {
1674     long pos = XYToIndex(x, y);
1675     wxCHECK_RET( pos != -1, wxT("invalid image coordinates") );
1676
1677     AllocExclusive();
1678
1679     pos *= 3;
1680
1681     M_IMGDATA->m_data[ pos   ] = r;
1682     M_IMGDATA->m_data[ pos+1 ] = g;
1683     M_IMGDATA->m_data[ pos+2 ] = b;
1684 }
1685
1686 void wxImage::SetRGB( const wxRect& rect_, unsigned char r, unsigned char g, unsigned char b )
1687 {
1688     wxCHECK_RET( Ok(), wxT("invalid image") );
1689
1690     AllocExclusive();
1691
1692     wxRect rect(rect_);
1693     wxRect imageRect(0, 0, GetWidth(), GetHeight());
1694     if ( rect == wxRect() )
1695     {
1696         rect = imageRect;
1697     }
1698     else
1699     {
1700         wxCHECK_RET( imageRect.Contains(rect.GetTopLeft()) &&
1701                      imageRect.Contains(rect.GetBottomRight()),
1702                      wxT("invalid bounding rectangle") );
1703     }
1704
1705     int x1 = rect.GetLeft(),
1706         y1 = rect.GetTop(),
1707         x2 = rect.GetRight() + 1,
1708         y2 = rect.GetBottom() + 1;
1709
1710     unsigned char *data wxDUMMY_INITIALIZE(NULL);
1711     int x, y, width = GetWidth();
1712     for (y = y1; y < y2; y++)
1713     {
1714         data = M_IMGDATA->m_data + (y*width + x1)*3;
1715         for (x = x1; x < x2; x++)
1716         {
1717             *data++ = r;
1718             *data++ = g;
1719             *data++ = b;
1720         }
1721     }
1722 }
1723
1724 unsigned char wxImage::GetRed( int x, int y ) const
1725 {
1726     long pos = XYToIndex(x, y);
1727     wxCHECK_MSG( pos != -1, 0, wxT("invalid image coordinates") );
1728
1729     pos *= 3;
1730
1731     return M_IMGDATA->m_data[pos];
1732 }
1733
1734 unsigned char wxImage::GetGreen( int x, int y ) const
1735 {
1736     long pos = XYToIndex(x, y);
1737     wxCHECK_MSG( pos != -1, 0, wxT("invalid image coordinates") );
1738
1739     pos *= 3;
1740
1741     return M_IMGDATA->m_data[pos+1];
1742 }
1743
1744 unsigned char wxImage::GetBlue( int x, int y ) const
1745 {
1746     long pos = XYToIndex(x, y);
1747     wxCHECK_MSG( pos != -1, 0, wxT("invalid image coordinates") );
1748
1749     pos *= 3;
1750
1751     return M_IMGDATA->m_data[pos+2];
1752 }
1753
1754 bool wxImage::IsOk() const
1755 {
1756     // image of 0 width or height can't be considered ok - at least because it
1757     // causes crashes in ConvertToBitmap() if we don't catch it in time
1758     wxImageRefData *data = M_IMGDATA;
1759     return data && data->m_ok && data->m_width && data->m_height;
1760 }
1761
1762 unsigned char *wxImage::GetData() const
1763 {
1764     wxCHECK_MSG( Ok(), (unsigned char *)NULL, wxT("invalid image") );
1765
1766     return M_IMGDATA->m_data;
1767 }
1768
1769 void wxImage::SetData( unsigned char *data, bool static_data  )
1770 {
1771     wxCHECK_RET( Ok(), wxT("invalid image") );
1772
1773     wxImageRefData *newRefData = new wxImageRefData();
1774
1775     newRefData->m_width = M_IMGDATA->m_width;
1776     newRefData->m_height = M_IMGDATA->m_height;
1777     newRefData->m_data = data;
1778     newRefData->m_ok = true;
1779     newRefData->m_maskRed = M_IMGDATA->m_maskRed;
1780     newRefData->m_maskGreen = M_IMGDATA->m_maskGreen;
1781     newRefData->m_maskBlue = M_IMGDATA->m_maskBlue;
1782     newRefData->m_hasMask = M_IMGDATA->m_hasMask;
1783     newRefData->m_static = static_data;
1784
1785     UnRef();
1786
1787     m_refData = newRefData;
1788 }
1789
1790 void wxImage::SetData( unsigned char *data, int new_width, int new_height, bool static_data )
1791 {
1792     wxImageRefData *newRefData = new wxImageRefData();
1793
1794     if (m_refData)
1795     {
1796         newRefData->m_width = new_width;
1797         newRefData->m_height = new_height;
1798         newRefData->m_data = data;
1799         newRefData->m_ok = true;
1800         newRefData->m_maskRed = M_IMGDATA->m_maskRed;
1801         newRefData->m_maskGreen = M_IMGDATA->m_maskGreen;
1802         newRefData->m_maskBlue = M_IMGDATA->m_maskBlue;
1803         newRefData->m_hasMask = M_IMGDATA->m_hasMask;
1804     }
1805     else
1806     {
1807         newRefData->m_width = new_width;
1808         newRefData->m_height = new_height;
1809         newRefData->m_data = data;
1810         newRefData->m_ok = true;
1811     }
1812     newRefData->m_static = static_data;
1813
1814     UnRef();
1815
1816     m_refData = newRefData;
1817 }
1818
1819 // ----------------------------------------------------------------------------
1820 // alpha channel support
1821 // ----------------------------------------------------------------------------
1822
1823 void wxImage::SetAlpha(int x, int y, unsigned char alpha)
1824 {
1825     wxCHECK_RET( HasAlpha(), wxT("no alpha channel") );
1826
1827     long pos = XYToIndex(x, y);
1828     wxCHECK_RET( pos != -1, wxT("invalid image coordinates") );
1829
1830     AllocExclusive();
1831
1832     M_IMGDATA->m_alpha[pos] = alpha;
1833 }
1834
1835 unsigned char wxImage::GetAlpha(int x, int y) const
1836 {
1837     wxCHECK_MSG( HasAlpha(), 0, wxT("no alpha channel") );
1838
1839     long pos = XYToIndex(x, y);
1840     wxCHECK_MSG( pos != -1, 0, wxT("invalid image coordinates") );
1841
1842     return M_IMGDATA->m_alpha[pos];
1843 }
1844
1845 bool
1846 wxImage::ConvertColourToAlpha(unsigned char r, unsigned char g, unsigned char b)
1847 {
1848     SetAlpha(NULL);
1849
1850     const int w = M_IMGDATA->m_width;
1851     const int h = M_IMGDATA->m_height;
1852
1853     unsigned char *alpha = GetAlpha();
1854     unsigned char *data = GetData();
1855
1856     for ( int y = 0; y < h; y++ )
1857     {
1858         for ( int x = 0; x < w; x++ )
1859         {
1860             *alpha++ = *data;
1861             *data++ = r;
1862             *data++ = g;
1863             *data++ = b;
1864         }
1865     }
1866
1867     return true;
1868 }
1869
1870 void wxImage::SetAlpha( unsigned char *alpha, bool static_data )
1871 {
1872     wxCHECK_RET( Ok(), wxT("invalid image") );
1873
1874     AllocExclusive();
1875
1876     if ( !alpha )
1877     {
1878         alpha = (unsigned char *)malloc(M_IMGDATA->m_width*M_IMGDATA->m_height);
1879     }
1880
1881     if( !M_IMGDATA->m_staticAlpha )
1882         free(M_IMGDATA->m_alpha);
1883
1884     M_IMGDATA->m_alpha = alpha;
1885     M_IMGDATA->m_staticAlpha = static_data;
1886 }
1887
1888 unsigned char *wxImage::GetAlpha() const
1889 {
1890     wxCHECK_MSG( Ok(), (unsigned char *)NULL, wxT("invalid image") );
1891
1892     return M_IMGDATA->m_alpha;
1893 }
1894
1895 void wxImage::InitAlpha()
1896 {
1897     wxCHECK_RET( !HasAlpha(), wxT("image already has an alpha channel") );
1898
1899     // initialize memory for alpha channel
1900     SetAlpha();
1901
1902     unsigned char *alpha = M_IMGDATA->m_alpha;
1903     const size_t lenAlpha = M_IMGDATA->m_width * M_IMGDATA->m_height;
1904
1905     if ( HasMask() )
1906     {
1907         // use the mask to initialize the alpha channel.
1908         const unsigned char * const alphaEnd = alpha + lenAlpha;
1909
1910         const unsigned char mr = M_IMGDATA->m_maskRed;
1911         const unsigned char mg = M_IMGDATA->m_maskGreen;
1912         const unsigned char mb = M_IMGDATA->m_maskBlue;
1913         for ( unsigned char *src = M_IMGDATA->m_data;
1914               alpha < alphaEnd;
1915               src += 3, alpha++ )
1916         {
1917             *alpha = (src[0] == mr && src[1] == mg && src[2] == mb)
1918                             ? wxIMAGE_ALPHA_TRANSPARENT
1919                             : wxIMAGE_ALPHA_OPAQUE;
1920         }
1921
1922         M_IMGDATA->m_hasMask = false;
1923     }
1924     else // no mask
1925     {
1926         // make the image fully opaque
1927         memset(alpha, wxIMAGE_ALPHA_OPAQUE, lenAlpha);
1928     }
1929 }
1930
1931 void wxImage::ClearAlpha()
1932 {
1933     wxCHECK_RET( HasAlpha(), wxT("image already doesn't have an alpha channel") );
1934
1935     if ( !M_IMGDATA->m_staticAlpha )
1936         free( M_IMGDATA->m_alpha );
1937
1938     M_IMGDATA->m_alpha = NULL;
1939 }
1940
1941
1942 // ----------------------------------------------------------------------------
1943 // mask support
1944 // ----------------------------------------------------------------------------
1945
1946 void wxImage::SetMaskColour( unsigned char r, unsigned char g, unsigned char b )
1947 {
1948     wxCHECK_RET( Ok(), wxT("invalid image") );
1949
1950     AllocExclusive();
1951
1952     M_IMGDATA->m_maskRed = r;
1953     M_IMGDATA->m_maskGreen = g;
1954     M_IMGDATA->m_maskBlue = b;
1955     M_IMGDATA->m_hasMask = true;
1956 }
1957
1958 bool wxImage::GetOrFindMaskColour( unsigned char *r, unsigned char *g, unsigned char *b ) const
1959 {
1960     wxCHECK_MSG( Ok(), false, wxT("invalid image") );
1961
1962     if (M_IMGDATA->m_hasMask)
1963     {
1964         if (r) *r = M_IMGDATA->m_maskRed;
1965         if (g) *g = M_IMGDATA->m_maskGreen;
1966         if (b) *b = M_IMGDATA->m_maskBlue;
1967         return true;
1968     }
1969     else
1970     {
1971         FindFirstUnusedColour(r, g, b);
1972         return false;
1973     }
1974 }
1975
1976 unsigned char wxImage::GetMaskRed() const
1977 {
1978     wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
1979
1980     return M_IMGDATA->m_maskRed;
1981 }
1982
1983 unsigned char wxImage::GetMaskGreen() const
1984 {
1985     wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
1986
1987     return M_IMGDATA->m_maskGreen;
1988 }
1989
1990 unsigned char wxImage::GetMaskBlue() const
1991 {
1992     wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
1993
1994     return M_IMGDATA->m_maskBlue;
1995 }
1996
1997 void wxImage::SetMask( bool mask )
1998 {
1999     wxCHECK_RET( Ok(), wxT("invalid image") );
2000
2001     AllocExclusive();
2002
2003     M_IMGDATA->m_hasMask = mask;
2004 }
2005
2006 bool wxImage::HasMask() const
2007 {
2008     wxCHECK_MSG( Ok(), false, wxT("invalid image") );
2009
2010     return M_IMGDATA->m_hasMask;
2011 }
2012
2013 bool wxImage::IsTransparent(int x, int y, unsigned char threshold) const
2014 {
2015     long pos = XYToIndex(x, y);
2016     wxCHECK_MSG( pos != -1, false, wxT("invalid image coordinates") );
2017
2018     // check mask
2019     if ( M_IMGDATA->m_hasMask )
2020     {
2021         const unsigned char *p = M_IMGDATA->m_data + 3*pos;
2022         if ( p[0] == M_IMGDATA->m_maskRed &&
2023                 p[1] == M_IMGDATA->m_maskGreen &&
2024                     p[2] == M_IMGDATA->m_maskBlue )
2025         {
2026             return true;
2027         }
2028     }
2029
2030     // then check alpha
2031     if ( M_IMGDATA->m_alpha )
2032     {
2033         if ( M_IMGDATA->m_alpha[pos] < threshold )
2034         {
2035             // transparent enough
2036             return true;
2037         }
2038     }
2039
2040     // not transparent
2041     return false;
2042 }
2043
2044 bool wxImage::SetMaskFromImage(const wxImage& mask,
2045                                unsigned char mr, unsigned char mg, unsigned char mb)
2046 {
2047     // check that the images are the same size
2048     if ( (M_IMGDATA->m_height != mask.GetHeight() ) || (M_IMGDATA->m_width != mask.GetWidth () ) )
2049     {
2050         wxLogError( _("Image and mask have different sizes.") );
2051         return false;
2052     }
2053
2054     // find unused colour
2055     unsigned char r,g,b ;
2056     if (!FindFirstUnusedColour(&r, &g, &b))
2057     {
2058         wxLogError( _("No unused colour in image being masked.") );
2059         return false ;
2060     }
2061
2062     AllocExclusive();
2063
2064     unsigned char *imgdata = GetData();
2065     unsigned char *maskdata = mask.GetData();
2066
2067     const int w = GetWidth();
2068     const int h = GetHeight();
2069
2070     for (int j = 0; j < h; j++)
2071     {
2072         for (int i = 0; i < w; i++)
2073         {
2074             if ((maskdata[0] == mr) && (maskdata[1]  == mg) && (maskdata[2] == mb))
2075             {
2076                 imgdata[0] = r;
2077                 imgdata[1] = g;
2078                 imgdata[2] = b;
2079             }
2080             imgdata  += 3;
2081             maskdata += 3;
2082         }
2083     }
2084
2085     SetMaskColour(r, g, b);
2086     SetMask(true);
2087
2088     return true;
2089 }
2090
2091 bool wxImage::ConvertAlphaToMask(unsigned char threshold)
2092 {
2093     if ( !HasAlpha() )
2094         return false;
2095
2096     unsigned char mr, mg, mb;
2097     if ( !FindFirstUnusedColour(&mr, &mg, &mb) )
2098     {
2099         wxLogError( _("No unused colour in image being masked.") );
2100         return false;
2101     }
2102
2103     return ConvertAlphaToMask(mr, mg, mb, threshold);
2104 }
2105
2106 bool wxImage::ConvertAlphaToMask(unsigned char mr,
2107                                  unsigned char mg,
2108                                  unsigned char mb,
2109                                  unsigned char threshold)
2110 {
2111     if ( !HasAlpha() )
2112         return false;
2113
2114     AllocExclusive();
2115
2116     SetMask(true);
2117     SetMaskColour(mr, mg, mb);
2118
2119     unsigned char *imgdata = GetData();
2120     unsigned char *alphadata = GetAlpha();
2121
2122     int w = GetWidth();
2123     int h = GetHeight();
2124
2125     for (int y = 0; y < h; y++)
2126     {
2127         for (int x = 0; x < w; x++, imgdata += 3, alphadata++)
2128         {
2129             if (*alphadata < threshold)
2130             {
2131                 imgdata[0] = mr;
2132                 imgdata[1] = mg;
2133                 imgdata[2] = mb;
2134             }
2135         }
2136     }
2137
2138     if ( !M_IMGDATA->m_staticAlpha )
2139         free(M_IMGDATA->m_alpha);
2140
2141     M_IMGDATA->m_alpha = NULL;
2142     M_IMGDATA->m_staticAlpha = false;
2143
2144     return true;
2145 }
2146
2147 // ----------------------------------------------------------------------------
2148 // Palette functions
2149 // ----------------------------------------------------------------------------
2150
2151 #if wxUSE_PALETTE
2152
2153 bool wxImage::HasPalette() const
2154 {
2155     if (!Ok())
2156         return false;
2157
2158     return M_IMGDATA->m_palette.Ok();
2159 }
2160
2161 const wxPalette& wxImage::GetPalette() const
2162 {
2163     wxCHECK_MSG( Ok(), wxNullPalette, wxT("invalid image") );
2164
2165     return M_IMGDATA->m_palette;
2166 }
2167
2168 void wxImage::SetPalette(const wxPalette& palette)
2169 {
2170     wxCHECK_RET( Ok(), wxT("invalid image") );
2171
2172     AllocExclusive();
2173
2174     M_IMGDATA->m_palette = palette;
2175 }
2176
2177 #endif // wxUSE_PALETTE
2178
2179 // ----------------------------------------------------------------------------
2180 // Option functions (arbitrary name/value mapping)
2181 // ----------------------------------------------------------------------------
2182
2183 void wxImage::SetOption(const wxString& name, const wxString& value)
2184 {
2185     AllocExclusive();
2186
2187     int idx = M_IMGDATA->m_optionNames.Index(name, false);
2188     if ( idx == wxNOT_FOUND )
2189     {
2190         M_IMGDATA->m_optionNames.Add(name);
2191         M_IMGDATA->m_optionValues.Add(value);
2192     }
2193     else
2194     {
2195         M_IMGDATA->m_optionNames[idx] = name;
2196         M_IMGDATA->m_optionValues[idx] = value;
2197     }
2198 }
2199
2200 void wxImage::SetOption(const wxString& name, int value)
2201 {
2202     wxString valStr;
2203     valStr.Printf(wxT("%d"), value);
2204     SetOption(name, valStr);
2205 }
2206
2207 wxString wxImage::GetOption(const wxString& name) const
2208 {
2209     if ( !M_IMGDATA )
2210         return wxEmptyString;
2211
2212     int idx = M_IMGDATA->m_optionNames.Index(name, false);
2213     if ( idx == wxNOT_FOUND )
2214         return wxEmptyString;
2215     else
2216         return M_IMGDATA->m_optionValues[idx];
2217 }
2218
2219 int wxImage::GetOptionInt(const wxString& name) const
2220 {
2221     return wxAtoi(GetOption(name));
2222 }
2223
2224 bool wxImage::HasOption(const wxString& name) const
2225 {
2226     return M_IMGDATA ? M_IMGDATA->m_optionNames.Index(name, false) != wxNOT_FOUND
2227                      : false;
2228 }
2229
2230 // ----------------------------------------------------------------------------
2231 // image I/O
2232 // ----------------------------------------------------------------------------
2233
2234 bool wxImage::LoadFile( const wxString& WXUNUSED_UNLESS_STREAMS(filename),
2235                         wxBitmapType WXUNUSED_UNLESS_STREAMS(type),
2236                         int WXUNUSED_UNLESS_STREAMS(index) )
2237 {
2238 #if HAS_FILE_STREAMS
2239     wxImageFileInputStream stream(filename);
2240     if ( stream.IsOk() )
2241     {
2242         wxBufferedInputStream bstream( stream );
2243         if ( LoadFile(bstream, type, index) )
2244             return true;
2245     }
2246
2247     wxLogError(_("Failed to load image from file \"%s\"."), filename);
2248 #endif // HAS_FILE_STREAMS
2249
2250     return false;
2251 }
2252
2253 bool wxImage::LoadFile( const wxString& WXUNUSED_UNLESS_STREAMS(filename),
2254                         const wxString& WXUNUSED_UNLESS_STREAMS(mimetype),
2255                         int WXUNUSED_UNLESS_STREAMS(index) )
2256 {
2257 #if HAS_FILE_STREAMS
2258     wxImageFileInputStream stream(filename);
2259     if ( stream.IsOk() )
2260     {
2261         wxBufferedInputStream bstream( stream );
2262         if ( LoadFile(bstream, mimetype, index) )
2263             return true;
2264     }
2265
2266     wxLogError(_("Failed to load image from file \"%s\"."), filename);
2267 #endif // HAS_FILE_STREAMS
2268
2269     return false;
2270 }
2271
2272
2273 bool wxImage::SaveFile( const wxString& filename ) const
2274 {
2275     wxString ext = filename.AfterLast('.').Lower();
2276
2277     wxImageHandler *handler = FindHandler(ext, wxBITMAP_TYPE_ANY);
2278     if ( !handler)
2279     {
2280        wxLogError(_("Can't save image to file '%s': unknown extension."),
2281                   filename);
2282        return false;
2283     }
2284
2285     return SaveFile(filename, handler->GetType());
2286 }
2287
2288 bool wxImage::SaveFile( const wxString& WXUNUSED_UNLESS_STREAMS(filename),
2289                         wxBitmapType WXUNUSED_UNLESS_STREAMS(type) ) const
2290 {
2291 #if HAS_FILE_STREAMS
2292     wxCHECK_MSG( Ok(), false, wxT("invalid image") );
2293
2294     ((wxImage*)this)->SetOption(wxIMAGE_OPTION_FILENAME, filename);
2295
2296     wxImageFileOutputStream stream(filename);
2297
2298     if ( stream.IsOk() )
2299     {
2300         wxBufferedOutputStream bstream( stream );
2301         return SaveFile(bstream, type);
2302     }
2303 #endif // HAS_FILE_STREAMS
2304
2305     return false;
2306 }
2307
2308 bool wxImage::SaveFile( const wxString& WXUNUSED_UNLESS_STREAMS(filename),
2309                         const wxString& WXUNUSED_UNLESS_STREAMS(mimetype) ) const
2310 {
2311 #if HAS_FILE_STREAMS
2312     wxCHECK_MSG( Ok(), false, wxT("invalid image") );
2313
2314     ((wxImage*)this)->SetOption(wxIMAGE_OPTION_FILENAME, filename);
2315
2316     wxImageFileOutputStream stream(filename);
2317
2318     if ( stream.IsOk() )
2319     {
2320         wxBufferedOutputStream bstream( stream );
2321         return SaveFile(bstream, mimetype);
2322     }
2323 #endif // HAS_FILE_STREAMS
2324
2325     return false;
2326 }
2327
2328 bool wxImage::CanRead( const wxString& WXUNUSED_UNLESS_STREAMS(name) )
2329 {
2330 #if HAS_FILE_STREAMS
2331     wxImageFileInputStream stream(name);
2332     return CanRead(stream);
2333 #else
2334     return false;
2335 #endif
2336 }
2337
2338 int wxImage::GetImageCount( const wxString& WXUNUSED_UNLESS_STREAMS(name),
2339                             wxBitmapType WXUNUSED_UNLESS_STREAMS(type) )
2340 {
2341 #if HAS_FILE_STREAMS
2342     wxImageFileInputStream stream(name);
2343     if (stream.Ok())
2344         return GetImageCount(stream, type);
2345 #endif
2346
2347   return 0;
2348 }
2349
2350 #if wxUSE_STREAMS
2351
2352 bool wxImage::CanRead( wxInputStream &stream )
2353 {
2354     const wxList& list = GetHandlers();
2355
2356     for ( wxList::compatibility_iterator node = list.GetFirst(); node; node = node->GetNext() )
2357     {
2358         wxImageHandler *handler=(wxImageHandler*)node->GetData();
2359         if (handler->CanRead( stream ))
2360             return true;
2361     }
2362
2363     return false;
2364 }
2365
2366 int wxImage::GetImageCount( wxInputStream &stream, wxBitmapType type )
2367 {
2368     wxImageHandler *handler;
2369
2370     if ( type == wxBITMAP_TYPE_ANY )
2371     {
2372         const wxList& list = GetHandlers();
2373
2374         for ( wxList::compatibility_iterator node = list.GetFirst();
2375               node;
2376               node = node->GetNext() )
2377         {
2378              handler = (wxImageHandler*)node->GetData();
2379              if ( handler->CanRead(stream) )
2380              {
2381                  const int count = handler->GetImageCount(stream);
2382                  if ( count >= 0 )
2383                      return count;
2384              }
2385
2386         }
2387
2388         wxLogWarning(_("No handler found for image type."));
2389         return 0;
2390     }
2391
2392     handler = FindHandler(type);
2393
2394     if ( !handler )
2395     {
2396         wxLogWarning(_("No image handler for type %d defined."), type);
2397         return false;
2398     }
2399
2400     if ( handler->CanRead(stream) )
2401     {
2402         return handler->GetImageCount(stream);
2403     }
2404     else
2405     {
2406         wxLogError(_("Image file is not of type %d."), type);
2407         return 0;
2408     }
2409 }
2410
2411 bool wxImage::DoLoad(wxImageHandler& handler, wxInputStream& stream, int index)
2412 {
2413     // save the options values which can be clobbered by the handler (e.g. many
2414     // of them call Destroy() before trying to load the file)
2415     const unsigned maxWidth = GetOptionInt(wxIMAGE_OPTION_MAX_WIDTH),
2416                    maxHeight = GetOptionInt(wxIMAGE_OPTION_MAX_HEIGHT);
2417
2418     // Preserve the original stream position if possible to rewind back to it
2419     // if we failed to load the file -- maybe the next handler that we try can
2420     // succeed after us then.
2421     wxFileOffset posOld = wxInvalidOffset;
2422     if ( stream.IsSeekable() )
2423         posOld = stream.TellI();
2424
2425     if ( !handler.LoadFile(this, stream, true/*verbose*/, index) )
2426     {
2427         if ( posOld != wxInvalidOffset )
2428             stream.SeekI(posOld);
2429
2430         return false;
2431     }
2432
2433     // rescale the image to the specified size if needed
2434     if ( maxWidth || maxHeight )
2435     {
2436         const unsigned widthOrig = GetWidth(),
2437                        heightOrig = GetHeight();
2438
2439         // this uses the same (trivial) algorithm as the JPEG handler
2440         unsigned width = widthOrig,
2441                  height = heightOrig;
2442         while ( (maxWidth && width > maxWidth) ||
2443                     (maxHeight && height > maxHeight) )
2444         {
2445             width /= 2;
2446             height /= 2;
2447         }
2448
2449         if ( width != widthOrig || height != heightOrig )
2450             Rescale(width, height, wxIMAGE_QUALITY_HIGH);
2451     }
2452
2453     // Set this after Rescale, which currently does not preserve it
2454     M_IMGDATA->m_type = handler.GetType();
2455
2456     return true;
2457 }
2458
2459 bool wxImage::LoadFile( wxInputStream& stream, wxBitmapType type, int index )
2460 {
2461     AllocExclusive();
2462
2463     wxImageHandler *handler;
2464
2465     if ( type == wxBITMAP_TYPE_ANY )
2466     {
2467         if ( !stream.IsSeekable() )
2468         {
2469             // The error message about image data format being unknown below
2470             // would be misleading in this case as we are not even going to try
2471             // any handlers because CanRead() never does anything for not
2472             // seekable stream, so try to be more precise here.
2473             wxLogError(_("Can't automatically determine the image format "
2474                          "for non-seekable input."));
2475             return false;
2476         }
2477
2478         const wxList& list = GetHandlers();
2479         for ( wxList::compatibility_iterator node = list.GetFirst();
2480               node;
2481               node = node->GetNext() )
2482         {
2483              handler = (wxImageHandler*)node->GetData();
2484              if ( handler->CanRead(stream) && DoLoad(*handler, stream, index) )
2485                  return true;
2486         }
2487
2488         wxLogWarning( _("Unknown image data format.") );
2489
2490         return false;
2491     }
2492     //else: have specific type
2493
2494     handler = FindHandler(type);
2495     if ( !handler )
2496     {
2497         wxLogWarning( _("No image handler for type %d defined."), type );
2498         return false;
2499     }
2500
2501     if ( stream.IsSeekable() && !handler->CanRead(stream) )
2502     {
2503         wxLogError(_("This is not a %s."), handler->GetName());
2504         return false;
2505     }
2506
2507     return DoLoad(*handler, stream, index);
2508 }
2509
2510 bool wxImage::LoadFile( wxInputStream& stream, const wxString& mimetype, int index )
2511 {
2512     UnRef();
2513
2514     m_refData = new wxImageRefData;
2515
2516     wxImageHandler *handler = FindHandlerMime(mimetype);
2517
2518     if ( !handler )
2519     {
2520         wxLogWarning( _("No image handler for type %s defined."), mimetype.GetData() );
2521         return false;
2522     }
2523
2524     if ( stream.IsSeekable() && !handler->CanRead(stream) )
2525     {
2526         wxLogError(_("Image is not of type %s."), mimetype);
2527         return false;
2528     }
2529
2530     return DoLoad(*handler, stream, index);
2531 }
2532
2533 bool wxImage::DoSave(wxImageHandler& handler, wxOutputStream& stream) const
2534 {
2535     wxImage * const self = const_cast<wxImage *>(this);
2536     if ( !handler.SaveFile(self, stream) )
2537         return false;
2538
2539     M_IMGDATA->m_type = handler.GetType();
2540     return true;
2541 }
2542
2543 bool wxImage::SaveFile( wxOutputStream& stream, wxBitmapType type ) const
2544 {
2545     wxCHECK_MSG( Ok(), false, wxT("invalid image") );
2546
2547     wxImageHandler *handler = FindHandler(type);
2548     if ( !handler )
2549     {
2550         wxLogWarning( _("No image handler for type %d defined."), type );
2551         return false;
2552     }
2553
2554     return DoSave(*handler, stream);
2555 }
2556
2557 bool wxImage::SaveFile( wxOutputStream& stream, const wxString& mimetype ) const
2558 {
2559     wxCHECK_MSG( Ok(), false, wxT("invalid image") );
2560
2561     wxImageHandler *handler = FindHandlerMime(mimetype);
2562     if ( !handler )
2563     {
2564         wxLogWarning( _("No image handler for type %s defined."), mimetype.GetData() );
2565     }
2566
2567     return DoSave(*handler, stream);
2568 }
2569
2570 #endif // wxUSE_STREAMS
2571
2572 // ----------------------------------------------------------------------------
2573 // image I/O handlers
2574 // ----------------------------------------------------------------------------
2575
2576 void wxImage::AddHandler( wxImageHandler *handler )
2577 {
2578     // Check for an existing handler of the type being added.
2579     if (FindHandler( handler->GetType() ) == 0)
2580     {
2581         sm_handlers.Append( handler );
2582     }
2583     else
2584     {
2585         // This is not documented behaviour, merely the simplest 'fix'
2586         // for preventing duplicate additions.  If someone ever has
2587         // a good reason to add and remove duplicate handlers (and they
2588         // may) we should probably refcount the duplicates.
2589         //   also an issue in InsertHandler below.
2590
2591         wxLogDebug( wxT("Adding duplicate image handler for '%s'"),
2592                     handler->GetName().c_str() );
2593         delete handler;
2594     }
2595 }
2596
2597 void wxImage::InsertHandler( wxImageHandler *handler )
2598 {
2599     // Check for an existing handler of the type being added.
2600     if (FindHandler( handler->GetType() ) == 0)
2601     {
2602         sm_handlers.Insert( handler );
2603     }
2604     else
2605     {
2606         // see AddHandler for additional comments.
2607         wxLogDebug( wxT("Inserting duplicate image handler for '%s'"),
2608                     handler->GetName().c_str() );
2609         delete handler;
2610     }
2611 }
2612
2613 bool wxImage::RemoveHandler( const wxString& name )
2614 {
2615     wxImageHandler *handler = FindHandler(name);
2616     if (handler)
2617     {
2618         sm_handlers.DeleteObject(handler);
2619         delete handler;
2620         return true;
2621     }
2622     else
2623         return false;
2624 }
2625
2626 wxImageHandler *wxImage::FindHandler( const wxString& name )
2627 {
2628     wxList::compatibility_iterator node = sm_handlers.GetFirst();
2629     while (node)
2630     {
2631         wxImageHandler *handler = (wxImageHandler*)node->GetData();
2632         if (handler->GetName().Cmp(name) == 0) return handler;
2633
2634         node = node->GetNext();
2635     }
2636     return NULL;
2637 }
2638
2639 wxImageHandler *wxImage::FindHandler( const wxString& extension, wxBitmapType bitmapType )
2640 {
2641     wxList::compatibility_iterator node = sm_handlers.GetFirst();
2642     while (node)
2643     {
2644         wxImageHandler *handler = (wxImageHandler*)node->GetData();
2645         if ((bitmapType == wxBITMAP_TYPE_ANY) || (handler->GetType() == bitmapType))
2646         {
2647             if (handler->GetExtension() == extension)
2648                 return handler;
2649             if (handler->GetAltExtensions().Index(extension, false) != wxNOT_FOUND)
2650                 return handler;
2651         }
2652         node = node->GetNext();
2653     }
2654     return NULL;
2655 }
2656
2657 wxImageHandler *wxImage::FindHandler(wxBitmapType bitmapType )
2658 {
2659     wxList::compatibility_iterator node = sm_handlers.GetFirst();
2660     while (node)
2661     {
2662         wxImageHandler *handler = (wxImageHandler *)node->GetData();
2663         if (handler->GetType() == bitmapType) return handler;
2664         node = node->GetNext();
2665     }
2666     return NULL;
2667 }
2668
2669 wxImageHandler *wxImage::FindHandlerMime( const wxString& mimetype )
2670 {
2671     wxList::compatibility_iterator node = sm_handlers.GetFirst();
2672     while (node)
2673     {
2674         wxImageHandler *handler = (wxImageHandler *)node->GetData();
2675         if (handler->GetMimeType().IsSameAs(mimetype, false)) return handler;
2676         node = node->GetNext();
2677     }
2678     return NULL;
2679 }
2680
2681 void wxImage::InitStandardHandlers()
2682 {
2683 #if wxUSE_STREAMS
2684     AddHandler(new wxBMPHandler);
2685 #endif // wxUSE_STREAMS
2686 }
2687
2688 void wxImage::CleanUpHandlers()
2689 {
2690     wxList::compatibility_iterator node = sm_handlers.GetFirst();
2691     while (node)
2692     {
2693         wxImageHandler *handler = (wxImageHandler *)node->GetData();
2694         wxList::compatibility_iterator next = node->GetNext();
2695         delete handler;
2696         node = next;
2697     }
2698
2699     sm_handlers.Clear();
2700 }
2701
2702 wxString wxImage::GetImageExtWildcard()
2703 {
2704     wxString fmts;
2705
2706     wxList& Handlers = wxImage::GetHandlers();
2707     wxList::compatibility_iterator Node = Handlers.GetFirst();
2708     while ( Node )
2709     {
2710         wxImageHandler* Handler = (wxImageHandler*)Node->GetData();
2711         fmts += wxT("*.") + Handler->GetExtension();
2712         for (size_t i = 0; i < Handler->GetAltExtensions().size(); i++)
2713             fmts += wxT(";*.") + Handler->GetAltExtensions()[i];
2714         Node = Node->GetNext();
2715         if ( Node ) fmts += wxT(";");
2716     }
2717
2718     return wxT("(") + fmts + wxT(")|") + fmts;
2719 }
2720
2721 wxImage::HSVValue wxImage::RGBtoHSV(const RGBValue& rgb)
2722 {
2723     const double red = rgb.red / 255.0,
2724                  green = rgb.green / 255.0,
2725                  blue = rgb.blue / 255.0;
2726
2727     // find the min and max intensity (and remember which one was it for the
2728     // latter)
2729     double minimumRGB = red;
2730     if ( green < minimumRGB )
2731         minimumRGB = green;
2732     if ( blue < minimumRGB )
2733         minimumRGB = blue;
2734
2735     enum { RED, GREEN, BLUE } chMax = RED;
2736     double maximumRGB = red;
2737     if ( green > maximumRGB )
2738     {
2739         chMax = GREEN;
2740         maximumRGB = green;
2741     }
2742     if ( blue > maximumRGB )
2743     {
2744         chMax = BLUE;
2745         maximumRGB = blue;
2746     }
2747
2748     const double value = maximumRGB;
2749
2750     double hue = 0.0, saturation;
2751     const double deltaRGB = maximumRGB - minimumRGB;
2752     if ( wxIsNullDouble(deltaRGB) )
2753     {
2754         // Gray has no color
2755         hue = 0.0;
2756         saturation = 0.0;
2757     }
2758     else
2759     {
2760         switch ( chMax )
2761         {
2762             case RED:
2763                 hue = (green - blue) / deltaRGB;
2764                 break;
2765
2766             case GREEN:
2767                 hue = 2.0 + (blue - red) / deltaRGB;
2768                 break;
2769
2770             case BLUE:
2771                 hue = 4.0 + (red - green) / deltaRGB;
2772                 break;
2773
2774             default:
2775                 wxFAIL_MSG(wxT("hue not specified"));
2776                 break;
2777         }
2778
2779         hue /= 6.0;
2780
2781         if ( hue < 0.0 )
2782             hue += 1.0;
2783
2784         saturation = deltaRGB / maximumRGB;
2785     }
2786
2787     return HSVValue(hue, saturation, value);
2788 }
2789
2790 wxImage::RGBValue wxImage::HSVtoRGB(const HSVValue& hsv)
2791 {
2792     double red, green, blue;
2793
2794     if ( wxIsNullDouble(hsv.saturation) )
2795     {
2796         // Grey
2797         red = hsv.value;
2798         green = hsv.value;
2799         blue = hsv.value;
2800     }
2801     else // not grey
2802     {
2803         double hue = hsv.hue * 6.0;      // sector 0 to 5
2804         int i = (int)floor(hue);
2805         double f = hue - i;          // fractional part of h
2806         double p = hsv.value * (1.0 - hsv.saturation);
2807
2808         switch (i)
2809         {
2810             case 0:
2811                 red = hsv.value;
2812                 green = hsv.value * (1.0 - hsv.saturation * (1.0 - f));
2813                 blue = p;
2814                 break;
2815
2816             case 1:
2817                 red = hsv.value * (1.0 - hsv.saturation * f);
2818                 green = hsv.value;
2819                 blue = p;
2820                 break;
2821
2822             case 2:
2823                 red = p;
2824                 green = hsv.value;
2825                 blue = hsv.value * (1.0 - hsv.saturation * (1.0 - f));
2826                 break;
2827
2828             case 3:
2829                 red = p;
2830                 green = hsv.value * (1.0 - hsv.saturation * f);
2831                 blue = hsv.value;
2832                 break;
2833
2834             case 4:
2835                 red = hsv.value * (1.0 - hsv.saturation * (1.0 - f));
2836                 green = p;
2837                 blue = hsv.value;
2838                 break;
2839
2840             default:    // case 5:
2841                 red = hsv.value;
2842                 green = p;
2843                 blue = hsv.value * (1.0 - hsv.saturation * f);
2844                 break;
2845         }
2846     }
2847
2848     return RGBValue((unsigned char)(red * 255.0),
2849                     (unsigned char)(green * 255.0),
2850                     (unsigned char)(blue * 255.0));
2851 }
2852
2853 /*
2854  * Rotates the hue of each pixel of the image. angle is a double in the range
2855  * -1.0..1.0 where -1.0 is -360 degrees and 1.0 is 360 degrees
2856  */
2857 void wxImage::RotateHue(double angle)
2858 {
2859     AllocExclusive();
2860
2861     unsigned char *srcBytePtr;
2862     unsigned char *dstBytePtr;
2863     unsigned long count;
2864     wxImage::HSVValue hsv;
2865     wxImage::RGBValue rgb;
2866
2867     wxASSERT (angle >= -1.0 && angle <= 1.0);
2868     count = M_IMGDATA->m_width * M_IMGDATA->m_height;
2869     if ( count > 0 && !wxIsNullDouble(angle) )
2870     {
2871         srcBytePtr = M_IMGDATA->m_data;
2872         dstBytePtr = srcBytePtr;
2873         do
2874         {
2875             rgb.red = *srcBytePtr++;
2876             rgb.green = *srcBytePtr++;
2877             rgb.blue = *srcBytePtr++;
2878             hsv = RGBtoHSV(rgb);
2879
2880             hsv.hue = hsv.hue + angle;
2881             if (hsv.hue > 1.0)
2882                 hsv.hue = hsv.hue - 1.0;
2883             else if (hsv.hue < 0.0)
2884                 hsv.hue = hsv.hue + 1.0;
2885
2886             rgb = HSVtoRGB(hsv);
2887             *dstBytePtr++ = rgb.red;
2888             *dstBytePtr++ = rgb.green;
2889             *dstBytePtr++ = rgb.blue;
2890         } while (--count != 0);
2891     }
2892 }
2893
2894 //-----------------------------------------------------------------------------
2895 // wxImageHandler
2896 //-----------------------------------------------------------------------------
2897
2898 IMPLEMENT_ABSTRACT_CLASS(wxImageHandler,wxObject)
2899
2900 #if wxUSE_STREAMS
2901 int wxImageHandler::GetImageCount( wxInputStream& stream )
2902 {
2903     // NOTE: this code is the same of wxAnimationDecoder::CanRead and
2904     //       wxImageHandler::CallDoCanRead
2905
2906     if ( !stream.IsSeekable() )
2907         return false;        // can't test unseekable stream
2908
2909     wxFileOffset posOld = stream.TellI();
2910     int n = DoGetImageCount(stream);
2911
2912     // restore the old position to be able to test other formats and so on
2913     if ( stream.SeekI(posOld) == wxInvalidOffset )
2914     {
2915         wxLogDebug(wxT("Failed to rewind the stream in wxImageHandler!"));
2916
2917         // reading would fail anyhow as we're not at the right position
2918         return false;
2919     }
2920
2921     return n;
2922 }
2923
2924 bool wxImageHandler::CanRead( const wxString& name )
2925 {
2926     wxImageFileInputStream stream(name);
2927     if ( !stream.IsOk() )
2928     {
2929         wxLogError(_("Failed to check format of image file \"%s\"."), name);
2930
2931         return false;
2932     }
2933
2934     return CanRead(stream);
2935 }
2936
2937 bool wxImageHandler::CallDoCanRead(wxInputStream& stream)
2938 {
2939     // NOTE: this code is the same of wxAnimationDecoder::CanRead and
2940     //       wxImageHandler::GetImageCount
2941
2942     if ( !stream.IsSeekable() )
2943         return false;        // can't test unseekable stream
2944
2945     wxFileOffset posOld = stream.TellI();
2946     bool ok = DoCanRead(stream);
2947
2948     // restore the old position to be able to test other formats and so on
2949     if ( stream.SeekI(posOld) == wxInvalidOffset )
2950     {
2951         wxLogDebug(wxT("Failed to rewind the stream in wxImageHandler!"));
2952
2953         // reading would fail anyhow as we're not at the right position
2954         return false;
2955     }
2956
2957     return ok;
2958 }
2959
2960 #endif // wxUSE_STREAMS
2961
2962 /* static */
2963 wxImageResolution
2964 wxImageHandler::GetResolutionFromOptions(const wxImage& image, int *x, int *y)
2965 {
2966     wxCHECK_MSG( x && y, wxIMAGE_RESOLUTION_NONE, wxT("NULL pointer") );
2967
2968     if ( image.HasOption(wxIMAGE_OPTION_RESOLUTIONX) &&
2969          image.HasOption(wxIMAGE_OPTION_RESOLUTIONY) )
2970     {
2971         *x = image.GetOptionInt(wxIMAGE_OPTION_RESOLUTIONX);
2972         *y = image.GetOptionInt(wxIMAGE_OPTION_RESOLUTIONY);
2973     }
2974     else if ( image.HasOption(wxIMAGE_OPTION_RESOLUTION) )
2975     {
2976         *x =
2977         *y = image.GetOptionInt(wxIMAGE_OPTION_RESOLUTION);
2978     }
2979     else // no resolution options specified
2980     {
2981         *x =
2982         *y = 0;
2983
2984         return wxIMAGE_RESOLUTION_NONE;
2985     }
2986
2987     // get the resolution unit too
2988     int resUnit = image.GetOptionInt(wxIMAGE_OPTION_RESOLUTIONUNIT);
2989     if ( !resUnit )
2990     {
2991         // this is the default
2992         resUnit = wxIMAGE_RESOLUTION_INCHES;
2993     }
2994
2995     return (wxImageResolution)resUnit;
2996 }
2997
2998 // ----------------------------------------------------------------------------
2999 // image histogram stuff
3000 // ----------------------------------------------------------------------------
3001
3002 bool
3003 wxImageHistogram::FindFirstUnusedColour(unsigned char *r,
3004                                         unsigned char *g,
3005                                         unsigned char *b,
3006                                         unsigned char r2,
3007                                         unsigned char b2,
3008                                         unsigned char g2) const
3009 {
3010     unsigned long key = MakeKey(r2, g2, b2);
3011
3012     while ( find(key) != end() )
3013     {
3014         // color already used
3015         r2++;
3016         if ( r2 >= 255 )
3017         {
3018             r2 = 0;
3019             g2++;
3020             if ( g2 >= 255 )
3021             {
3022                 g2 = 0;
3023                 b2++;
3024                 if ( b2 >= 255 )
3025                 {
3026                     wxLogError(_("No unused colour in image.") );
3027                     return false;
3028                 }
3029             }
3030         }
3031
3032         key = MakeKey(r2, g2, b2);
3033     }
3034
3035     if ( r )
3036         *r = r2;
3037     if ( g )
3038         *g = g2;
3039     if ( b )
3040         *b = b2;
3041
3042     return true;
3043 }
3044
3045 bool
3046 wxImage::FindFirstUnusedColour(unsigned char *r,
3047                                unsigned char *g,
3048                                unsigned char *b,
3049                                unsigned char r2,
3050                                unsigned char b2,
3051                                unsigned char g2) const
3052 {
3053     wxImageHistogram histogram;
3054
3055     ComputeHistogram(histogram);
3056
3057     return histogram.FindFirstUnusedColour(r, g, b, r2, g2, b2);
3058 }
3059
3060
3061
3062 // GRG, Dic/99
3063 // Counts and returns the number of different colours. Optionally stops
3064 // when it exceeds 'stopafter' different colours. This is useful, for
3065 // example, to see if the image can be saved as 8-bit (256 colour or
3066 // less, in this case it would be invoked as CountColours(256)). Default
3067 // value for stopafter is -1 (don't care).
3068 //
3069 unsigned long wxImage::CountColours( unsigned long stopafter ) const
3070 {
3071     wxHashTable h;
3072     wxObject dummy;
3073     unsigned char r, g, b;
3074     unsigned char *p;
3075     unsigned long size, nentries, key;
3076
3077     p = GetData();
3078     size = GetWidth() * GetHeight();
3079     nentries = 0;
3080
3081     for (unsigned long j = 0; (j < size) && (nentries <= stopafter) ; j++)
3082     {
3083         r = *(p++);
3084         g = *(p++);
3085         b = *(p++);
3086         key = wxImageHistogram::MakeKey(r, g, b);
3087
3088         if (h.Get(key) == NULL)
3089         {
3090             h.Put(key, &dummy);
3091             nentries++;
3092         }
3093     }
3094
3095     return nentries;
3096 }
3097
3098
3099 unsigned long wxImage::ComputeHistogram( wxImageHistogram &h ) const
3100 {
3101     unsigned char *p = GetData();
3102     unsigned long nentries = 0;
3103
3104     h.clear();
3105
3106     const unsigned long size = GetWidth() * GetHeight();
3107
3108     unsigned char r, g, b;
3109     for ( unsigned long n = 0; n < size; n++ )
3110     {
3111         r = *p++;
3112         g = *p++;
3113         b = *p++;
3114
3115         wxImageHistogramEntry& entry = h[wxImageHistogram::MakeKey(r, g, b)];
3116
3117         if ( entry.value++ == 0 )
3118             entry.index = nentries++;
3119     }
3120
3121     return nentries;
3122 }
3123
3124 /*
3125  * Rotation code by Carlos Moreno
3126  */
3127
3128 static const double wxROTATE_EPSILON = 1e-10;
3129
3130 // Auxiliary function to rotate a point (x,y) with respect to point p0
3131 // make it inline and use a straight return to facilitate optimization
3132 // also, the function receives the sine and cosine of the angle to avoid
3133 // repeating the time-consuming calls to these functions -- sin/cos can
3134 // be computed and stored in the calling function.
3135
3136 static inline wxRealPoint
3137 wxRotatePoint(const wxRealPoint& p, double cos_angle, double sin_angle,
3138               const wxRealPoint& p0)
3139 {
3140     return wxRealPoint(p0.x + (p.x - p0.x) * cos_angle - (p.y - p0.y) * sin_angle,
3141                        p0.y + (p.y - p0.y) * cos_angle + (p.x - p0.x) * sin_angle);
3142 }
3143
3144 static inline wxRealPoint
3145 wxRotatePoint(double x, double y, double cos_angle, double sin_angle,
3146               const wxRealPoint & p0)
3147 {
3148     return wxRotatePoint (wxRealPoint(x,y), cos_angle, sin_angle, p0);
3149 }
3150
3151 wxImage wxImage::Rotate(double angle,
3152                         const wxPoint& centre_of_rotation,
3153                         bool interpolating,
3154                         wxPoint *offset_after_rotation) const
3155 {
3156     // screen coordinates are a mirror image of "real" coordinates
3157     angle = -angle;
3158
3159     const bool has_alpha = HasAlpha();
3160
3161     const int w = GetWidth();
3162     const int h = GetHeight();
3163
3164     int i;
3165
3166     // Create pointer-based array to accelerate access to wxImage's data
3167     unsigned char ** data = new unsigned char * [h];
3168     data[0] = GetData();
3169     for (i = 1; i < h; i++)
3170         data[i] = data[i - 1] + (3 * w);
3171
3172     // Same for alpha channel
3173     unsigned char ** alpha = NULL;
3174     if (has_alpha)
3175     {
3176         alpha = new unsigned char * [h];
3177         alpha[0] = GetAlpha();
3178         for (i = 1; i < h; i++)
3179             alpha[i] = alpha[i - 1] + w;
3180     }
3181
3182     // precompute coefficients for rotation formula
3183     const double cos_angle = cos(angle);
3184     const double sin_angle = sin(angle);
3185
3186     // Create new Image to store the result
3187     // First, find rectangle that covers the rotated image;  to do that,
3188     // rotate the four corners
3189
3190     const wxRealPoint p0(centre_of_rotation.x, centre_of_rotation.y);
3191
3192     wxRealPoint p1 = wxRotatePoint (0, 0, cos_angle, sin_angle, p0);
3193     wxRealPoint p2 = wxRotatePoint (0, h, cos_angle, sin_angle, p0);
3194     wxRealPoint p3 = wxRotatePoint (w, 0, cos_angle, sin_angle, p0);
3195     wxRealPoint p4 = wxRotatePoint (w, h, cos_angle, sin_angle, p0);
3196
3197     int x1a = (int) floor (wxMin (wxMin(p1.x, p2.x), wxMin(p3.x, p4.x)));
3198     int y1a = (int) floor (wxMin (wxMin(p1.y, p2.y), wxMin(p3.y, p4.y)));
3199     int x2a = (int) ceil (wxMax (wxMax(p1.x, p2.x), wxMax(p3.x, p4.x)));
3200     int y2a = (int) ceil (wxMax (wxMax(p1.y, p2.y), wxMax(p3.y, p4.y)));
3201
3202     // Create rotated image
3203     wxImage rotated (x2a - x1a + 1, y2a - y1a + 1, false);
3204     // With alpha channel
3205     if (has_alpha)
3206         rotated.SetAlpha();
3207
3208     if (offset_after_rotation != NULL)
3209     {
3210         *offset_after_rotation = wxPoint (x1a, y1a);
3211     }
3212
3213     // the rotated (destination) image is always accessed sequentially via this
3214     // pointer, there is no need for pointer-based arrays here
3215     unsigned char *dst = rotated.GetData();
3216
3217     unsigned char *alpha_dst = has_alpha ? rotated.GetAlpha() : NULL;
3218
3219     // if the original image has a mask, use its RGB values as the blank pixel,
3220     // else, fall back to default (black).
3221     unsigned char blank_r = 0;
3222     unsigned char blank_g = 0;
3223     unsigned char blank_b = 0;
3224
3225     if (HasMask())
3226     {
3227         blank_r = GetMaskRed();
3228         blank_g = GetMaskGreen();
3229         blank_b = GetMaskBlue();
3230         rotated.SetMaskColour( blank_r, blank_g, blank_b );
3231     }
3232
3233     // Now, for each point of the rotated image, find where it came from, by
3234     // performing an inverse rotation (a rotation of -angle) and getting the
3235     // pixel at those coordinates
3236
3237     const int rH = rotated.GetHeight();
3238     const int rW = rotated.GetWidth();
3239
3240     // do the (interpolating) test outside of the loops, so that it is done
3241     // only once, instead of repeating it for each pixel.
3242     if (interpolating)
3243     {
3244         for (int y = 0; y < rH; y++)
3245         {
3246             for (int x = 0; x < rW; x++)
3247             {
3248                 wxRealPoint src = wxRotatePoint (x + x1a, y + y1a, cos_angle, -sin_angle, p0);
3249
3250                 if (-0.25 < src.x && src.x < w - 0.75 &&
3251                     -0.25 < src.y && src.y < h - 0.75)
3252                 {
3253                     // interpolate using the 4 enclosing grid-points.  Those
3254                     // points can be obtained using floor and ceiling of the
3255                     // exact coordinates of the point
3256                     int x1, y1, x2, y2;
3257
3258                     if (0 < src.x && src.x < w - 1)
3259                     {
3260                         x1 = wxRound(floor(src.x));
3261                         x2 = wxRound(ceil(src.x));
3262                     }
3263                     else    // else means that x is near one of the borders (0 or width-1)
3264                     {
3265                         x1 = x2 = wxRound (src.x);
3266                     }
3267
3268                     if (0 < src.y && src.y < h - 1)
3269                     {
3270                         y1 = wxRound(floor(src.y));
3271                         y2 = wxRound(ceil(src.y));
3272                     }
3273                     else
3274                     {
3275                         y1 = y2 = wxRound (src.y);
3276                     }
3277
3278                     // get four points and the distances (square of the distance,
3279                     // for efficiency reasons) for the interpolation formula
3280
3281                     // GRG: Do not calculate the points until they are
3282                     //      really needed -- this way we can calculate
3283                     //      just one, instead of four, if d1, d2, d3
3284                     //      or d4 are < wxROTATE_EPSILON
3285
3286                     const double d1 = (src.x - x1) * (src.x - x1) + (src.y - y1) * (src.y - y1);
3287                     const double d2 = (src.x - x2) * (src.x - x2) + (src.y - y1) * (src.y - y1);
3288                     const double d3 = (src.x - x2) * (src.x - x2) + (src.y - y2) * (src.y - y2);
3289                     const double d4 = (src.x - x1) * (src.x - x1) + (src.y - y2) * (src.y - y2);
3290
3291                     // Now interpolate as a weighted average of the four surrounding
3292                     // points, where the weights are the distances to each of those points
3293
3294                     // If the point is exactly at one point of the grid of the source
3295                     // image, then don't interpolate -- just assign the pixel
3296
3297                     // d1,d2,d3,d4 are positive -- no need for abs()
3298                     if (d1 < wxROTATE_EPSILON)
3299                     {
3300                         unsigned char *p = data[y1] + (3 * x1);
3301                         *(dst++) = *(p++);
3302                         *(dst++) = *(p++);
3303                         *(dst++) = *p;
3304
3305                         if (has_alpha)
3306                             *(alpha_dst++) = *(alpha[y1] + x1);
3307                     }
3308                     else if (d2 < wxROTATE_EPSILON)
3309                     {
3310                         unsigned char *p = data[y1] + (3 * x2);
3311                         *(dst++) = *(p++);
3312                         *(dst++) = *(p++);
3313                         *(dst++) = *p;
3314
3315                         if (has_alpha)
3316                             *(alpha_dst++) = *(alpha[y1] + x2);
3317                     }
3318                     else if (d3 < wxROTATE_EPSILON)
3319                     {
3320                         unsigned char *p = data[y2] + (3 * x2);
3321                         *(dst++) = *(p++);
3322                         *(dst++) = *(p++);
3323                         *(dst++) = *p;
3324
3325                         if (has_alpha)
3326                             *(alpha_dst++) = *(alpha[y2] + x2);
3327                     }
3328                     else if (d4 < wxROTATE_EPSILON)
3329                     {
3330                         unsigned char *p = data[y2] + (3 * x1);
3331                         *(dst++) = *(p++);
3332                         *(dst++) = *(p++);
3333                         *(dst++) = *p;
3334
3335                         if (has_alpha)
3336                             *(alpha_dst++) = *(alpha[y2] + x1);
3337                     }
3338                     else
3339                     {
3340                         // weights for the weighted average are proportional to the inverse of the distance
3341                         unsigned char *v1 = data[y1] + (3 * x1);
3342                         unsigned char *v2 = data[y1] + (3 * x2);
3343                         unsigned char *v3 = data[y2] + (3 * x2);
3344                         unsigned char *v4 = data[y2] + (3 * x1);
3345
3346                         const double w1 = 1/d1, w2 = 1/d2, w3 = 1/d3, w4 = 1/d4;
3347
3348                         // GRG: Unrolled.
3349
3350                         *(dst++) = (unsigned char)
3351                             ( (w1 * *(v1++) + w2 * *(v2++) +
3352                                w3 * *(v3++) + w4 * *(v4++)) /
3353                               (w1 + w2 + w3 + w4) );
3354                         *(dst++) = (unsigned char)
3355                             ( (w1 * *(v1++) + w2 * *(v2++) +
3356                                w3 * *(v3++) + w4 * *(v4++)) /
3357                               (w1 + w2 + w3 + w4) );
3358                         *(dst++) = (unsigned char)
3359                             ( (w1 * *v1 + w2 * *v2 +
3360                                w3 * *v3 + w4 * *v4) /
3361                               (w1 + w2 + w3 + w4) );
3362
3363                         if (has_alpha)
3364                         {
3365                             v1 = alpha[y1] + (x1);
3366                             v2 = alpha[y1] + (x2);
3367                             v3 = alpha[y2] + (x2);
3368                             v4 = alpha[y2] + (x1);
3369
3370                             *(alpha_dst++) = (unsigned char)
3371                                 ( (w1 * *v1 + w2 * *v2 +
3372                                    w3 * *v3 + w4 * *v4) /
3373                                   (w1 + w2 + w3 + w4) );
3374                         }
3375                     }
3376                 }
3377                 else
3378                 {
3379                     *(dst++) = blank_r;
3380                     *(dst++) = blank_g;
3381                     *(dst++) = blank_b;
3382
3383                     if (has_alpha)
3384                         *(alpha_dst++) = 0;
3385                 }
3386             }
3387         }
3388     }
3389     else // not interpolating
3390     {
3391         for (int y = 0; y < rH; y++)
3392         {
3393             for (int x = 0; x < rW; x++)
3394             {
3395                 wxRealPoint src = wxRotatePoint (x + x1a, y + y1a, cos_angle, -sin_angle, p0);
3396
3397                 const int xs = wxRound (src.x);      // wxRound rounds to the
3398                 const int ys = wxRound (src.y);      // closest integer
3399
3400                 if (0 <= xs && xs < w && 0 <= ys && ys < h)
3401                 {
3402                     unsigned char *p = data[ys] + (3 * xs);
3403                     *(dst++) = *(p++);
3404                     *(dst++) = *(p++);
3405                     *(dst++) = *p;
3406
3407                     if (has_alpha)
3408                         *(alpha_dst++) = *(alpha[ys] + (xs));
3409                 }
3410                 else
3411                 {
3412                     *(dst++) = blank_r;
3413                     *(dst++) = blank_g;
3414                     *(dst++) = blank_b;
3415
3416                     if (has_alpha)
3417                         *(alpha_dst++) = 255;
3418                 }
3419             }
3420         }
3421     }
3422
3423     delete [] data;
3424     delete [] alpha;
3425
3426     return rotated;
3427 }
3428
3429
3430
3431
3432
3433 // A module to allow wxImage initialization/cleanup
3434 // without calling these functions from app.cpp or from
3435 // the user's application.
3436
3437 class wxImageModule: public wxModule
3438 {
3439 DECLARE_DYNAMIC_CLASS(wxImageModule)
3440 public:
3441     wxImageModule() {}
3442     bool OnInit() { wxImage::InitStandardHandlers(); return true; }
3443     void OnExit() { wxImage::CleanUpHandlers(); }
3444 };
3445
3446 IMPLEMENT_DYNAMIC_CLASS(wxImageModule, wxModule)
3447
3448
3449 #endif // wxUSE_IMAGE