X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/79fa23744b2c622ebe9ff89a3ee8c8ec8017ee3b..8adb5d455797d5b656ef677c74359e5a578b539f:/src/common/image.cpp

diff --git a/src/common/image.cpp b/src/common/image.cpp
index a18a4473bb..289eb78759 100644
--- a/src/common/image.cpp
+++ b/src/common/image.cpp
@@ -31,6 +31,7 @@
 #include "wx/wfstream.h"
 #include "wx/intl.h"
 #include "wx/module.h"
+#include "wx/hash.h"
 
 // For memcpy
 #include <string.h>
@@ -49,39 +50,53 @@ class wxImageRefData: public wxObjectRefData
 {
 public:
     wxImageRefData();
-    ~wxImageRefData();
+    virtual ~wxImageRefData();
 
     int             m_width;
     int             m_height;
     unsigned char  *m_data;
+
     bool            m_hasMask;
     unsigned char   m_maskRed,m_maskGreen,m_maskBlue;
+
+    // alpha channel data, may be NULL for the formats without alpha support
+    unsigned char  *m_alpha;
+
     bool            m_ok;
     bool            m_static;
+
 #if wxUSE_PALETTE
     wxPalette       m_palette;
 #endif // wxUSE_PALETTE
+
     wxArrayString   m_optionNames;
     wxArrayString   m_optionValues;
+
+    DECLARE_NO_COPY_CLASS(wxImageRefData)
 };
 
 wxImageRefData::wxImageRefData()
 {
     m_width = 0;
     m_height = 0;
-    m_data = (unsigned char*) NULL;
-    m_ok = FALSE;
+    m_data =
+    m_alpha = (unsigned char *) NULL;
+
     m_maskRed = 0;
     m_maskGreen = 0;
     m_maskBlue = 0;
     m_hasMask = FALSE;
+
+    m_ok = FALSE;
     m_static = FALSE;
 }
 
 wxImageRefData::~wxImageRefData()
 {
-    if (m_data && !m_static)
+    if ( !m_static )
         free( m_data );
+
+    free(m_alpha);
 }
 
 wxList wxImage::sm_handlers;
@@ -98,9 +113,9 @@ wxImage::wxImage()
 {
 }
 
-wxImage::wxImage( int width, int height )
+wxImage::wxImage( int width, int height, bool clear )
 {
-    Create( width, height );
+    Create( width, height, clear );
 }
 
 wxImage::wxImage( int width, int height, unsigned char* data, bool static_data )
@@ -141,7 +156,7 @@ wxImage::wxImage( const wxImage* image )
     if (image) Ref(*image);
 }
 
-void wxImage::Create( int width, int height )
+void wxImage::Create( int width, int height, bool clear )
 {
     UnRef();
 
@@ -150,7 +165,7 @@ void wxImage::Create( int width, int height )
     M_IMGDATA->m_data = (unsigned char *) malloc( width*height*3 );
     if (M_IMGDATA->m_data)
     {
-        for (int l = 0; l < width*height*3; l++) M_IMGDATA->m_data[l] = 0;
+        if (clear) memset(M_IMGDATA->m_data, 0, width*height*3);
 
         M_IMGDATA->m_width = width;
         M_IMGDATA->m_height = height;
@@ -193,88 +208,178 @@ wxImage wxImage::Copy() const
 
     wxCHECK_MSG( Ok(), image, wxT("invalid image") );
 
-    image.Create( M_IMGDATA->m_width, M_IMGDATA->m_height );
+    image.Create( M_IMGDATA->m_width, M_IMGDATA->m_height, false );
 
-    char unsigned *data = image.GetData();
+    unsigned char *data = image.GetData();
 
     wxCHECK_MSG( data, image, wxT("unable to create image") );
 
-    if (M_IMGDATA->m_hasMask)
-        image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
+    image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
+    image.SetMask( M_IMGDATA->m_hasMask );
 
     memcpy( data, GetData(), M_IMGDATA->m_width*M_IMGDATA->m_height*3 );
 
     return image;
 }
 
-wxImage wxImage::Scale( int width, int height ) const
+wxImage wxImage::ShrinkBy( int xFactor , int yFactor ) const
 {
+    if( xFactor == 1 && yFactor == 1 )
+        return Copy() ;
+        
     wxImage image;
 
     wxCHECK_MSG( Ok(), image, wxT("invalid image") );
 
     // can't scale to/from 0 size
-    wxCHECK_MSG( (width > 0) && (height > 0), image,
+    wxCHECK_MSG( (xFactor > 0) && (yFactor > 0), image,
                  wxT("invalid new image size") );
 
     long old_height = M_IMGDATA->m_height,
          old_width  = M_IMGDATA->m_width;
+         
     wxCHECK_MSG( (old_height > 0) && (old_width > 0), image,
                  wxT("invalid old image size") );
 
-    image.Create( width, height );
+    long width = old_width / xFactor ;
+    long height = old_height / yFactor ;
+
+    image.Create( width, height, false );
 
     char unsigned *data = image.GetData();
 
     wxCHECK_MSG( data, image, wxT("unable to create image") );
 
+    bool hasMask = false ;
+    unsigned char maskRed = 0;
+    unsigned char maskGreen = 0;
+    unsigned char maskBlue =0 ;
     if (M_IMGDATA->m_hasMask)
     {
+        hasMask = true ;
+        maskRed = M_IMGDATA->m_maskRed;
+        maskGreen = M_IMGDATA->m_maskGreen;
+        maskBlue =M_IMGDATA->m_maskBlue ;
+      
         image.SetMaskColour( M_IMGDATA->m_maskRed,
                              M_IMGDATA->m_maskGreen,
                              M_IMGDATA->m_maskBlue );
     }
-
     char unsigned *source_data = M_IMGDATA->m_data;
     char unsigned *target_data = data;
-
-#if 0
-    // This is nonsense, RR.
-
-    // We do (x, y) -> (x, y)*oldSize/newSize but the valid values of x and y
-    // are from 0 to size-1, hence all decrement the sizes
-    long old_old_width = old_width;
-    old_height--;
-    old_width--;
-    height--;
-    width--;
-    for ( long j = 0; j <= height; j++ )
+    
+    for (long y = 0; y < height; y++)
     {
-        // don't crash for images with height == 1
-        long y_offset = height ? (j * old_height / height)* old_old_width : 0;
-
-        for ( long i = 0; i <= width; i++ )
+        for (long x = 0; x < width; x++)
         {
-            long x_offset = width ? (i * old_width) / width : 0;
-
-            memcpy( target_data, source_data + 3*(y_offset + x_offset), 3 );
-            target_data += 3;
+            unsigned long avgRed = 0 ;
+            unsigned long avgGreen = 0;
+            unsigned long avgBlue = 0;
+            unsigned long counter = 0 ;
+            // determine average
+            for ( int y1 = 0 ; y1 < yFactor ; ++y1 )
+            {
+                long y_offset = (y * yFactor + y1) * old_width;
+                for ( int x1 = 0 ; x1 < xFactor ; ++x1 )
+                {
+                    unsigned char *pixel = source_data + 3 * ( y_offset + x * xFactor + x1 ) ;
+                    unsigned char red = pixel[0] ;
+                    unsigned char green = pixel[1] ;
+                    unsigned char blue = pixel[2] ;
+                    if ( !hasMask || red != maskRed || green != maskGreen || blue != maskBlue )
+                    {
+                        avgRed += red ;
+                        avgGreen += green ;
+                        avgBlue += blue ;
+                        counter++ ;
+                    }
+                }
+            }
+            if ( counter == 0 )
+            {
+                *(target_data++) = M_IMGDATA->m_maskRed ;
+                *(target_data++) = M_IMGDATA->m_maskGreen ;
+                *(target_data++) = M_IMGDATA->m_maskBlue ;
+            }
+            else
+            {
+                *(target_data++) = avgRed / counter ;
+                *(target_data++) = avgGreen / counter ;
+                *(target_data++) = avgBlue / counter ;
+            }
         }
     }
-#else
-    for (long j = 0; j < height; j++)
+
+    // In case this is a cursor, make sure the hotspot is scalled accordingly:
+    if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_X) )
+        image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X,
+                (GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_X))/xFactor);
+    if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y) )
+        image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y,
+                (GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_Y))/yFactor);
+
+    return image;
+}
+
+wxImage wxImage::Scale( int width, int height ) const
+{
+    wxImage image;
+
+    wxCHECK_MSG( Ok(), image, wxT("invalid image") );
+
+    // can't scale to/from 0 size
+    wxCHECK_MSG( (width > 0) && (height > 0), image,
+                 wxT("invalid new image size") );
+
+    long old_height = M_IMGDATA->m_height,
+         old_width  = M_IMGDATA->m_width;
+    wxCHECK_MSG( (old_height > 0) && (old_width > 0), image,
+                 wxT("invalid old image size") );
+
+    if ( old_width % width == 0 && old_width >= width &&
+        old_height % height == 0 && old_height >= height )
     {
-        long y_offset = (j * old_height / height) * old_width;
+        return ShrinkBy( old_width / width , old_height / height ) ;
+    }
+    image.Create( width, height, false );
 
-        for (long i = 0; i < width; i++)
+    unsigned char *data = image.GetData();
+
+    wxCHECK_MSG( data, image, wxT("unable to create image") );
+
+    if (M_IMGDATA->m_hasMask)
+    {
+        image.SetMaskColour( M_IMGDATA->m_maskRed,
+                             M_IMGDATA->m_maskGreen,
+                             M_IMGDATA->m_maskBlue );
+    }
+
+    unsigned char *source_data = M_IMGDATA->m_data;
+    unsigned char *target_data = data;
+
+    long x_delta = (old_width<<16) / width;
+    long y_delta = (old_height<<16) / height;
+
+    unsigned char* dest_pixel = target_data;
+
+    long y = 0;
+    for ( long j = 0; j < height; j++ )
         {
-            memcpy( target_data,
-                source_data + 3*(y_offset + ((i * old_width )/ width)),
-                3 );
-            target_data += 3;
+        unsigned char* src_line = &source_data[(y>>16)*old_width*3];
+
+        long x = 0;
+        for ( long i = 0; i < width; i++ )
+        {
+             unsigned char* src_pixel = &src_line[(x>>16)*3];
+             dest_pixel[0] = src_pixel[0];
+             dest_pixel[1] = src_pixel[1];
+             dest_pixel[2] = src_pixel[2];
+             dest_pixel += 3;
+             x += x_delta;
         }
+
+        y += y_delta;
     }
-#endif
 
     // In case this is a cursor, make sure the hotspot is scalled accordingly:
     if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_X) )
@@ -293,9 +398,9 @@ wxImage wxImage::Rotate90( bool clockwise ) const
 
     wxCHECK_MSG( Ok(), image, wxT("invalid image") );
 
-    image.Create( M_IMGDATA->m_height, M_IMGDATA->m_width );
+    image.Create( M_IMGDATA->m_height, M_IMGDATA->m_width, false );
 
-    char unsigned *data = image.GetData();
+    unsigned char *data = image.GetData();
 
     wxCHECK_MSG( data, image, wxT("unable to create image") );
 
@@ -305,8 +410,8 @@ wxImage wxImage::Rotate90( bool clockwise ) const
     long height = M_IMGDATA->m_height;
     long width  = M_IMGDATA->m_width;
 
-    char unsigned *source_data = M_IMGDATA->m_data;
-    char unsigned *target_data;
+    unsigned char *source_data = M_IMGDATA->m_data;
+    unsigned char *target_data;
 
     for (long j = 0; j < height; j++)
     {
@@ -330,9 +435,9 @@ wxImage wxImage::Mirror( bool horizontally ) const
 
     wxCHECK_MSG( Ok(), image, wxT("invalid image") );
 
-    image.Create( M_IMGDATA->m_width, M_IMGDATA->m_height );
+    image.Create( M_IMGDATA->m_width, M_IMGDATA->m_height, false );
 
-    char unsigned *data = image.GetData();
+    unsigned char *data = image.GetData();
 
     wxCHECK_MSG( data, image, wxT("unable to create image") );
 
@@ -342,8 +447,8 @@ wxImage wxImage::Mirror( bool horizontally ) const
     long height = M_IMGDATA->m_height;
     long width  = M_IMGDATA->m_width;
 
-    char unsigned *source_data = M_IMGDATA->m_data;
-    char unsigned *target_data;
+    unsigned char *source_data = M_IMGDATA->m_data;
+    unsigned char *target_data;
 
     if (horizontally)
     {
@@ -384,9 +489,9 @@ wxImage wxImage::GetSubImage( const wxRect &rect ) const
     int subwidth=rect.GetWidth();
     const int subheight=rect.GetHeight();
 
-    image.Create( subwidth, subheight );
+    image.Create( subwidth, subheight, false );
 
-    char unsigned *subdata = image.GetData(), *data=GetData();
+    unsigned char *subdata = image.GetData(), *data=GetData();
 
     wxCHECK_MSG( subdata, image, wxT("unable to create image") );
 
@@ -494,7 +599,7 @@ void wxImage::Replace( unsigned char r1, unsigned char g1, unsigned char b1,
 {
     wxCHECK_RET( Ok(), wxT("invalid image") );
 
-    char unsigned *data = GetData();
+    unsigned char *data = GetData();
 
     const int w = GetWidth();
     const int h = GetHeight();
@@ -518,9 +623,9 @@ wxImage wxImage::ConvertToMono( unsigned char r, unsigned char g, unsigned char
 
     wxCHECK_MSG( Ok(), image, wxT("invalid image") );
 
-    image.Create( M_IMGDATA->m_width, M_IMGDATA->m_height );
+    image.Create( M_IMGDATA->m_width, M_IMGDATA->m_height, false );
 
-    char unsigned *data = image.GetData();
+    unsigned char *data = image.GetData();
 
     wxCHECK_MSG( data, image, wxT("unable to create image") );
 
@@ -535,8 +640,8 @@ wxImage wxImage::ConvertToMono( unsigned char r, unsigned char g, unsigned char
 
     long size = M_IMGDATA->m_height * M_IMGDATA->m_width;
 
-    char unsigned *srcd = M_IMGDATA->m_data;
-    char unsigned *tard = image.GetData();
+    unsigned char *srcd = M_IMGDATA->m_data;
+    unsigned char *tard = image.GetData();
 
     for ( long i = 0; i < size; i++, srcd += 3, tard += 3 )
     {
@@ -615,14 +720,14 @@ bool wxImage::Ok() const
     return data && data->m_ok && data->m_width && data->m_height;
 }
 
-char unsigned *wxImage::GetData() const
+unsigned char *wxImage::GetData() const
 {
-    wxCHECK_MSG( Ok(), (char unsigned *)NULL, wxT("invalid image") );
+    wxCHECK_MSG( Ok(), (unsigned char *)NULL, wxT("invalid image") );
 
     return M_IMGDATA->m_data;
 }
 
-void wxImage::SetData( char unsigned *data )
+void wxImage::SetData( unsigned char *data )
 {
     wxCHECK_RET( Ok(), wxT("invalid image") );
 
@@ -642,7 +747,7 @@ void wxImage::SetData( char unsigned *data )
     m_refData = newRefData;
 }
 
-void wxImage::SetData( char unsigned *data, int new_width, int new_height )
+void wxImage::SetData( unsigned char *data, int new_width, int new_height )
 {
     wxImageRefData *newRefData = new wxImageRefData();
 
@@ -670,6 +775,59 @@ void wxImage::SetData( char unsigned *data, int new_width, int new_height )
     m_refData = newRefData;
 }
 
+// ----------------------------------------------------------------------------
+// alpha channel support
+// ----------------------------------------------------------------------------
+
+void wxImage::SetAlpha(int x, int y, unsigned char alpha)
+{
+    wxCHECK_RET( Ok() && HasAlpha(), wxT("invalid image or no alpha channel") );
+
+    int w = M_IMGDATA->m_width,
+        h = M_IMGDATA->m_height;
+
+    wxCHECK_RET( x >=0 && y >= 0 && x < w && y < h, wxT("invalid image index") );
+
+    M_IMGDATA->m_alpha[y*w + x] = alpha;
+}
+
+unsigned char wxImage::GetAlpha(int x, int y)
+{
+    wxCHECK_MSG( Ok() && HasAlpha(), 0, wxT("invalid image or no alpha channel") );
+
+    int w = M_IMGDATA->m_width,
+        h = M_IMGDATA->m_height;
+
+    wxCHECK_MSG( x >=0 && y >= 0 && x < w && y < h, 0, wxT("invalid image index") );
+
+    return M_IMGDATA->m_alpha[y*w + x];
+}
+
+void wxImage::SetAlpha( unsigned char *alpha )
+{
+    wxCHECK_RET( Ok(), wxT("invalid image") );
+
+    if ( !alpha )
+    {
+        alpha = (unsigned char *)
+                    malloc(M_IMGDATA->m_width*M_IMGDATA->m_height*3);
+    }
+
+    delete [] M_IMGDATA->m_alpha;
+    M_IMGDATA->m_alpha = alpha;
+}
+
+unsigned char *wxImage::GetAlpha() const
+{
+    wxCHECK_MSG( Ok(), (unsigned char *)NULL, wxT("invalid image") );
+
+    return M_IMGDATA->m_alpha;
+}
+
+// ----------------------------------------------------------------------------
+// mask support
+// ----------------------------------------------------------------------------
+
 void wxImage::SetMaskColour( unsigned char r, unsigned char g, unsigned char b )
 {
     wxCHECK_RET( Ok(), wxT("invalid image") );
@@ -729,73 +887,26 @@ int wxImage::GetHeight() const
     return M_IMGDATA->m_height;
 }
 
-
-bool wxImage::FindFirstUnusedColour(
-            unsigned char *r, unsigned char *g, unsigned char *b,
-            unsigned char startR, unsigned char startG, unsigned char startB) const
-{
-    wxImageHistogram histogram;
-    unsigned long key;
-   
-    ComputeHistogram(histogram);
-    
-    unsigned char r2 = startR;
-    unsigned char g2 = startG;
-    unsigned char b2 = startB;
-    
-    key = (r2 << 16) | (g2 << 8) | b2;
-
-    while ( histogram.find(key) != histogram.end() )
-    {
-        // color already used
-        r2++;
-        if ( r2 >= 255 )
-        {
-            r2 = 0;
-            g2++;
-            if ( g2 >= 255 )
-            {
-                g2 = 0;
-                b2++;
-                if ( b2 >= 255 )
-                {
-                    wxLogError( _("GetUnusedColour:: No Unused Color in image ") );            
-                    return FALSE;                              
-                }
-            }
-        }
-        
-        key = (r2 << 16) | (g2 << 8) | b2;
-    }
-    
-    if (r) *r = r2;
-    if (g) *g = g2;
-    if (b) *b = b2;
-    
-    return TRUE;
-}
-
-
-bool wxImage::SetMaskFromImage(const wxImage& mask, 
+bool wxImage::SetMaskFromImage(const wxImage& mask,
                                unsigned char mr, unsigned char mg, unsigned char mb)
 {
     // check that the images are the same size
     if ( (M_IMGDATA->m_height != mask.GetHeight() ) || (M_IMGDATA->m_width != mask.GetWidth () ) )
     {
-        wxLogError( _("Image and Mask have different sizes") );            
+        wxLogError( _("Image and Mask have different sizes") );
         return FALSE;
     }
-    
+
     // find unused colour
     unsigned char r,g,b ;
     if (!FindFirstUnusedColour(&r, &g, &b))
     {
-        wxLogError( _("No Unused Color in image being masked") );            
+        wxLogError( _("No Unused Color in image being masked") );
         return FALSE ;
     }
-        
-    char unsigned *imgdata = GetData();
-    char unsigned *maskdata = mask.GetData();
+
+    unsigned char *imgdata = GetData();
+    unsigned char *maskdata = mask.GetData();
 
     const int w = GetWidth();
     const int h = GetHeight();
@@ -817,7 +928,7 @@ bool wxImage::SetMaskFromImage(const wxImage& mask,
 
     SetMaskColour(r, g, b);
     SetMask(TRUE);
-    
+
     return TRUE;
 }
 
@@ -944,7 +1055,7 @@ bool wxImage::LoadFile( const wxString& filename, const wxString& mimetype, int
 bool wxImage::SaveFile( const wxString& filename ) const
 {
     wxString ext = filename.AfterLast('.').Lower();
-    
+
     wxImageHandler * pHandler = FindHandler(ext, -1);
     if (pHandler)
     {
@@ -964,7 +1075,7 @@ bool wxImage::SaveFile( const wxString& filename, int type ) const
 
     wxFileOutputStream stream(filename);
 
-    if ( stream.LastError() == wxStream_NOERROR )
+    if ( stream.IsOk() )
     {
         wxBufferedOutputStream bstream( stream );
         return SaveFile(bstream, type);
@@ -981,7 +1092,7 @@ bool wxImage::SaveFile( const wxString& filename, const wxString& mimetype ) con
 
     wxFileOutputStream stream(filename);
 
-    if ( stream.LastError() == wxStream_NOERROR )
+    if ( stream.IsOk() )
     {
         wxBufferedOutputStream bstream( stream );
         return SaveFile(bstream, mimetype);
@@ -1005,10 +1116,11 @@ int wxImage::GetImageCount( const wxString &name, long type )
 {
 #if wxUSE_STREAMS
   wxFileInputStream stream(name);
-  return GetImageCount(stream, type);
-#else
-  return 0;
+  if (stream.Ok())
+      return GetImageCount(stream, type);
 #endif
+
+  return 0;
 }
 
 #if wxUSE_STREAMS
@@ -1092,7 +1204,7 @@ bool wxImage::LoadFile( wxInputStream& stream, long type, int index )
 
     handler = FindHandler(type);
 
-    if (handler == NULL)
+    if (handler == 0)
     {
         wxLogWarning( _("No image handler for type %d defined."), type );
 
@@ -1110,7 +1222,7 @@ bool wxImage::LoadFile( wxInputStream& stream, const wxString& mimetype, int ind
 
     wxImageHandler *handler = FindHandlerMime(mimetype);
 
-    if (handler == NULL)
+    if (handler == 0)
     {
         wxLogWarning( _("No image handler for type %s defined."), mimetype.GetData() );
 
@@ -1126,7 +1238,7 @@ bool wxImage::SaveFile( wxOutputStream& stream, int type ) const
 
     wxImageHandler *handler = FindHandler(type);
 
-    if (handler == NULL)
+    if (handler == 0)
     {
         wxLogWarning( _("No image handler for type %d defined."), type );
 
@@ -1142,7 +1254,7 @@ bool wxImage::SaveFile( wxOutputStream& stream, const wxString& mimetype ) const
 
     wxImageHandler *handler = FindHandlerMime(mimetype);
 
-    if (handler == NULL)
+    if (handler == 0)
     {
         wxLogWarning( _("No image handler for type %s defined."), mimetype.GetData() );
 
@@ -1158,7 +1270,23 @@ void wxImage::AddHandler( wxImageHandler *handler )
     // make sure that the memory will be freed at the program end
     sm_handlers.DeleteContents(TRUE);
 
-    sm_handlers.Append( handler );
+    // Check for an existing handler of the type being added.
+    if (FindHandler( handler->GetType() ) == 0)
+    {
+        sm_handlers.Append( handler );
+    }
+    else
+    {
+        // This is not documented behaviour, merely the simplest 'fix'
+        // for preventing duplicate additions.  If someone ever has
+        // a good reason to add and remove duplicate handlers (and they
+        // may) we should probably refcount the duplicates.
+        //   also an issue in InsertHandler below.
+
+        wxLogDebug( _T("Adding duplicate image handler for '%s'"),
+                    handler->GetName().c_str() );
+        delete handler;
+    }
 }
 
 void wxImage::InsertHandler( wxImageHandler *handler )
@@ -1166,7 +1294,18 @@ void wxImage::InsertHandler( wxImageHandler *handler )
     // make sure that the memory will be freed at the program end
     sm_handlers.DeleteContents(TRUE);
 
-    sm_handlers.Insert( handler );
+    // Check for an existing handler of the type being added.
+    if (FindHandler( handler->GetType() ) == 0)
+    {
+        sm_handlers.Insert( handler );
+    }
+    else
+    {
+        // see AddHandler for additional comments.
+        wxLogDebug( _T("Inserting duplicate image handler for '%s'"),
+                    handler->GetName().c_str() );
+        delete handler;
+    }
 }
 
 bool wxImage::RemoveHandler( const wxString& name )
@@ -1183,53 +1322,53 @@ bool wxImage::RemoveHandler( const wxString& name )
 
 wxImageHandler *wxImage::FindHandler( const wxString& name )
 {
-    wxNode *node = sm_handlers.First();
+    wxNode *node = sm_handlers.GetFirst();
     while (node)
     {
-        wxImageHandler *handler = (wxImageHandler*)node->Data();
+        wxImageHandler *handler = (wxImageHandler*)node->GetData();
         if (handler->GetName().Cmp(name) == 0) return handler;
 
-        node = node->Next();
+        node = node->GetNext();
     }
-    return (wxImageHandler *)NULL;
+    return 0;
 }
 
 wxImageHandler *wxImage::FindHandler( const wxString& extension, long bitmapType )
 {
-    wxNode *node = sm_handlers.First();
+    wxNode *node = sm_handlers.GetFirst();
     while (node)
     {
-        wxImageHandler *handler = (wxImageHandler*)node->Data();
+        wxImageHandler *handler = (wxImageHandler*)node->GetData();
         if ( (handler->GetExtension().Cmp(extension) == 0) &&
             (bitmapType == -1 || handler->GetType() == bitmapType) )
             return handler;
-        node = node->Next();
+        node = node->GetNext();
     }
-    return (wxImageHandler*)NULL;
+    return 0;
 }
 
 wxImageHandler *wxImage::FindHandler( long bitmapType )
 {
-    wxNode *node = sm_handlers.First();
+    wxNode *node = sm_handlers.GetFirst();
     while (node)
     {
-        wxImageHandler *handler = (wxImageHandler *)node->Data();
+        wxImageHandler *handler = (wxImageHandler *)node->GetData();
         if (handler->GetType() == bitmapType) return handler;
-        node = node->Next();
+        node = node->GetNext();
     }
-    return NULL;
+    return 0;
 }
 
 wxImageHandler *wxImage::FindHandlerMime( const wxString& mimetype )
 {
-    wxNode *node = sm_handlers.First();
+    wxNode *node = sm_handlers.GetFirst();
     while (node)
     {
-        wxImageHandler *handler = (wxImageHandler *)node->Data();
+        wxImageHandler *handler = (wxImageHandler *)node->GetData();
         if (handler->GetMimeType().IsSameAs(mimetype, FALSE)) return handler;
-        node = node->Next();
+        node = node->GetNext();
     }
-    return NULL;
+    return 0;
 }
 
 void wxImage::InitStandardHandlers()
@@ -1237,25 +1376,22 @@ void wxImage::InitStandardHandlers()
 #if wxUSE_STREAMS
     AddHandler(new wxBMPHandler);
 #endif // wxUSE_STREAMS
-
-#if wxUSE_XPM && !defined(__WXGTK__) && !defined(__WXMOTIF__)
-    AddHandler(new wxXPMHandler);
-#endif
 }
 
 void wxImage::CleanUpHandlers()
 {
-    wxNode *node = sm_handlers.First();
+    wxNode *node = sm_handlers.GetFirst();
     while (node)
     {
-        wxImageHandler *handler = (wxImageHandler *)node->Data();
-        wxNode *next = node->Next();
+        wxImageHandler *handler = (wxImageHandler *)node->GetData();
+        wxNode *next = node->GetNext();
         delete handler;
         delete node;
         node = next;
     }
 }
 
+
 //-----------------------------------------------------------------------------
 // wxImageHandler
 //-----------------------------------------------------------------------------
@@ -1286,12 +1422,32 @@ bool wxImageHandler::CanRead( const wxString& name )
         return CanRead(stream);
     }
 
-    else {
-        wxLogError( _("Can't check image format of file '%s': file does not exist."), name.c_str() );
+    wxLogError( _("Can't check image format of file '%s': file does not exist."), name.c_str() );
 
+    return FALSE;
+}
+
+bool wxImageHandler::CallDoCanRead(wxInputStream& stream)
+{
+    off_t posOld = stream.TellI();
+    if ( posOld == wxInvalidOffset )
+    {
+        // can't test unseekable stream
+        return FALSE;
+    }
+
+    bool ok = DoCanRead(stream);
+
+    // restore the old position to be able to test other formats and so on
+    if ( stream.SeekI(posOld) == wxInvalidOffset )
+    {
+        wxLogDebug(_T("Failed to rewind the stream in wxImageHandler!"));
+
+        // reading would fail anyhow as we're not at the right position
         return FALSE;
     }
-//    return FALSE;
+
+    return ok;
 }
 
 #endif // wxUSE_STREAMS
@@ -1299,7 +1455,7 @@ bool wxImageHandler::CanRead( const wxString& name )
 
 
 //-----------------------------------------------------------------------------
-// Deprecated wxBitmap convertion routines
+// Deprecated wxBitmap conversion routines
 //-----------------------------------------------------------------------------
 
 #if WXWIN_COMPATIBILITY_2_2 && wxUSE_GUI
@@ -1327,7 +1483,69 @@ wxImage::wxImage( const wxBitmap &bitmap )
 #endif // WXWIN_COMPATIBILITY_2_2 && wxUSE_GUI
 
 
-//-----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+// image histogram stuff
+// ----------------------------------------------------------------------------
+
+bool
+wxImageHistogram::FindFirstUnusedColour(unsigned char *r,
+                                        unsigned char *g,
+                                        unsigned char *b,
+                                        unsigned char r2,
+                                        unsigned char b2,
+                                        unsigned char g2) const
+{
+    unsigned long key = MakeKey(r2, g2, b2);
+
+    while ( find(key) != end() )
+    {
+        // color already used
+        r2++;
+        if ( r2 >= 255 )
+        {
+            r2 = 0;
+            g2++;
+            if ( g2 >= 255 )
+            {
+                g2 = 0;
+                b2++;
+                if ( b2 >= 255 )
+                {
+                    wxLogError(_("GetUnusedColour:: No Unused Color in image ") );
+                    return FALSE;
+                }
+            }
+        }
+
+        key = MakeKey(r2, g2, b2);
+    }
+
+    if ( r )
+        *r = r2;
+    if ( g )
+        *g = g2;
+    if ( b )
+        *b = b2;
+
+    return TRUE;
+}
+
+bool
+wxImage::FindFirstUnusedColour(unsigned char *r,
+                               unsigned char *g,
+                               unsigned char *b,
+                               unsigned char r2,
+                               unsigned char b2,
+                               unsigned char g2) const
+{
+    wxImageHistogram histogram;
+
+    ComputeHistogram(histogram);
+
+    return histogram.FindFirstUnusedColour(r, g, b, r2, g2, b2);
+}
+
+
 
 // GRG, Dic/99
 // Counts and returns the number of different colours. Optionally stops
@@ -1353,7 +1571,7 @@ unsigned long wxImage::CountColours( unsigned long stopafter ) const
         r = *(p++);
         g = *(p++);
         b = *(p++);
-        key = (r << 16) | (g << 8) | b;
+        key = wxImageHistogram::MakeKey(r, g, b);
 
         if (h.Get(key) == NULL)
         {
@@ -1368,24 +1586,22 @@ unsigned long wxImage::CountColours( unsigned long stopafter ) const
 
 unsigned long wxImage::ComputeHistogram( wxImageHistogram &h ) const
 {
-    unsigned char r, g, b;
-    unsigned char *p;
-    unsigned long size, nentries, key;
+    unsigned char *p = GetData();
+    unsigned long nentries = 0;
 
     h.clear();
 
-    p = GetData();
-    size = GetWidth() * GetHeight();
-    nentries = 0;
+    const unsigned long size = GetWidth() * GetHeight();
 
-    for (unsigned long j = 0; j < size; j++)
+    unsigned char r, g, b;
+    for ( unsigned long n = 0; n < size; n++ )
     {
-        r = *(p++);
-        g = *(p++);
-        b = *(p++);
-        key = (r << 16) | (g << 8) | b;
+        r = *p++;
+        g = *p++;
+        b = *p++;
+
+        wxImageHistogramEntry& entry = h[wxImageHistogram::MakeKey(r, g, b)];
 
-        wxImageHistogramEntry& entry = h[key];
         if ( entry.value++ == 0 )
             entry.index = nentries++;
     }
@@ -1461,7 +1677,7 @@ wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool i
     int x2 = (int) ceil (wxMax (wxMax(p1.x, p2.x), wxMax(p3.x, p4.x)));
     int y2 = (int) ceil (wxMax (wxMax(p1.y, p2.y), wxMax(p3.y, p4.y)));
 
-    wxImage rotated (x2 - x1 + 1, y2 - y1 + 1);
+    wxImage rotated (x2 - x1 + 1, y2 - y1 + 1, false);
 
     if (offset_after_rotation != NULL)
     {