Make brush hatches in wxGTK consistent with wxMSW.

[wxWidgets.git] / src / common / imagbmp.cpp

diff --git a/src/common/imagbmp.cpp b/src/common/imagbmp.cpp
index 99e6a5fb281d953202ee339ac798d9c8c2afdfd9..bc6f47c85841979209d41b42b59e2d9b4d6782a0 100644 (file)
--- a/src/common/imagbmp.cpp
+++ b/src/common/imagbmp.cpp
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        imagbmp.cpp
+// Name:        src/common/imagbmp.cpp

 // Purpose:     wxImage BMP,ICO and CUR handlers
 // Author:      Robert Roebling, Chris Elliott
 // RCS-ID:      $Id$
 // Purpose:     wxImage BMP,ICO and CUR handlers
 // Author:      Robert Roebling, Chris Elliott
 // RCS-ID:      $Id$


@@ -7,44 +7,47 @@
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 

-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-#pragma implementation "imagbmp.h"
-#endif
-

 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__

-#pragma hdrstop
+    #pragma hdrstop

 #endif
 
 #endif
 

-#include "wx/defs.h"
-

 #if wxUSE_IMAGE
 
 #include "wx/imagbmp.h"
 #if wxUSE_IMAGE
 
 #include "wx/imagbmp.h"

-#include "wx/bitmap.h"
-#include "wx/debug.h"
-#include "wx/log.h"
-#include "wx/app.h"
+
+#ifndef WX_PRECOMP
+    #ifdef __WXMSW__
+        #include "wx/msw/wrapwin.h"
+    #endif
+    #include "wx/log.h"
+    #include "wx/app.h"
+    #include "wx/bitmap.h"
+    #include "wx/palette.h"
+    #include "wx/intl.h"
+    #include "wx/math.h"
+#endif
+

 #include "wx/filefn.h"
 #include "wx/wfstream.h"
 #include "wx/filefn.h"
 #include "wx/wfstream.h"

-#include "wx/intl.h"
-#include "wx/module.h"

 #include "wx/quantize.h"
 #include "wx/quantize.h"

+#include "wx/scopeguard.h"
+#include "wx/anidecod.h"

 
 // For memcpy
 #include <string.h>
 
 
 // For memcpy
 #include <string.h>
 

-#ifdef __SALFORDC__
-#ifdef FAR
-#undef FAR
-#endif
-#endif
+// ----------------------------------------------------------------------------
+// private functions
+// ----------------------------------------------------------------------------

 
 

-#ifdef __WXMSW__
-#include "wx/msw/wrapwin.h"
-#endif
+#if wxUSE_ICO_CUR
+
+static bool CanReadICOOrCUR(wxInputStream *stream, wxUint16 resourceType);
+
+#endif // wxUSE_ICO_CUR

 
 //-----------------------------------------------------------------------------
 // wxBMPHandler
 
 //-----------------------------------------------------------------------------
 // wxBMPHandler


@@ -86,12 +89,14 @@ bool wxBMPHandler::SaveDib(wxImage *image,
                            bool IsMask)
 
 {
                            bool IsMask)
 
 {

-    wxCHECK_MSG( image, false, _T("invalid pointer in wxBMPHandler::SaveFile") );
+    wxCHECK_MSG( image, false, wxT("invalid pointer in wxBMPHandler::SaveFile") );

 
     if ( !image->Ok() )
     {
         if ( verbose )
 
     if ( !image->Ok() )
     {
         if ( verbose )

+        {

             wxLogError(_("BMP: Couldn't save invalid image."));
             wxLogError(_("BMP: Couldn't save invalid image."));

+        }

         return false;
     }
 
         return false;
     }
 


@@ -125,7 +130,9 @@ bool wxBMPHandler::SaveDib(wxImage *image,
             )
         {
             if ( verbose )
             )
         {
             if ( verbose )

+            {

                 wxLogError(_("BMP: wxImage doesn't have own wxPalette."));
                 wxLogError(_("BMP: wxImage doesn't have own wxPalette."));

+            }

             return false;
         }
         bpp = 8;
             return false;
         }
         bpp = 8;


@@ -157,7 +164,7 @@ bool wxBMPHandler::SaveDib(wxImage *image,
         wxUint16  bpp;            // bits per pixel
         wxUint32  compression;    // compression method
         wxUint32  size_of_bmp;    // size of the bitmap
         wxUint16  bpp;            // bits per pixel
         wxUint32  compression;    // compression method
         wxUint32  size_of_bmp;    // size of the bitmap

-        wxUint32  h_res, v_res;   // image resolution in dpi
+        wxUint32  h_res, v_res;   // image resolution in pixels-per-meter

         wxUint32  num_clrs;       // number of colors used
         wxUint32  num_signif_clrs;// number of significant colors
     } hdr;
         wxUint32  num_clrs;       // number of colors used
         wxUint32  num_signif_clrs;// number of significant colors
     } hdr;


@@ -184,7 +191,36 @@ bool wxBMPHandler::SaveDib(wxImage *image,
     hdr.bpp = wxUINT16_SWAP_ON_BE(bpp);
     hdr.compression = 0; // RGB uncompressed
     hdr.size_of_bmp = wxUINT32_SWAP_ON_BE(row_width * image->GetHeight());
     hdr.bpp = wxUINT16_SWAP_ON_BE(bpp);
     hdr.compression = 0; // RGB uncompressed
     hdr.size_of_bmp = wxUINT32_SWAP_ON_BE(row_width * image->GetHeight());

-    hdr.h_res = hdr.v_res = wxUINT32_SWAP_ON_BE(72);  // 72dpi is standard
+
+    // get the resolution from the image options  or fall back to 72dpi standard
+    // for the BMP format if not specified
+    int hres, vres;
+    switch ( GetResolutionFromOptions(*image, &hres, &vres) )
+    {
+        default:
+            wxFAIL_MSG( wxT("unexpected image resolution units") );
+            // fall through
+
+        case wxIMAGE_RESOLUTION_NONE:
+            hres =
+            vres = 72;
+            // fall through to convert it to correct units
+
+        case wxIMAGE_RESOLUTION_INCHES:
+            // convert resolution in inches to resolution in centimeters
+            hres = (int)(10*mm2inches*hres);
+            vres = (int)(10*mm2inches*vres);
+            // fall through to convert it to resolution in meters
+
+        case wxIMAGE_RESOLUTION_CM:
+            // convert resolution in centimeters to resolution in meters
+            hres *= 100;
+            vres *= 100;
+            break;
+    }
+
+    hdr.h_res = wxUINT32_SWAP_ON_BE(hres);
+    hdr.v_res = wxUINT32_SWAP_ON_BE(vres);

     hdr.num_clrs = wxUINT32_SWAP_ON_BE(palette_size); // # colors in colormap
     hdr.num_signif_clrs = 0;     // all colors are significant
 
     hdr.num_clrs = wxUINT32_SWAP_ON_BE(palette_size); // # colors in colormap
     hdr.num_signif_clrs = 0;     // all colors are significant
 


@@ -200,7 +236,9 @@ bool wxBMPHandler::SaveDib(wxImage *image,
            )
         {
             if (verbose)
            )
         {
             if (verbose)

+            {

                 wxLogError(_("BMP: Couldn't write the file (Bitmap) header."));
                 wxLogError(_("BMP: Couldn't write the file (Bitmap) header."));

+                }

             return false;
         }
     }
             return false;
         }
     }


@@ -221,7 +259,9 @@ bool wxBMPHandler::SaveDib(wxImage *image,
            )
         {
             if (verbose)
            )
         {
             if (verbose)

+            {

                 wxLogError(_("BMP: Couldn't write the file (BitmapInfo) header."));
                 wxLogError(_("BMP: Couldn't write the file (BitmapInfo) header."));

+            }

             return false;
         }
     }
             return false;
         }
     }


@@ -295,7 +335,9 @@ bool wxBMPHandler::SaveDib(wxImage *image,
             if ( !stream.Write(rgbquad, palette_size*4) )
             {
                 if (verbose)
             if ( !stream.Write(rgbquad, palette_size*4) )
             {
                 if (verbose)

+                {

                     wxLogError(_("BMP: Couldn't write RGB color map."));
                     wxLogError(_("BMP: Couldn't write RGB color map."));

+                }

                 delete[] rgbquad;
 #if wxUSE_PALETTE
                 delete palette;
                 delete[] rgbquad;
 #if wxUSE_PALETTE
                 delete palette;


@@ -428,7 +470,9 @@ bool wxBMPHandler::SaveDib(wxImage *image,
         if ( !stream.Write(buffer, row_width) )
         {
             if (verbose)
         if ( !stream.Write(buffer, row_width) )
         {
             if (verbose)

+            {

                 wxLogError(_("BMP: Couldn't write data."));
                 wxLogError(_("BMP: Couldn't write data."));

+            }

             delete[] buffer;
 #if wxUSE_PALETTE
             delete palette;
             delete[] buffer;
 #if wxUSE_PALETTE
             delete palette;


@@ -447,18 +491,20 @@ bool wxBMPHandler::SaveDib(wxImage *image,
 }
 
 
 }
 
 

-typedef struct
+struct BMPPalette

 {
 {

+    static void Free(BMPPalette* pal) { delete [] pal; }
+

     unsigned char r, g, b;
     unsigned char r, g, b;

-}  _cmap;
+};

 
 bool wxBMPHandler::DoLoadDib(wxImage * image, int width, int height,
                              int bpp, int ncolors, int comp,
                              wxFileOffset bmpOffset, wxInputStream& stream,
                              bool verbose, bool IsBmp, bool hasPalette)
 {
 
 bool wxBMPHandler::DoLoadDib(wxImage * image, int width, int height,
                              int bpp, int ncolors, int comp,
                              wxFileOffset bmpOffset, wxInputStream& stream,
                              bool verbose, bool IsBmp, bool hasPalette)
 {

-    wxInt32         aDword, rmask = 0, gmask = 0, bmask = 0;
-    int             rshift = 0, gshift = 0, bshift = 0;
+    wxInt32         aDword, rmask = 0, gmask = 0, bmask = 0, amask = 0;
+    int             rshift = 0, gshift = 0, bshift = 0, ashift = 0;

     int             rbits = 0, gbits = 0, bbits = 0;
     wxInt32         dbuf[4];
     wxInt8          bbuf[4];
     int             rbits = 0, gbits = 0, bbits = 0;
     wxInt32         dbuf[4];
     wxInt8          bbuf[4];


@@ -466,20 +512,26 @@ bool wxBMPHandler::DoLoadDib(wxImage * image, int width, int height,
     wxUint16        aWord;
 
     // allocate space for palette if needed:
     wxUint16        aWord;
 
     // allocate space for palette if needed:

-    _cmap *cmap;
+    BMPPalette *cmap;

 
     if ( bpp < 16 )
     {
 
     if ( bpp < 16 )
     {

-        cmap = new _cmap[ncolors];
+        cmap = new BMPPalette[ncolors];

         if ( !cmap )
         {
             if (verbose)
         if ( !cmap )
         {
             if (verbose)

+            {

                 wxLogError(_("BMP: Couldn't allocate memory."));
                 wxLogError(_("BMP: Couldn't allocate memory."));

+            }

             return false;
         }
     }
             return false;
         }
     }

-    else
+    else // no palette
+    {

         cmap = NULL;
         cmap = NULL;

+    }
+
+    wxON_BLOCK_EXIT1(&BMPPalette::Free, cmap);

 
     // destroy existing here instead of:
     image->Destroy();
 
     // destroy existing here instead of:
     image->Destroy();


@@ -490,12 +542,32 @@ bool wxBMPHandler::DoLoadDib(wxImage * image, int width, int height,
     if ( !ptr )
     {
         if ( verbose )
     if ( !ptr )
     {
         if ( verbose )

+        {

             wxLogError( _("BMP: Couldn't allocate memory.") );
             wxLogError( _("BMP: Couldn't allocate memory.") );

-        if ( cmap )
-            delete[] cmap;
+        }

         return false;
     }
 
         return false;
     }
 

+    unsigned char *alpha;
+    if ( bpp == 32 )
+    {
+        // tell the image to allocate an alpha buffer
+        image->SetAlpha();
+        alpha = image->GetAlpha();
+        if ( !alpha )
+        {
+            if ( verbose )
+            {
+                wxLogError(_("BMP: Couldn't allocate memory."));
+            }
+            return false;
+        }
+    }
+    else // no alpha
+    {
+        alpha = NULL;
+    }
+

     // Reading the palette, if it exists:
     if ( bpp < 16 && ncolors != 0 )
     {
     // Reading the palette, if it exists:
     if ( bpp < 16 && ncolors != 0 )
     {


@@ -537,7 +609,7 @@ bool wxBMPHandler::DoLoadDib(wxImage * image, int width, int height,
     {
         if ( comp == BI_BITFIELDS )
         {
     {
         if ( comp == BI_BITFIELDS )
         {

-            int bit = 0;
+            int bit;

             stream.Read(dbuf, 4 * 3);
             rmask = wxINT32_SWAP_ON_BE(dbuf[0]);
             gmask = wxINT32_SWAP_ON_BE(dbuf[1]);
             stream.Read(dbuf, 4 * 3);
             rmask = wxINT32_SWAP_ON_BE(dbuf[0]);
             gmask = wxINT32_SWAP_ON_BE(dbuf[1]);


@@ -580,6 +652,9 @@ bool wxBMPHandler::DoLoadDib(wxImage * image, int width, int height,
             rmask = 0x00FF0000;
             gmask = 0x0000FF00;
             bmask = 0x000000FF;
             rmask = 0x00FF0000;
             gmask = 0x0000FF00;
             bmask = 0x000000FF;

+            amask = 0xFF000000;
+
+            ashift = 24;

             rshift = 16;
             gshift = 8;
             bshift = 0;
             rshift = 16;
             gshift = 8;
             bshift = 0;


@@ -593,7 +668,15 @@ bool wxBMPHandler::DoLoadDib(wxImage * image, int width, int height,
      * Reading the image data
      */
     if ( IsBmp )
      * Reading the image data
      */
     if ( IsBmp )

-        stream.SeekI(bmpOffset); // else icon, just carry on
+    {
+        // NOTE: seeking a positive amount in wxFromCurrent mode allows us to
+        //       load even non-seekable streams (see wxInputStream::SeekI docs)!
+        const wxFileOffset pos = stream.TellI();
+        if (pos != wxInvalidOffset && bmpOffset > pos)
+            if (stream.SeekI(bmpOffset - pos, wxFromCurrent) == wxInvalidOffset)
+                return false;
+        //else: icon, just carry on
+    }

 
     unsigned char *data = ptr;
 
 
     unsigned char *data = ptr;
 


@@ -611,6 +694,14 @@ bool wxBMPHandler::DoLoadDib(wxImage * image, int width, int height,
 
     int linesize = ((width * bpp + 31) / 32) * 4;
 
 
     int linesize = ((width * bpp + 31) / 32) * 4;
 

+    // flag indicating if we have any not fully transparent alpha values: this
+    // is used to account for the bitmaps which use 32bpp format (normally
+    // meaning that they have alpha channel) but have only zeroes in it so that
+    // without this hack they appear fully transparent -- and as this is
+    // unlikely intentional, we consider that they don't have alpha at all in
+    // this case (see #10915)
+    bool hasValidAlpha = false;
+

     /* BMPs are stored upside down */
     for ( int line = (height - 1); line >= 0; line-- )
     {
     /* BMPs are stored upside down */
     for ( int line = (height - 1); line >= 0; line-- )
     {


@@ -705,7 +796,7 @@ bool wxBMPHandler::DoLoadDib(wxImage * image, int width, int height,
                     {
                         for (int nibble = 0; nibble < 2 && column < width; nibble++)
                         {
                     {
                         for (int nibble = 0; nibble < 2 && column < width; nibble++)
                         {

-                            int index = ((aByte & (0xF0 >> nibble * 4)) >> (!nibble * 4));
+                            int index = ((aByte & (0xF0 >> (nibble * 4))) >> (!nibble * 4));

                             if ( index >= 16 )
                                 index = 15;
                             ptr[poffset] = cmap[index].r;
                             if ( index >= 16 )
                                 index = 15;
                             ptr[poffset] = cmap[index].r;


@@ -794,15 +885,15 @@ bool wxBMPHandler::DoLoadDib(wxImage * image, int width, int height,
                 stream.Read(&aWord, 2);
                 aWord = wxUINT16_SWAP_ON_BE(aWord);
                 linepos += 2;
                 stream.Read(&aWord, 2);
                 aWord = wxUINT16_SWAP_ON_BE(aWord);
                 linepos += 2;

-                /* use the masks and calculated amonut of shift
+                /* Use the masks and calculated amount of shift

                    to retrieve the color data out of the word.  Then
                    shift it left by (8 - number of bits) such that
                    the image has the proper dynamic range */
                    to retrieve the color data out of the word.  Then
                    shift it left by (8 - number of bits) such that
                    the image has the proper dynamic range */

-                temp = (unsigned char)((aWord & rmask) >> rshift << (8-rbits));
+                temp = (unsigned char)(((aWord & rmask) >> rshift) << (8-rbits));

                 ptr[poffset] = temp;
                 ptr[poffset] = temp;

-                temp = (unsigned char)((aWord & gmask) >> gshift << (8-gbits));
+                temp = (unsigned char)(((aWord & gmask) >> gshift) << (8-gbits));

                 ptr[poffset + 1] = temp;
                 ptr[poffset + 1] = temp;

-                temp = (unsigned char)((aWord & bmask) >> bshift << (8-bbits));
+                temp = (unsigned char)(((aWord & bmask) >> bshift) << (8-bbits));

                 ptr[poffset + 2] = temp;
                 column++;
             }
                 ptr[poffset + 2] = temp;
                 column++;
             }


@@ -818,6 +909,14 @@ bool wxBMPHandler::DoLoadDib(wxImage * image, int width, int height,
                 ptr[poffset + 1] = temp;
                 temp = (unsigned char)((aDword & bmask) >> bshift);
                 ptr[poffset + 2] = temp;
                 ptr[poffset + 1] = temp;
                 temp = (unsigned char)((aDword & bmask) >> bshift);
                 ptr[poffset + 2] = temp;

+                if ( alpha )
+                {
+                    temp = (unsigned char)((aDword & amask) >> ashift);
+                    alpha[line * width + column] = temp;
+
+                    if ( temp != wxALPHA_TRANSPARENT )
+                        hasValidAlpha = true;
+                }

                 column++;
             }
         }
                 column++;
             }
         }


@@ -830,10 +929,15 @@ bool wxBMPHandler::DoLoadDib(wxImage * image, int width, int height,
         }
     }
 
         }
     }
 

-    delete[] cmap;
-

     image->SetMask(false);
 
     image->SetMask(false);
 

+    // check if we had any valid alpha values in this bitmap
+    if ( alpha && !hasValidAlpha )
+    {
+        // we didn't, so finally discard the alpha channel completely
+        image->ClearAlpha();
+    }
+

     const wxStreamError err = stream.GetLastError();
     return err == wxSTREAM_NO_ERROR || err == wxSTREAM_EOF;
 }
     const wxStreamError err = stream.GetLastError();
     return err == wxSTREAM_NO_ERROR || err == wxSTREAM_EOF;
 }


@@ -845,15 +949,9 @@ bool wxBMPHandler::LoadDib(wxImage *image, wxInputStream& stream,
     wxInt32         dbuf[4];
     wxInt8          bbuf[4];
 
     wxInt32         dbuf[4];
     wxInt8          bbuf[4];
 

-    wxFileOffset offset = 0; // keep gcc quiet

     if ( IsBmp )
     {
         // read the header off the .BMP format file
     if ( IsBmp )
     {
         // read the header off the .BMP format file

-
-        offset = stream.TellI();
-        if (offset == wxInvalidOffset)
-            offset = 0;
-

         stream.Read(bbuf, 2);
         stream.Read(dbuf, 16);
     }
         stream.Read(bbuf, 2);
         stream.Read(dbuf, 16);
     }


@@ -864,7 +962,7 @@ bool wxBMPHandler::LoadDib(wxImage *image, wxInputStream& stream,
     #if 0 // unused
         wxInt32 size = wxINT32_SWAP_ON_BE(dbuf[0]);
     #endif
     #if 0 // unused
         wxInt32 size = wxINT32_SWAP_ON_BE(dbuf[0]);
     #endif

-    offset = offset + wxINT32_SWAP_ON_BE(dbuf[2]);
+    wxFileOffset offset = wxINT32_SWAP_ON_BE(dbuf[2]);

 
     stream.Read(dbuf, 4 * 2);
     int width = wxINT32_SWAP_ON_BE((int)dbuf[0]);
 
     stream.Read(dbuf, 4 * 2);
     int width = wxINT32_SWAP_ON_BE((int)dbuf[0]);


@@ -874,13 +972,17 @@ bool wxBMPHandler::LoadDib(wxImage *image, wxInputStream& stream,
     if ( width > 32767 )
     {
         if (verbose)
     if ( width > 32767 )
     {
         if (verbose)

+        {

             wxLogError( _("DIB Header: Image width > 32767 pixels for file.") );
             wxLogError( _("DIB Header: Image width > 32767 pixels for file.") );

+        }

         return false;
     }
     if ( height > 32767 )
     {
         if (verbose)
         return false;
     }
     if ( height > 32767 )
     {
         if (verbose)

+        {

             wxLogError( _("DIB Header: Image height > 32767 pixels for file.") );
             wxLogError( _("DIB Header: Image height > 32767 pixels for file.") );

+        }

         return false;
     }
 
         return false;
     }
 


@@ -894,7 +996,9 @@ bool wxBMPHandler::LoadDib(wxImage *image, wxInputStream& stream,
     if ( bpp != 1 && bpp != 4 && bpp != 8 && bpp != 16 && bpp != 24 && bpp != 32 )
     {
         if (verbose)
     if ( bpp != 1 && bpp != 4 && bpp != 8 && bpp != 16 && bpp != 24 && bpp != 32 )
     {
         if (verbose)

+        {

             wxLogError( _("DIB Header: Unknown bitdepth in file.") );
             wxLogError( _("DIB Header: Unknown bitdepth in file.") );

+        }

         return false;
     }
 
         return false;
     }
 


@@ -904,11 +1008,14 @@ bool wxBMPHandler::LoadDib(wxImage *image, wxInputStream& stream,
          comp != BI_BITFIELDS )
     {
         if (verbose)
          comp != BI_BITFIELDS )
     {
         if (verbose)

+        {

             wxLogError( _("DIB Header: Unknown encoding in file.") );
             wxLogError( _("DIB Header: Unknown encoding in file.") );

+        }

         return false;
     }
 
     stream.Read(dbuf, 4 * 2);
         return false;
     }
 
     stream.Read(dbuf, 4 * 2);

+

     int ncolors = wxINT32_SWAP_ON_BE( (int)dbuf[0] );
     if (ncolors == 0)
         ncolors = 1 << bpp;
     int ncolors = wxINT32_SWAP_ON_BE( (int)dbuf[0] );
     if (ncolors == 0)
         ncolors = 1 << bpp;


@@ -918,7 +1025,9 @@ bool wxBMPHandler::LoadDib(wxImage *image, wxInputStream& stream,
         ((comp == BI_BITFIELDS) && (bpp != 16 && bpp != 32)))
     {
         if (verbose)
         ((comp == BI_BITFIELDS) && (bpp != 16 && bpp != 32)))
     {
         if (verbose)

+        {

             wxLogError( _("DIB Header: Encoding doesn't match bitdepth.") );
             wxLogError( _("DIB Header: Encoding doesn't match bitdepth.") );

+        }

         return false;
     }
 
         return false;
     }
 


@@ -927,7 +1036,9 @@ bool wxBMPHandler::LoadDib(wxImage *image, wxInputStream& stream,
                     verbose, IsBmp, true) )
     {
         if (verbose)
                     verbose, IsBmp, true) )
     {
         if (verbose)

-            wxLogError( _("Error in reading image DIB .") );
+        {
+            wxLogError( _("Error in reading image DIB.") );
+        }

         return false;
     }
 
         return false;
     }
 


@@ -940,13 +1051,20 @@ bool wxBMPHandler::LoadDib(wxImage *image, wxInputStream& stream,
                         verbose, IsBmp, false) )
         {
             if (verbose)
                         verbose, IsBmp, false) )
         {
             if (verbose)

+            {

                 wxLogError( _("ICO: Error in reading mask DIB.") );
                 wxLogError( _("ICO: Error in reading mask DIB.") );

+            }

             return false;
         }
         image->SetMaskFromImage(mask, 255, 255, 255);
 
     }
 
             return false;
         }
         image->SetMaskFromImage(mask, 255, 255, 255);
 
     }
 

+    // the resolution in the bitmap header is in meters, convert to centimeters
+    image->SetOption(wxIMAGE_OPTION_RESOLUTIONUNIT, wxIMAGE_RESOLUTION_CM);
+    image->SetOption(wxIMAGE_OPTION_RESOLUTIONX, dbuf[2]/100);
+    image->SetOption(wxIMAGE_OPTION_RESOLUTIONY, dbuf[3]/100);
+

     return true;
 }
 
     return true;
 }
 


@@ -961,7 +1079,7 @@ bool wxBMPHandler::DoCanRead(wxInputStream& stream)
 {
     unsigned char hdr[2];
 
 {
     unsigned char hdr[2];
 

-    if ( !stream.Read(hdr, WXSIZEOF(hdr)) )
+    if ( !stream.Read(hdr, WXSIZEOF(hdr)) )     // it's ok to modify the stream position here

         return false;
 
     // do we have the BMP file signature?
         return false;
 
     // do we have the BMP file signature?


@@ -1013,17 +1131,21 @@ bool wxICOHandler::SaveFile(wxImage *image,
     if ( image->GetHeight () > 127 )
     {
         if ( verbose )
     if ( image->GetHeight () > 127 )
     {
         if ( verbose )

+        {

             wxLogError(_("ICO: Image too tall for an icon."));
             wxLogError(_("ICO: Image too tall for an icon."));

+        }

         return false;
     }
     if ( image->GetWidth () > 255 )
     {
         if ( verbose )
         return false;
     }
     if ( image->GetWidth () > 255 )
     {
         if ( verbose )

+        {

             wxLogError(_("ICO: Image too wide for an icon."));
             wxLogError(_("ICO: Image too wide for an icon."));

+        }

         return false;
     }
 
         return false;
     }
 

-    int images = 1; // only generate one image
+    const int images = 1; // only generate one image

 
     // VS: This is a hack of sort - since ICO and CUR files are almost
     //     identical, we have all the meat in wxICOHandler and check for
 
     // VS: This is a hack of sort - since ICO and CUR files are almost
     //     identical, we have all the meat in wxICOHandler and check for


@@ -1045,13 +1167,15 @@ bool wxICOHandler::SaveFile(wxImage *image,
     if ( !stream.IsOk() )
     {
         if ( verbose )
     if ( !stream.IsOk() )
     {
         if ( verbose )

+        {

             wxLogError(_("ICO: Error writing the image file!"));
             wxLogError(_("ICO: Error writing the image file!"));

+        }

         return false;
     }
 
     // for each iamage write a description ICONDIRENTRY:
     ICONDIRENTRY icondirentry;
         return false;
     }
 
     // for each iamage write a description ICONDIRENTRY:
     ICONDIRENTRY icondirentry;

-    for (int i = 0; i < images; i++)
+    for (int img = 0; img < images; img++)

     {
         wxImage mask;
 
     {
         wxImage mask;
 


@@ -1084,10 +1208,10 @@ bool wxICOHandler::SaveFile(wxImage *image,
         {
             // just make a black mask all over:
             mask = image->Copy();
         {
             // just make a black mask all over:
             mask = image->Copy();

-            int k, j;
-            for (k = 0; k < mask.GetWidth(); k++)
+            int i, j;
+            for (i = 0; i < mask.GetWidth(); i++)

                 for (j = 0; j < mask.GetHeight(); j++)
                 for (j = 0; j < mask.GetHeight(); j++)

-                    mask.SetRGB(k, j, 0, 0, 0 );
+                    mask.SetRGB(i, j, 0, 0, 0 );

         }
         // Set the formats for image and mask
         // (Windows never saves with more than 8 colors):
         }
         // Set the formats for image and mask
         // (Windows never saves with more than 8 colors):


@@ -1104,7 +1228,9 @@ bool wxICOHandler::SaveFile(wxImage *image,
         if ( !bResult )
         {
             if ( verbose )
         if ( !bResult )
         {
             if ( verbose )

+            {

                 wxLogError(_("ICO: Error writing the image file!"));
                 wxLogError(_("ICO: Error writing the image file!"));

+            }

             return false;
         }
         IsMask = true;
             return false;
         }
         IsMask = true;


@@ -1113,18 +1239,22 @@ bool wxICOHandler::SaveFile(wxImage *image,
         if ( !bResult )
         {
             if ( verbose )
         if ( !bResult )
         {
             if ( verbose )

+            {

                 wxLogError(_("ICO: Error writing the image file!"));
                 wxLogError(_("ICO: Error writing the image file!"));

+            }

             return false;
         }
         wxUint32 Size = cStream.GetSize();
 
             return false;
         }
         wxUint32 Size = cStream.GetSize();
 

-        // wxCountingOutputStream::Ok() always returns true for now and this
+        // wxCountingOutputStream::IsOk() always returns true for now and this

         // "if" provokes VC++ warnings in optimized build
 #if 0
         if ( !cStream.Ok() )
         {
             if ( verbose )
         // "if" provokes VC++ warnings in optimized build
 #if 0
         if ( !cStream.Ok() )
         {
             if ( verbose )

+            {

                 wxLogError(_("ICO: Error writing the image file!"));
                 wxLogError(_("ICO: Error writing the image file!"));

+            }

             return false;
         }
 #endif // 0
             return false;
         }
 #endif // 0


@@ -1168,7 +1298,9 @@ bool wxICOHandler::SaveFile(wxImage *image,
         if ( !stream.IsOk() )
         {
             if ( verbose )
         if ( !stream.IsOk() )
         {
             if ( verbose )

+            {

                 wxLogError(_("ICO: Error writing the image file!"));
                 wxLogError(_("ICO: Error writing the image file!"));

+            }

             return false;
         }
 
             return false;
         }
 


@@ -1178,7 +1310,9 @@ bool wxICOHandler::SaveFile(wxImage *image,
         if ( !bResult )
         {
             if ( verbose )
         if ( !bResult )
         {
             if ( verbose )

+            {

                 wxLogError(_("ICO: Error writing the image file!"));
                 wxLogError(_("ICO: Error writing the image file!"));

+            }

             return false;
         }
         IsMask = true;
             return false;
         }
         IsMask = true;


@@ -1187,7 +1321,9 @@ bool wxICOHandler::SaveFile(wxImage *image,
         if ( !bResult )
         {
             if ( verbose )
         if ( !bResult )
         {
             if ( verbose )

+            {

                 wxLogError(_("ICO: Error writing the image file!"));
                 wxLogError(_("ICO: Error writing the image file!"));

+            }

             return false;
         }
 
             return false;
         }
 


@@ -1199,7 +1335,6 @@ bool wxICOHandler::SaveFile(wxImage *image,
 bool wxICOHandler::LoadFile(wxImage *image, wxInputStream& stream,
                             bool verbose, int index)
 {
 bool wxICOHandler::LoadFile(wxImage *image, wxInputStream& stream,
                             bool verbose, int index)
 {

-    stream.SeekI(0);

     return DoLoadFile(image, stream, verbose, index);
 }
 
     return DoLoadFile(image, stream, verbose, index);
 }
 


@@ -1211,9 +1346,9 @@ bool wxICOHandler::DoLoadFile(wxImage *image, wxInputStream& stream,
 
     ICONDIR IconDir;
 
 
     ICONDIR IconDir;
 

-    wxFileOffset iPos = stream.TellI();

     stream.Read(&IconDir, sizeof(IconDir));
     wxUint16 nIcons = wxUINT16_SWAP_ON_BE(IconDir.idCount);
     stream.Read(&IconDir, sizeof(IconDir));
     wxUint16 nIcons = wxUINT16_SWAP_ON_BE(IconDir.idCount);

+

     // nType is 1 for Icons, 2 for Cursors:
     wxUint16 nType = wxUINT16_SWAP_ON_BE(IconDir.idType);
 
     // nType is 1 for Icons, 2 for Cursors:
     wxUint16 nType = wxUINT16_SWAP_ON_BE(IconDir.idType);
 


@@ -1224,9 +1359,13 @@ bool wxICOHandler::DoLoadFile(wxImage *image, wxInputStream& stream,
     int colmax = 0;
     int iSel = wxNOT_FOUND;
 
     int colmax = 0;
     int iSel = wxNOT_FOUND;
 

-    for (int i = 0; i < nIcons; i++ )
+    // remember how many bytes we read from the stream:
+    wxFileOffset alreadySeeked = sizeof(IconDir);
+
+    for (unsigned int i = 0; i < nIcons; i++ )

     {
     {

-        stream.Read(pCurrentEntry, sizeof(ICONDIRENTRY));
+        alreadySeeked += stream.Read(pCurrentEntry, sizeof(ICONDIRENTRY)).LastRead();
+

         // bHeight and bColorCount are wxUint8
         if ( pCurrentEntry->bWidth >= wMax )
         {
         // bHeight and bColorCount are wxUint8
         if ( pCurrentEntry->bWidth >= wMax )
         {


@@ -1240,6 +1379,7 @@ bool wxICOHandler::DoLoadFile(wxImage *image, wxInputStream& stream,
                 colmax = pCurrentEntry->bColorCount;
             }
         }
                 colmax = pCurrentEntry->bColorCount;
             }
         }

+

         pCurrentEntry++;
     }
 
         pCurrentEntry++;
     }
 


@@ -1259,7 +1399,13 @@ bool wxICOHandler::DoLoadFile(wxImage *image, wxInputStream& stream,
     {
         // seek to selected icon:
         pCurrentEntry = pIconDirEntry + iSel;
     {
         // seek to selected icon:
         pCurrentEntry = pIconDirEntry + iSel;

-        stream.SeekI(iPos + wxUINT32_SWAP_ON_BE(pCurrentEntry->dwImageOffset), wxFromStart);
+
+        // NOTE: seeking a positive amount in wxFromCurrent mode allows us to
+        //       load even non-seekable streams (see wxInputStream::SeekI docs)!
+        wxFileOffset offset = wxUINT32_SWAP_ON_BE(pCurrentEntry->dwImageOffset) - alreadySeeked;
+        if (offset != 0 && stream.SeekI(offset, wxFromCurrent) == wxInvalidOffset)
+            return false;
+

         bResult = LoadDib(image, stream, true, IsBmp);
         bool bIsCursorType = (this->GetType() == wxBITMAP_TYPE_CUR) || (this->GetType() == wxBITMAP_TYPE_ANI);
         if ( bResult && bIsCursorType && nType == 2 )
         bResult = LoadDib(image, stream, true, IsBmp);
         bool bIsCursorType = (this->GetType() == wxBITMAP_TYPE_CUR) || (this->GetType() == wxBITMAP_TYPE_ANI);
         if ( bResult && bIsCursorType && nType == 2 )


@@ -1269,30 +1415,27 @@ bool wxICOHandler::DoLoadFile(wxImage *image, wxInputStream& stream,
             image->SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, wxUINT16_SWAP_ON_BE(pCurrentEntry->wBitCount));
         }
     }
             image->SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, wxUINT16_SWAP_ON_BE(pCurrentEntry->wBitCount));
         }
     }

-    delete[] pIconDirEntry;
+
+    delete [] pIconDirEntry;
+

     return bResult;
 }
 
     return bResult;
 }
 

-int wxICOHandler::GetImageCount(wxInputStream& stream)
+int wxICOHandler::DoGetImageCount(wxInputStream& stream)

 {
     ICONDIR IconDir;
 {
     ICONDIR IconDir;

-    wxFileOffset iPos = stream.TellI();
-    stream.SeekI(0);
-    stream.Read(&IconDir, sizeof(IconDir));
-    wxUint16 nIcons = wxUINT16_SWAP_ON_BE(IconDir.idCount);
-    stream.SeekI(iPos);
-    return (int)nIcons;
+
+    if (stream.Read(&IconDir, sizeof(IconDir)).LastRead() != sizeof(IconDir))
+             // it's ok to modify the stream position here
+        return 0;
+
+    return (int)wxUINT16_SWAP_ON_BE(IconDir.idCount);

 }
 
 bool wxICOHandler::DoCanRead(wxInputStream& stream)
 {
 }
 
 bool wxICOHandler::DoCanRead(wxInputStream& stream)
 {

-    stream.SeekI(0);
-    unsigned char hdr[4];
-    if ( !stream.Read(hdr, WXSIZEOF(hdr)) )
-        return false;
+    return CanReadICOOrCUR(&stream, 1 /*for identifying an icon*/);

 
 

-    // hdr[2] is one for an icon and two for a cursor
-    return hdr[0] == '\0' && hdr[1] == '\0' && hdr[2] == '\1' && hdr[3] == '\0';

 }
 
 #endif // wxUSE_STREAMS
 }
 
 #endif // wxUSE_STREAMS


@@ -1308,13 +1451,7 @@ IMPLEMENT_DYNAMIC_CLASS(wxCURHandler, wxICOHandler)
 
 bool wxCURHandler::DoCanRead(wxInputStream& stream)
 {
 
 bool wxCURHandler::DoCanRead(wxInputStream& stream)
 {

-    stream.SeekI(0);
-    unsigned char hdr[4];
-    if ( !stream.Read(hdr, WXSIZEOF(hdr)) )
-        return false;
-
-    // hdr[2] is one for an icon and two for a cursor
-    return hdr[0] == '\0' && hdr[1] == '\0' && hdr[2] == '\2' && hdr[3] == '\0';
+    return CanReadICOOrCUR(&stream, 2 /*for identifying a cursor*/);

 }
 
 #endif // wxUSE_STREAMS
 }
 
 #endif // wxUSE_STREAMS


@@ -1328,160 +1465,42 @@ IMPLEMENT_DYNAMIC_CLASS(wxANIHandler, wxCURHandler)
 #if wxUSE_STREAMS
 
 bool wxANIHandler::LoadFile(wxImage *image, wxInputStream& stream,
 #if wxUSE_STREAMS
 
 bool wxANIHandler::LoadFile(wxImage *image, wxInputStream& stream,

-                            bool verbose, int index)
+                            bool WXUNUSED(verbose), int index)

 {
 {

-    wxInt32 FCC1, FCC2;
-    wxUint32 datalen;
-
-    wxInt32 riff32;
-    memcpy( &riff32, "RIFF", 4 );
-    wxInt32 list32;
-    memcpy( &list32, "LIST", 4 );
-    wxInt32 ico32;
-    memcpy( &ico32, "icon", 4 );
-    int iIcon = 0;
-
-    stream.SeekI(0);
-    stream.Read(&FCC1, 4);
-    if ( FCC1 != riff32 )
+    wxANIDecoder decoder;
+    if (!decoder.Load(stream))

         return false;
 
         return false;
 

-    // we have a riff file:
-    while (stream.IsOk())
-    {
-        // we always have a data size
-        stream.Read(&datalen, 4);
-        datalen = wxINT32_SWAP_ON_BE(datalen) ;
-        //data should be padded to make even number of bytes
-        if (datalen % 2 == 1) datalen ++ ;
-        //now either data or a FCC
-        if ( (FCC1 == riff32) || (FCC1 == list32) )
-        {
-            stream.Read(&FCC2, 4);
-        }
-        else
-        {
-            if (FCC1 == ico32 && iIcon >= index)
-            {
-                return DoLoadFile(image, stream, verbose, -1);
-            }
-            else
-            {
-                stream.SeekI(stream.TellI() + datalen);
-                if ( FCC1 == ico32 )
-                    iIcon ++;
-            }
-        }
-
-        // try to read next data chunk:
-        stream.Read(&FCC1, 4);
-    }
-    return false;
+    return decoder.ConvertToImage(index != -1 ? (size_t)index : 0, image);

 }
 
 bool wxANIHandler::DoCanRead(wxInputStream& stream)
 {
 }
 
 bool wxANIHandler::DoCanRead(wxInputStream& stream)
 {

-    wxInt32 FCC1, FCC2;
-    wxUint32 datalen ;
-
-    wxInt32 riff32;
-    memcpy( &riff32, "RIFF", 4 );
-    wxInt32 list32;
-    memcpy( &list32, "LIST", 4 );
-    wxInt32 ico32;
-    memcpy( &ico32, "icon", 4 );
-    wxInt32 anih32;
-    memcpy( &anih32, "anih", 4 );
-
-    stream.SeekI(0);
-    if ( !stream.Read(&FCC1, 4) )
-        return false;
-
-    if ( FCC1 != riff32 )
-        return false;
-
-    // we have a riff file:
-    while ( stream.IsOk() )
-    {
-        if ( FCC1 == anih32 )
-            return true;
-        // we always have a data size:
-        stream.Read(&datalen, 4);
-        datalen = wxINT32_SWAP_ON_BE(datalen) ;
-        //data should be padded to make even number of bytes
-        if (datalen % 2 == 1) datalen ++ ;
-        // now either data or a FCC:
-        if ( (FCC1 == riff32) || (FCC1 == list32) )
-        {
-            stream.Read(&FCC2, 4);
-        }
-        else
-        {
-            stream.SeekI(stream.TellI() + datalen);
-        }
-
-        // try to read next data chunk:
-        if ( !stream.Read(&FCC1, 4) )
-        {
-            // reading failed -- either EOF or IO error, bail out anyhow
-            return false;
-        }
-    }
-
-    return false;
+    wxANIDecoder decod;
+    return decod.CanRead(stream);
+             // it's ok to modify the stream position here

 }
 
 }
 

-int wxANIHandler::GetImageCount(wxInputStream& stream)
+int wxANIHandler::DoGetImageCount(wxInputStream& stream)

 {
 {

-    wxInt32 FCC1, FCC2;
-    wxUint32 datalen ;
-
-    wxInt32 riff32;
-    memcpy( &riff32, "RIFF", 4 );
-    wxInt32 list32;
-    memcpy( &list32, "LIST", 4 );
-    wxInt32 ico32;
-    memcpy( &ico32, "icon", 4 );
-    wxInt32 anih32;
-    memcpy( &anih32, "anih", 4 );
-
-    stream.SeekI(0);
-    stream.Read(&FCC1, 4);
-    if ( FCC1 != riff32 )
+    wxANIDecoder decoder;
+    if (!decoder.Load(stream))  // it's ok to modify the stream position here

         return wxNOT_FOUND;
 
         return wxNOT_FOUND;
 

-    // we have a riff file:
-    while ( stream.IsOk() )
-    {
-        // we always have a data size:
-        stream.Read(&datalen, 4);
-        datalen = wxINT32_SWAP_ON_BE(datalen) ;
-        //data should be padded to make even number of bytes
-        if (datalen % 2 == 1) datalen ++ ;
-        // now either data or a FCC:
-        if ( (FCC1 == riff32) || (FCC1 == list32) )
-        {
-            stream.Read(&FCC2, 4);
-        }
-        else
-        {
-            if ( FCC1 == anih32 )
-            {
-                wxUint32 *pData = new wxUint32[datalen/4];
-                stream.Read(pData, datalen);
-                int nIcons = wxINT32_SWAP_ON_BE(*(pData + 1));
-                delete[] pData;
-                return nIcons;
-            }
-            else
-                stream.SeekI(stream.TellI() + datalen);
-        }
+    return decoder.GetFrameCount();
+}

 
 

-        // try to read next data chunk:
-        stream.Read(&FCC1, 4);
+static bool CanReadICOOrCUR(wxInputStream *stream, wxUint16 resourceType)
+{
+    ICONDIR iconDir;
+    if ( !stream->Read(&iconDir, sizeof(iconDir)) )     // it's ok to modify the stream position here
+    {
+        return false;

     }
 
     }
 

-    return wxNOT_FOUND;
+    return !iconDir.idReserved // reserved, must be 0
+        && wxUINT16_SWAP_ON_BE(iconDir.idType) == resourceType // either 1 or 2
+        && iconDir.idCount; // must contain at least one image

 }
 
 #endif // wxUSE_STREAMS
 }
 
 #endif // wxUSE_STREAMS