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