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