]> git.saurik.com Git - wxWidgets.git/blobdiff - src/common/imagbmp.cpp
added wxEncodingToCodepage() and implemented it properly (using in32 API instead...
[wxWidgets.git] / src / common / imagbmp.cpp
index 6a09a824faf61ac066c0702417b74e4132a09886..2142d1e59e54cc0858f9abde6d95dfdc97e2938a 100644 (file)
@@ -47,7 +47,7 @@
 #endif
 
 //-----------------------------------------------------------------------------
-// wxBMPHandler
+// wxBMPHandler & wxICOHandler
 //-----------------------------------------------------------------------------
 
 IMPLEMENT_DYNAMIC_CLASS(wxBMPHandler,wxImageHandler)
@@ -56,9 +56,219 @@ IMPLEMENT_DYNAMIC_CLASS(wxBMPHandler,wxImageHandler)
 #if wxUSE_STREAMS
 
 
+#ifndef BI_RGB
+#define BI_RGB       0
+#define BI_RLE8      1
+#define BI_RLE4      2
+#endif
+
+#ifndef BI_BITFIELDS
+#define BI_BITFIELDS 3
+#endif
+
+#define poffset (line * width * 3 + column * 3)
+
+
+
+struct ICONDIRENTRY
+    {
+    wxUint8         bWidth;               // Width of the image
+    wxUint8         bHeight;              // Height of the image (times 2)
+    wxUint8         bColorCount;          // Number of colors in image (0 if >=8bpp)
+    wxUint8         bReserved;            // Reserved
+    wxUint16        wPlanes;              // Color Planes
+    wxUint16        wBitCount;            // Bits per pixel
+    wxUint32        dwBytesInRes;         // how many bytes in this resource?
+    wxUint32        dwImageOffset;        // where in the file is this image
+} ;
+
+
+struct ICONDIR
+{
+    wxUint16     idReserved;   // Reserved
+    wxUint16     idType;       // resource type (1 for icons)
+    wxUint16     idCount;      // how many images?
+} ;
+
+bool wxICOHandler::SaveFile(wxImage *image,
+                            wxOutputStream& stream,
+                            bool verbose)
+
+{
+    bool bResult = FALSE ;
+    //sanity check; icon must be less than 127 pixels high and 255 wide
+    if (image -> GetHeight () > 127 )
+    {
+        if (verbose)
+            wxLogError( _("ICO: Error Image too tall for an icon.") );
+        return FALSE;
+    }
+    if (image -> GetWidth () > 255 )
+    {
+        if (verbose)
+            wxLogError( _("ICO: Error Image too wide for an icon.") );
+        return FALSE;
+    }
+
+    // only generate one image
+    int m_images = 1 ;
+
+    // write a header, (ICONDIR)
+    // Calculate the header size
+    wxUint32 m_offset = 3 * sizeof(wxUint16);
+
+    ICONDIR m_IconDir ;
+    m_IconDir.idReserved = 0 ;
+    m_IconDir.idType = wxUINT16_SWAP_ON_BE (1);
+    m_IconDir.idCount = wxUINT16_SWAP_ON_BE (m_images);
+    stream.Write(&m_IconDir.idReserved, sizeof(m_IconDir.idReserved));
+    stream.Write(&m_IconDir.idType, sizeof(m_IconDir.idType));
+    stream.Write(&m_IconDir.idCount, sizeof(m_IconDir.idCount));
+    if ( !stream.IsOk () )
+    {
+        if (verbose)
+            wxLogError( _("ICO: Error writing ICONDIR header.") );
+        return FALSE;
+    }
+
+    // for each iamage write a description ICONDIRENTRY
+    ICONDIRENTRY m_icondirentry ;
+    int i ;
+    for ( i = 0; i < m_images; i++ )
+    {
+        wxImage mask ;
+        if (image->HasMask())
+        {            
+            //make another image with black/white 
+            mask = image -> ConvertToMono (image->GetMaskRed(), image->GetMaskGreen(), image->GetMaskBlue() );
+            //now we need to change the masked regions to black
+            unsigned char r = image -> GetMaskRed() ;
+            unsigned char g = image -> GetMaskGreen() ;
+            unsigned char b = image -> GetMaskBlue() ;
+            if ((r != 0) || (g != 0) || (b != 0) )
+                {
+                    //Go round and apply black to the masked bits
+                    int i,j;
+                    for (i=0; i < mask.GetWidth(); i++)
+                        for (j=0; j < mask.GetHeight(); j++)
+                        {
+                            if ((r == mask.GetRed(i, j)) && 
+                                (g == mask.GetGreen(i, j) ) && 
+                                (b == mask.GetBlue(i, j)) )
+                                    image -> SetRGB ( i, j, 0, 0, 0 );
+                        }
+
+                }
+        }
+        else
+        {
+            // just make a black mask all over
+            mask = image -> Copy ();
+            int i,j;
+            for (i=0; i < mask.GetWidth(); i++)
+                for (j=0; j < mask.GetHeight(); j++)
+                mask.SetRGB ( i, j, 0, 0, 0 );
+        }
+        //Set the formats for image and mask
+        // windows never saves with more than 8 colors
+        image -> SetOption (wxBMP_FORMAT, wxBMP_8BPP);
+        // monochome bitmap
+        mask . SetOption (wxBMP_FORMAT, wxBMP_1BPP_BW);
+        bool IsBmp = FALSE ;
+        bool IsMask = FALSE ;
+
+        //calculate size and offset of image and mask
+        wxCountingOutputStream cStream ;
+        bResult = SaveDib ( image, cStream, verbose, IsBmp, IsMask ) ;
+        if (!bResult)
+        {
+            if (verbose)
+                wxLogError( _("ICO: Error calculating size of XOR DIB .") );
+            return FALSE;
+        }
+        IsMask = TRUE ;
+        bResult = SaveDib ( &mask, cStream, verbose, IsBmp, IsMask ) ;
+        if (!bResult)
+        {
+            if (verbose)
+                wxLogError( _("ICO: Error calculating size of Mask DIB .") );
+            return FALSE;
+        }
+        wxUint32 m_Size = cStream.GetSize();
+        if (!cStream.Ok())
+        {
+            if (verbose)
+                wxLogError( _("ICO: Error calculating size of DIB .") );
+            return FALSE;
+        }
+
+        m_offset = m_offset + sizeof(ICONDIRENTRY) ;
+
+        m_icondirentry. bWidth = image -> GetWidth () ;
+        m_icondirentry. bHeight = 2 * image -> GetHeight () ;
+        m_icondirentry. bColorCount = 0 ;
+        m_icondirentry. bReserved = 0 ;
+        m_icondirentry. wPlanes = wxUINT16_SWAP_ON_BE(1);
+        m_icondirentry. wBitCount = wxUINT16_SWAP_ON_BE(wxBMP_8BPP) ;
+        m_icondirentry. dwBytesInRes = wxUINT32_SWAP_ON_BE(m_Size);
+        m_icondirentry. dwImageOffset = wxUINT32_SWAP_ON_BE(m_offset);
+
+        //increase size to allow for the data wriitten
+        m_offset = m_offset + m_Size ;
+
+        //write to stream
+        stream.Write(&m_icondirentry. bWidth, sizeof(m_icondirentry. bWidth) );
+        stream.Write(&m_icondirentry. bHeight, sizeof(m_icondirentry. bHeight) );
+        stream.Write(&m_icondirentry. bColorCount, sizeof(m_icondirentry. bColorCount) );
+        stream.Write(&m_icondirentry. bReserved, sizeof(m_icondirentry. bReserved) );
+        stream.Write(&m_icondirentry. wPlanes, sizeof(m_icondirentry. wPlanes) );
+        stream.Write(&m_icondirentry. wBitCount, sizeof(m_icondirentry. wBitCount) );
+        stream.Write(&m_icondirentry. dwBytesInRes, sizeof(m_icondirentry. dwBytesInRes) );
+        stream.Write(&m_icondirentry. dwImageOffset, sizeof(m_icondirentry. dwImageOffset) );
+        if ( !stream.IsOk () )
+        {
+            if (verbose)
+                wxLogError( _("ICO: Error writing ICONDIRENTRY header.") );
+            return FALSE;
+        }
+        //actually save it
+        IsMask = FALSE ;
+        bResult = SaveDib ( image, stream, verbose, IsBmp, IsMask ) ;
+        if (!bResult)
+        {
+            if (verbose)
+                wxLogError( _("ICO: Error writing XOR DIB .") );
+            return FALSE;
+        }
+        IsMask = TRUE ;
+        bResult = SaveDib ( &mask, stream, verbose, IsBmp, IsMask ) ;
+        if (!bResult)
+        {
+            if (verbose)
+                wxLogError( _("ICO: Error writing Mask DIB .") );
+            return FALSE;
+        }
+
+    } // end of for loop
+    return TRUE ;
+}
+
+
 bool wxBMPHandler::SaveFile(wxImage *image,
                             wxOutputStream& stream,
                             bool verbose)
+{
+    bool IsBmp = TRUE;
+    bool IsMask = FALSE ;
+    return SaveDib( image, stream, verbose, IsBmp, IsMask ) ;
+}
+
+bool wxBMPHandler::SaveDib(wxImage *image,
+                            wxOutputStream& stream,
+                            bool verbose,
+                            bool IsBmp,
+                            bool IsMask)
+
 {
     wxCHECK_MSG( image, FALSE, _T("invalid pointer in wxBMPHandler::SaveFile") );
 
@@ -145,7 +355,14 @@ bool wxBMPHandler::SaveFile(wxImage *image,
 
     hdr.bih_size = wxUINT32_SWAP_ON_BE(hdr_size - 14);
     hdr.width = wxUINT32_SWAP_ON_BE(image->GetWidth());
+    if (IsBmp)
+    {
     hdr.height = wxUINT32_SWAP_ON_BE(image->GetHeight());
+    }
+    else
+    {
+        hdr.height = wxUINT32_SWAP_ON_BE(2 * image->GetHeight());
+    }    
     hdr.planes = wxUINT16_SWAP_ON_BE(1); // always 1 plane
     hdr.bpp = wxUINT16_SWAP_ON_BE(bpp);
     hdr.compression = 0; // RGB uncompressed
@@ -154,13 +371,25 @@ bool wxBMPHandler::SaveFile(wxImage *image,
     hdr.num_clrs = wxUINT32_SWAP_ON_BE(palette_size); // # colors in colormap
     hdr.num_signif_clrs = 0;     // all colors are significant
 
+    if (IsBmp)
+    {
     if (// VS: looks ugly but compilers tend to do ugly things with structs,
         //     like aligning hdr.filesize's ofset to dword :(
         // VZ: we should add padding then...
         !stream.Write(&hdr.magic, 2) ||
         !stream.Write(&hdr.filesize, 4) ||
         !stream.Write(&hdr.reserved, 4) ||
-        !stream.Write(&hdr.data_offset, 4) ||
+             !stream.Write(&hdr.data_offset, 4) 
+            )
+         {
+             if (verbose)
+                 wxLogError(_("BMP: Couldn't write the file (Bitmap) header."));
+             return FALSE;
+         }
+     }
+     if (!IsMask)
+     {
+        if (
         !stream.Write(&hdr.bih_size, 4) ||
         !stream.Write(&hdr.width, 4) ||
         !stream.Write(&hdr.height, 4) ||
@@ -175,9 +404,10 @@ bool wxBMPHandler::SaveFile(wxImage *image,
        )
     {
         if (verbose)
-            wxLogError(_("BMP: Couldn't write the file header."));
+                 wxLogError(_("BMP: Couldn't write the file (BitmapInfo) header."));
         return FALSE;
     }
+     }
 
     wxPalette *palette = NULL; // entries for quantized images
     wxUint8 *rgbquad = NULL;   // for the RGBQUAD bytes for the colormap
@@ -243,6 +473,8 @@ bool wxBMPHandler::SaveFile(wxImage *image,
     // if the colormap was made, then it needs to be written
     if (rgbquad)
     {
+        if (!IsMask)
+        {
         if (!stream.Write(rgbquad, palette_size*4))
         {
             if (verbose)
@@ -254,6 +486,7 @@ bool wxBMPHandler::SaveFile(wxImage *image,
             delete q_image;
             return FALSE;
         }
+        }
         delete []rgbquad;
     }
 
@@ -397,123 +630,52 @@ bool wxBMPHandler::SaveFile(wxImage *image,
 
 
 
-#ifndef BI_RGB
-#define BI_RGB       0
-#define BI_RLE8      1
-#define BI_RLE4      2
-#endif
-
-#ifndef BI_BITFIELDS
-#define BI_BITFIELDS 3
-#endif
 
-#define poffset (line * width * 3 + column * 3)
+bool wxBMPHandler::DoLoadDib (wxImage * image, int width, int height, int bpp, int ncolors, int comp,
+                off_t bmpOffset, wxInputStream& stream,
+                bool verbose, bool IsBmp, bool hasPalette  )
+    {
 
-bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream, bool verbose, int WXUNUSED(index) )
-{
+    wxInt32         aDword, rmask = 0, gmask = 0, bmask = 0;
     int             rshift = 0, gshift = 0, bshift = 0;
-    wxUint8         aByte;
-    wxUint16        aWord;
     wxInt32         dbuf[4];
-       wxInt32         aDword, rmask = 0, gmask = 0, bmask = 0;
     wxInt8          bbuf[4];
-    struct _cmap {
-        unsigned char r, g, b;
-    } *cmap = NULL;
-
-    off_t start_offset = stream.TellI();
-    if (start_offset == wxInvalidOffset) start_offset = 0;
-
-    image->Destroy();
-
-    /*
-     * Read the BMP header
-     */
-
-    stream.Read( bbuf, 2 );
-    stream.Read( dbuf, 4 * 4 );
+    wxUint8         aByte;
+    wxUint16        aWord;
 
-#if 0 // unused
-    wxInt32 size = wxINT32_SWAP_ON_BE( dbuf[0] );
-#endif
-    wxInt32 offset = wxINT32_SWAP_ON_BE( dbuf[2] );
 
-    stream.Read(dbuf, 4 * 2);
-    int width = (int)wxINT32_SWAP_ON_BE( dbuf[0] );
-    int height = (int)wxINT32_SWAP_ON_BE( dbuf[1] );
-    if (width > 32767)
-    {
-        if (verbose)
-            wxLogError( _("BMP: Image width > 32767 pixels for file.") );
-        return FALSE;
-    }
-    if (height > 32767)
+    // allocate space for palette if needed
+    struct _cmap
     {
-        if (verbose)
-            wxLogError( _("BMP: Image height > 32767 pixels for file.") );
-        return FALSE;
-    }
-
-    stream.Read( &aWord, 2 );
-/*
-    TODO
-    int planes = (int)wxUINT16_SWAP_ON_BE( aWord );
-*/
-    stream.Read( &aWord, 2 );
-    int bpp = (int)wxUINT16_SWAP_ON_BE( aWord );
-    if (bpp != 1 && bpp != 4 && bpp != 8 && bpp != 16 && bpp != 24 && bpp != 32)
-    {
-        if (verbose)
-            wxLogError( _("BMP: Unknown bitdepth in file.") );
-        return FALSE;
-    }
-
-    stream.Read( dbuf, 4 * 4 );
-    int comp = (int)wxINT32_SWAP_ON_BE( dbuf[0] );
-    if (comp != BI_RGB && comp != BI_RLE4 && comp != BI_RLE8 && comp != BI_BITFIELDS)
-    {
-        if (verbose)
-            wxLogError( _("BMP: Unknown encoding in file.") );
-        return FALSE;
+        unsigned char r, g, b;
     }
+    *cmap = NULL;
 
-    stream.Read( dbuf, 4 * 2 );
-    int ncolors = (int)wxINT32_SWAP_ON_BE( dbuf[0] );
-    if (ncolors == 0)
-        ncolors = 1 << bpp;
-    /* some more sanity checks */
-    if (((comp == BI_RLE4) && (bpp != 4)) ||
-        ((comp == BI_RLE8) && (bpp != 8)) ||
-        ((comp == BI_BITFIELDS) && (bpp != 16 && bpp != 32)))
-    {
-        if (verbose)
-            wxLogError( _("BMP: Encoding doesn't match bitdepth.") );
-        return FALSE;
-    }
     if (bpp < 16)
     {
         cmap = (struct _cmap *)malloc(sizeof(struct _cmap) * ncolors);
         if (!cmap)
         {
             if (verbose)
-                wxLogError( _("BMP: Couldn't allocate memory.") );
+                wxLogError( _("Loading DIB : Couldn't allocate memory.") );
             return FALSE;
         }
     }
     else
         cmap = NULL;
 
+    // destroy existing here instead of
+    image->Destroy();
     image->Create( width, height );
     unsigned char *ptr = image->GetData();
     if (!ptr)
     {
         if (verbose)
-            wxLogError( _("BMP: Couldn't allocate memory.") );
+            wxLogError( _("Loading DIB : Couldn't allocate memory.") );
         if (cmap)
             free(cmap);
         return FALSE;
     }
-
     /*
      * Reading the palette, if it exists.
      */
@@ -524,6 +686,8 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream, bool verbose
         unsigned char* b = new unsigned char[ncolors];
         for (int j = 0; j < ncolors; j++)
         {
+            if (hasPalette)
+            {
             stream.Read( bbuf, 4 );
             cmap[j].b = bbuf[0];
             cmap[j].g = bbuf[1];
@@ -533,6 +697,14 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream, bool verbose
             g[j] = cmap[j].g;
             b[j] = cmap[j].b;
         }
+            else
+            {
+                //used in reading .ico file mask
+                r[j] = cmap[j].r = j * 255;
+                g[j] = cmap[j].g = j * 255;
+                b[j] = cmap[j].b = j * 255;
+            }
+        }
 
 #if wxUSE_PALETTE
         // Set the palette for the wxImage
@@ -586,7 +758,8 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream, bool verbose
     /*
      * Reading the image data
      */
-    stream.SeekI( start_offset + offset );
+    if ( IsBmp ) stream.SeekI( bmpOffset ); // else icon, just carry on
+
     unsigned char *data = ptr;
 
     /* set the whole image to the background color */
@@ -633,7 +806,7 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream, bool verbose
                     if (comp == BI_RLE4)
                     {
                         if (verbose)
-                            wxLogError( _("BMP: Cannot deal with 4bit encoded yet.") );
+                            wxLogError( _("DIB Header: Cannot deal with 4bit encoded yet.") );
                         image->Destroy();
                         free(cmap);
                         return FALSE;
@@ -768,9 +941,179 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream, bool verbose
 
      image->SetMask( FALSE );
 
+    return stream.IsOk();
+}
+
+
+bool wxBMPHandler::LoadDib( wxImage *image, wxInputStream& stream, bool verbose, bool IsBmp  )
+{
+    wxUint16        aWord;
+    wxInt32         dbuf[4];
+    wxInt8          bbuf[4];
+    off_t           offset;
+
+    offset = 0; // keep gcc quiet
+    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  );
+    }
+    else
+    {
+        stream.Read( dbuf, 4  );
+    }
+    #if 0 // unused
+        wxInt32 size = wxINT32_SWAP_ON_BE( dbuf[0] );
+    #endif
+    offset = offset + wxINT32_SWAP_ON_BE( dbuf[2] );
+
+    stream.Read(dbuf, 4 * 2);
+    int width = (int)wxINT32_SWAP_ON_BE( dbuf[0] );
+    int height = (int)wxINT32_SWAP_ON_BE( dbuf[1] );
+    if ( !IsBmp ) height = height  / 2; // for icons divide by 2
+        
+    if (width > 32767)
+    {
+        if (verbose)
+            wxLogError( _("DIB Header: Image width > 32767 pixels for file.") );
+        return FALSE;
+    }
+    if (height > 32767)
+    {
+        if (verbose)
+            wxLogError( _("DIB Header: Image height > 32767 pixels for file.") );
+        return FALSE;
+    }
+
+    stream.Read( &aWord, 2 );
+    /*
+            TODO
+            int planes = (int)wxUINT16_SWAP_ON_BE( aWord );
+        */
+    stream.Read( &aWord, 2 );
+    int bpp = (int)wxUINT16_SWAP_ON_BE( aWord );
+    if (bpp != 1 && bpp != 4 && bpp != 8 && bpp != 16 && bpp != 24 && bpp != 32)
+    {
+        if (verbose)
+            wxLogError( _("DIB Header: Unknown bitdepth in file.") );
+        return FALSE;
+    }
+
+    stream.Read( dbuf, 4 * 4 );
+    int comp = (int)wxINT32_SWAP_ON_BE( dbuf[0] );
+    if (comp != BI_RGB && comp != BI_RLE4 && comp != BI_RLE8 && comp != BI_BITFIELDS)
+    {
+        if (verbose)
+            wxLogError( _("DIB Header: Unknown encoding in file.") );
+        return FALSE;
+    }
+
+    stream.Read( dbuf, 4 * 2 );
+    int ncolors = (int)wxINT32_SWAP_ON_BE( dbuf[0] );
+    if (ncolors == 0)
+        ncolors = 1 << bpp;
+    /* some more sanity checks */
+    if (((comp == BI_RLE4) && (bpp != 4)) ||
+        ((comp == BI_RLE8) && (bpp != 8)) ||
+        ((comp == BI_BITFIELDS) && (bpp != 16 && bpp != 32)))
+    {
+        if (verbose)
+            wxLogError( _("DIB Header: Encoding doesn't match bitdepth.") );
+        return FALSE;
+    }
+
+    //read DIB; this is the BMP image or the XOR part of an icon image
+    if (!DoLoadDib (image, width, height, bpp, ncolors, comp, offset, stream,
+        verbose, IsBmp, TRUE ) )
+    {
+        if (verbose)
+            wxLogError( _("Error in reading image DIB .") );
+        return FALSE;
+    }
+
+    if ( !IsBmp )
+    {
+        //read Icon mask which is monochrome
+        //there is no palette, so we will create one
+        wxImage mask;
+        if (!DoLoadDib (&mask, width, height, 1, 2, BI_RGB, offset, stream,
+            verbose, IsBmp, FALSE ) )
+        {
+            if (verbose)
+                wxLogError( _("ICO: Error in reading mask DIB.") );
+            return FALSE;
+        }
+        image->SetMaskFromImage(mask, 255, 255, 255);
+
+    }
      return TRUE;
 }
 
+
+bool wxBMPHandler::LoadFile ( wxImage *image, wxInputStream& stream, bool verbose, int WXUNUSED(index) )
+{
+    bool IsBmp = TRUE;
+    //Read a single DIB fom the file
+    return LoadDib ( image, stream, verbose, IsBmp ) ;
+}
+
+
+
+bool wxICOHandler::LoadFile ( wxImage *image, wxInputStream& stream, bool verbose, int WXUNUSED(index) )
+{
+    bool bResult = FALSE ;
+    bool IsBmp = FALSE;
+
+    ICONDIR m_IconDir ;
+    stream.Read (&m_IconDir, sizeof(m_IconDir));
+    wxUint16 nIcons = wxUINT16_SWAP_ON_BE ( m_IconDir.idCount ) ;
+
+    //loop round the icons and choose the best one
+    ICONDIRENTRY * pIconDirEntry = new ICONDIRENTRY [nIcons];
+    ICONDIRENTRY * pCurrentEntry = pIconDirEntry ;
+    int i ;
+    int wMax = 0 ;
+    int colmax = 0 ;
+    int iSel = wxNOT_FOUND ;
+    for (i=0; i < nIcons ; i++ )
+    {
+        stream.Read(pCurrentEntry, sizeof(ICONDIRENTRY));
+        //bHeight and bColorCount are wxUint8
+        if (pCurrentEntry->bWidth >= wMax )
+        {
+            // see if we have more colors, ==0 indicates > 8bpp
+            if (pCurrentEntry->bColorCount == 0 ) pCurrentEntry->bColorCount = 255 ;
+            if (pCurrentEntry->bColorCount >= colmax)
+            {                
+                iSel = i ;
+                wMax =  pCurrentEntry->bWidth ;
+                colmax = pCurrentEntry->bColorCount ;
+            }
+        }
+        pCurrentEntry ++ ;
+    }
+    if (iSel == wxNOT_FOUND)
+    {
+        bResult = FALSE;
+    }
+    else
+    {
+        //seek to selected icon
+        pCurrentEntry = pIconDirEntry + iSel ;
+        stream.SeekI (wxUINT32_SWAP_ON_BE ( pCurrentEntry -> dwImageOffset ), wxFromStart ) ;
+        bResult = LoadDib ( image,  stream, TRUE, IsBmp );
+    }
+    delete [] pIconDirEntry  ;
+    return bResult    ;
+}
+
+
 bool wxBMPHandler::DoCanRead( wxInputStream& stream )
 {
     unsigned char hdr[2];
@@ -780,6 +1123,15 @@ bool wxBMPHandler::DoCanRead( wxInputStream& stream )
     return (hdr[0] == 'B' && hdr[1] == 'M');
 }
 
+bool wxICOHandler::DoCanRead( wxInputStream& stream )
+{
+    unsigned char hdr[4];
+
+    stream.Read(hdr, 4);
+    stream.SeekI(-4, wxFromCurrent);
+    return (hdr[0] == '\0' && hdr[1] == '\0' && hdr[2] == '\1' && hdr[3] == '\0');
+}
+
 #endif // wxUSE_STREAMS
 
 #endif // wxUSE_IMAGE