1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: wxImage BMP,ICO and CUR handlers
4 // Author: Robert Roebling, Chris Elliott
6 // Copyright: (c) Robert Roebling, Chris Elliott
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
11 #pragma implementation "imagbmp.h"
14 // For compilers that support precompilation, includes "wx.h".
15 #include "wx/wxprec.h"
23 #if wxUSE_IMAGE && wxUSE_STREAMS
25 #include "wx/imagbmp.h"
26 #include "wx/bitmap.h"
30 #include "wx/filefn.h"
31 #include "wx/wfstream.h"
33 #include "wx/module.h"
34 #include "wx/quantize.h"
49 //-----------------------------------------------------------------------------
51 //-----------------------------------------------------------------------------
53 IMPLEMENT_DYNAMIC_CLASS(wxBMPHandler
,wxImageHandler
)
62 #define BI_BITFIELDS 3
65 #define poffset (line * width * 3 + column * 3)
67 bool wxBMPHandler::SaveFile(wxImage
*image
,
68 wxOutputStream
& stream
,
71 return SaveDib(image
, stream
, verbose
, TRUE
/*IsBmp*/, FALSE
/*IsMask*/);
74 bool wxBMPHandler::SaveDib(wxImage
*image
,
75 wxOutputStream
& stream
,
81 wxCHECK_MSG( image
, FALSE
, _T("invalid pointer in wxBMPHandler::SaveFile") );
86 wxLogError(_("BMP: Couldn't save invalid image."));
90 // get the format of the BMP file to save, else use 24bpp
91 unsigned format
= wxBMP_24BPP
;
92 if ( image
->HasOption(wxIMAGE_OPTION_BMP_FORMAT
) )
93 format
= image
->GetOptionInt(wxIMAGE_OPTION_BMP_FORMAT
);
95 wxUint16 bpp
; // # of bits per pixel
96 int palette_size
; // # of color map entries, ie. 2^bpp colors
98 // set the bpp and appropriate palette_size, and do additional checks
99 if ( (format
== wxBMP_1BPP
) || (format
== wxBMP_1BPP_BW
) )
104 else if ( format
== wxBMP_4BPP
)
109 else if ( (format
== wxBMP_8BPP
) || (format
== wxBMP_8BPP_GREY
) ||
110 (format
== wxBMP_8BPP_RED
) || (format
== wxBMP_8BPP_PALETTE
) )
112 // need to set a wxPalette to use this, HOW TO CHECK IF VALID, SIZE?
113 if ((format
== wxBMP_8BPP_PALETTE
)
115 && !image
->HasPalette()
116 #endif // wxUSE_PALETTE
120 wxLogError(_("BMP: wxImage doesn't have own wxPalette."));
126 else // you get 24bpp
128 format
= wxBMP_24BPP
;
133 unsigned width
= image
->GetWidth();
134 unsigned row_padding
= (4 - int(width
*bpp
/8.0) % 4) % 4; // # bytes to pad to dword
135 unsigned row_width
= int(width
* bpp
/8.0) + row_padding
; // # of bytes per row
140 wxUint16 magic
; // format magic, always 'BM'
141 wxUint32 filesize
; // total file size, inc. headers
142 wxUint32 reserved
; // for future use
143 wxUint32 data_offset
; // image data offset in the file
146 wxUint32 bih_size
; // 2nd part's size
147 wxUint32 width
, height
; // bitmap's dimensions
148 wxUint16 planes
; // num of planes
149 wxUint16 bpp
; // bits per pixel
150 wxUint32 compression
; // compression method
151 wxUint32 size_of_bmp
; // size of the bitmap
152 wxUint32 h_res
, v_res
; // image resolution in dpi
153 wxUint32 num_clrs
; // number of colors used
154 wxUint32 num_signif_clrs
;// number of significant colors
157 wxUint32 hdr_size
= 14/*BitmapHeader*/ + 40/*BitmapInfoHeader*/;
159 hdr
.magic
= wxUINT16_SWAP_ON_BE(0x4D42/*'BM'*/);
160 hdr
.filesize
= wxUINT32_SWAP_ON_BE( hdr_size
+ palette_size
*4 +
161 row_width
* image
->GetHeight() );
163 hdr
.data_offset
= wxUINT32_SWAP_ON_BE(hdr_size
+ palette_size
*4);
165 hdr
.bih_size
= wxUINT32_SWAP_ON_BE(hdr_size
- 14);
166 hdr
.width
= wxUINT32_SWAP_ON_BE(image
->GetWidth());
169 hdr
.height
= wxUINT32_SWAP_ON_BE(image
->GetHeight());
173 hdr
.height
= wxUINT32_SWAP_ON_BE(2 * image
->GetHeight());
175 hdr
.planes
= wxUINT16_SWAP_ON_BE(1); // always 1 plane
176 hdr
.bpp
= wxUINT16_SWAP_ON_BE(bpp
);
177 hdr
.compression
= 0; // RGB uncompressed
178 hdr
.size_of_bmp
= wxUINT32_SWAP_ON_BE(row_width
* image
->GetHeight());
179 hdr
.h_res
= hdr
.v_res
= wxUINT32_SWAP_ON_BE(72); // 72dpi is standard
180 hdr
.num_clrs
= wxUINT32_SWAP_ON_BE(palette_size
); // # colors in colormap
181 hdr
.num_signif_clrs
= 0; // all colors are significant
185 if (// VS: looks ugly but compilers tend to do ugly things with structs,
186 // like aligning hdr.filesize's ofset to dword :(
187 // VZ: we should add padding then...
188 !stream
.Write(&hdr
.magic
, 2) ||
189 !stream
.Write(&hdr
.filesize
, 4) ||
190 !stream
.Write(&hdr
.reserved
, 4) ||
191 !stream
.Write(&hdr
.data_offset
, 4)
195 wxLogError(_("BMP: Couldn't write the file (Bitmap) header."));
202 !stream
.Write(&hdr
.bih_size
, 4) ||
203 !stream
.Write(&hdr
.width
, 4) ||
204 !stream
.Write(&hdr
.height
, 4) ||
205 !stream
.Write(&hdr
.planes
, 2) ||
206 !stream
.Write(&hdr
.bpp
, 2) ||
207 !stream
.Write(&hdr
.compression
, 4) ||
208 !stream
.Write(&hdr
.size_of_bmp
, 4) ||
209 !stream
.Write(&hdr
.h_res
, 4) ||
210 !stream
.Write(&hdr
.v_res
, 4) ||
211 !stream
.Write(&hdr
.num_clrs
, 4) ||
212 !stream
.Write(&hdr
.num_signif_clrs
, 4)
216 wxLogError(_("BMP: Couldn't write the file (BitmapInfo) header."));
221 wxPalette
*palette
= NULL
; // entries for quantized images
222 wxUint8
*rgbquad
= NULL
; // for the RGBQUAD bytes for the colormap
223 wxImage
*q_image
= NULL
; // destination for quantized image
225 // if <24bpp use quantization to reduce colors for *some* of the formats
226 if ( (format
== wxBMP_1BPP
) || (format
== wxBMP_4BPP
) ||
227 (format
== wxBMP_8BPP
) || (format
== wxBMP_8BPP_PALETTE
) )
229 // make a new palette and quantize the image
230 if (format
!= wxBMP_8BPP_PALETTE
)
232 q_image
= new wxImage();
234 // I get a delete error using Quantize when desired colors > 236
235 int quantize
= ((palette_size
> 236) ? 236 : palette_size
);
236 // fill the destination too, it gives much nicer 4bpp images
237 wxQuantize::Quantize( *image
, *q_image
, &palette
, quantize
, 0,
238 wxQUANTIZE_FILL_DESTINATION_IMAGE
);
243 palette
= new wxPalette(image
->GetPalette());
244 #endif // wxUSE_PALETTE
248 unsigned char r
, g
, b
;
249 rgbquad
= new wxUint8
[palette_size
*4];
251 for (i
= 0; i
< palette_size
; i
++)
254 if ( !palette
->GetRGB(i
, &r
, &g
, &b
) )
255 #endif // wxUSE_PALETTE
264 // make a 256 entry greyscale colormap or 2 entry black & white
265 else if ( (format
== wxBMP_8BPP_GREY
) || (format
== wxBMP_8BPP_RED
) ||
266 (format
== wxBMP_1BPP_BW
) )
269 rgbquad
= new wxUint8
[palette_size
*4];
271 for (i
= 0; i
< palette_size
; i
++)
273 // if 1BPP_BW then just 0 and 255 then exit
274 if (( i
> 0) && (format
== wxBMP_1BPP_BW
)) i
= 255;
282 // if the colormap was made, then it needs to be written
287 if ( !stream
.Write(rgbquad
, palette_size
*4) )
290 wxLogError(_("BMP: Couldn't write RGB color map."));
294 #endif // wxUSE_PALETTE
302 // pointer to the image data, use quantized if available
303 wxUint8
*data
= (wxUint8
*) image
->GetData();
304 if (q_image
) if (q_image
->Ok()) data
= (wxUint8
*) q_image
->GetData();
306 wxUint8
*buffer
= new wxUint8
[row_width
];
307 memset(buffer
, 0, row_width
);
311 for (y
= image
->GetHeight() -1; y
>= 0; y
--)
313 if ( format
== wxBMP_24BPP
) // 3 bytes per pixel red,green,blue
315 for ( x
= 0; x
< width
; x
++ )
317 pixel
= 3*(y
*width
+ x
);
319 buffer
[3*x
] = data
[pixel
+2];
320 buffer
[3*x
+ 1] = data
[pixel
+1];
321 buffer
[3*x
+ 2] = data
[pixel
];
324 else if ((format
== wxBMP_8BPP
) || // 1 byte per pixel in color
325 (format
== wxBMP_8BPP_PALETTE
))
327 for (x
= 0; x
< width
; x
++)
329 pixel
= 3*(y
*width
+ x
);
331 buffer
[x
] = palette
->GetPixel( data
[pixel
],
335 // FIXME: what should this be? use some std palette maybe?
337 #endif // wxUSE_PALETTE
340 else if ( format
== wxBMP_8BPP_GREY
) // 1 byte per pix, rgb ave to grey
342 for (x
= 0; x
< width
; x
++)
344 pixel
= 3*(y
*width
+ x
);
345 buffer
[x
] = (wxUint8
)(.299*data
[pixel
] +
350 else if ( format
== wxBMP_8BPP_RED
) // 1 byte per pixel, red as greys
352 for (x
= 0; x
< width
; x
++)
354 buffer
[x
] = (wxUint8
)data
[3*(y
*width
+ x
)];
357 else if ( format
== wxBMP_4BPP
) // 4 bpp in color
359 for (x
= 0; x
< width
; x
+=2)
361 pixel
= 3*(y
*width
+ x
);
363 // fill buffer, ignore if > width
366 ((wxUint8
)palette
->GetPixel(data
[pixel
],
368 data
[pixel
+2]) << 4) |
371 : ((wxUint8
)palette
->GetPixel(data
[pixel
+3],
375 // FIXME: what should this be? use some std palette maybe?
377 #endif // wxUSE_PALETTE
380 else if ( format
== wxBMP_1BPP
) // 1 bpp in "color"
382 for (x
= 0; x
< width
; x
+=8)
384 pixel
= 3*(y
*width
+ x
);
387 buffer
[x
/8] = ((wxUint8
)palette
->GetPixel(data
[pixel
], data
[pixel
+1], data
[pixel
+2]) << 7) |
388 (((x
+1) > width
) ? 0 : ((wxUint8
)palette
->GetPixel(data
[pixel
+3], data
[pixel
+4], data
[pixel
+5]) << 6)) |
389 (((x
+2) > width
) ? 0 : ((wxUint8
)palette
->GetPixel(data
[pixel
+6], data
[pixel
+7], data
[pixel
+8]) << 5)) |
390 (((x
+3) > width
) ? 0 : ((wxUint8
)palette
->GetPixel(data
[pixel
+9], data
[pixel
+10], data
[pixel
+11]) << 4)) |
391 (((x
+4) > width
) ? 0 : ((wxUint8
)palette
->GetPixel(data
[pixel
+12], data
[pixel
+13], data
[pixel
+14]) << 3)) |
392 (((x
+5) > width
) ? 0 : ((wxUint8
)palette
->GetPixel(data
[pixel
+15], data
[pixel
+16], data
[pixel
+17]) << 2)) |
393 (((x
+6) > width
) ? 0 : ((wxUint8
)palette
->GetPixel(data
[pixel
+18], data
[pixel
+19], data
[pixel
+20]) << 1)) |
394 (((x
+7) > width
) ? 0 : ((wxUint8
)palette
->GetPixel(data
[pixel
+21], data
[pixel
+22], data
[pixel
+23]) ));
396 // FIXME: what should this be? use some std palette maybe?
398 #endif // wxUSE_PALETTE
401 else if ( format
== wxBMP_1BPP_BW
) // 1 bpp B&W colormap from red color ONLY
403 for (x
= 0; x
< width
; x
+=8)
405 pixel
= 3*(y
*width
+ x
);
408 (((wxUint8
)(data
[pixel
] /128.)) << 7) |
409 (((x
+1) > width
) ? 0 : (((wxUint8
)(data
[pixel
+3] /128.)) << 6)) |
410 (((x
+2) > width
) ? 0 : (((wxUint8
)(data
[pixel
+6] /128.)) << 5)) |
411 (((x
+3) > width
) ? 0 : (((wxUint8
)(data
[pixel
+9] /128.)) << 4)) |
412 (((x
+4) > width
) ? 0 : (((wxUint8
)(data
[pixel
+12]/128.)) << 3)) |
413 (((x
+5) > width
) ? 0 : (((wxUint8
)(data
[pixel
+15]/128.)) << 2)) |
414 (((x
+6) > width
) ? 0 : (((wxUint8
)(data
[pixel
+18]/128.)) << 1)) |
415 (((x
+7) > width
) ? 0 : (((wxUint8
)(data
[pixel
+21]/128.)) ));
419 if ( !stream
.Write(buffer
, row_width
) )
422 wxLogError(_("BMP: Couldn't write data."));
426 #endif // wxUSE_PALETTE
434 #endif // wxUSE_PALETTE
443 unsigned char r
, g
, b
;
446 bool wxBMPHandler::DoLoadDib(wxImage
* image
, int width
, int height
,
447 int bpp
, int ncolors
, int comp
,
448 off_t bmpOffset
, wxInputStream
& stream
,
449 bool verbose
, bool IsBmp
, bool hasPalette
)
451 wxInt32 aDword
, rmask
= 0, gmask
= 0, bmask
= 0;
452 int rshift
= 0, gshift
= 0, bshift
= 0;
458 // allocate space for palette if needed:
463 cmap
= new _cmap
[ncolors
];
467 wxLogError(_("BMP: Couldn't allocate memory."));
474 // destroy existing here instead of:
476 image
->Create(width
, height
);
478 unsigned char *ptr
= image
->GetData();
483 wxLogError( _("BMP: Couldn't allocate memory.") );
489 // Reading the palette, if it exists:
490 if ( bpp
< 16 && ncolors
!= 0 )
492 unsigned char* r
= new unsigned char[ncolors
];
493 unsigned char* g
= new unsigned char[ncolors
];
494 unsigned char* b
= new unsigned char[ncolors
];
495 for (int j
= 0; j
< ncolors
; j
++)
499 stream
.Read(bbuf
, 4);
510 //used in reading .ico file mask
511 r
[j
] = cmap
[j
].r
= j
* 255;
512 g
[j
] = cmap
[j
].g
= j
* 255;
513 b
[j
] = cmap
[j
].b
= j
* 255;
518 // Set the palette for the wxImage
519 image
->SetPalette(wxPalette(ncolors
, r
, g
, b
));
520 #endif // wxUSE_PALETTE
526 else if ( bpp
== 16 || bpp
== 32 )
528 if ( comp
== BI_BITFIELDS
)
531 stream
.Read(dbuf
, 4 * 3);
532 bmask
= wxINT32_SWAP_ON_BE(dbuf
[0]);
533 gmask
= wxINT32_SWAP_ON_BE(dbuf
[1]);
534 rmask
= wxINT32_SWAP_ON_BE(dbuf
[2]);
535 // find shift amount.. ugly, but i can't think of a better way:
536 for (bit
= 0; bit
< bpp
; bit
++)
538 if (bmask
& (1 << bit
))
540 if (gmask
& (1 << bit
))
542 if (rmask
& (1 << bit
))
546 else if ( bpp
== 16 )
555 else if ( bpp
== 32 )
567 * Reading the image data
570 stream
.SeekI(bmpOffset
); // else icon, just carry on
572 unsigned char *data
= ptr
;
574 /* set the whole image to the background color */
575 if ( bpp
< 16 && (comp
== BI_RLE4
|| comp
== BI_RLE8
) )
577 for (int i
= 0; i
< width
* height
; i
++)
588 int linesize
= ((width
* bpp
+ 31) / 32) * 4;
590 /* BMPs are stored upside down */
591 for ( line
= (height
- 1); line
>= 0; line
-- )
594 for ( column
= 0; column
< width
; )
600 aByte
= stream
.GetC();
604 for (bit
= 0; bit
< 8 && column
< width
; bit
++)
606 index
= ((aByte
& (0x80 >> bit
)) ? 1 : 0);
607 ptr
[poffset
] = cmap
[index
].r
;
608 ptr
[poffset
+ 1] = cmap
[index
].g
;
609 ptr
[poffset
+ 2] = cmap
[index
].b
;
615 if ( comp
== BI_RLE4
)
618 wxLogError(_("DIB Header: Cannot deal with 4bit encoded yet."));
626 for (nibble
= 0; nibble
< 2 && column
< width
; nibble
++)
628 index
= ((aByte
& (0xF0 >> nibble
* 4)) >> (!nibble
* 4));
631 ptr
[poffset
] = cmap
[index
].r
;
632 ptr
[poffset
+ 1] = cmap
[index
].g
;
633 ptr
[poffset
+ 2] = cmap
[index
].b
;
640 if ( comp
== BI_RLE8
)
644 aByte
= stream
.GetC();
649 /* column = width; */
651 else if ( aByte
== 1 )
656 else if ( aByte
== 2 )
658 aByte
= stream
.GetC();
660 linepos
= column
* bpp
/ 8;
661 aByte
= stream
.GetC();
666 int absolute
= aByte
;
667 for (int k
= 0; k
< absolute
; k
++)
670 aByte
= stream
.GetC();
671 ptr
[poffset
] = cmap
[aByte
].r
;
672 ptr
[poffset
+ 1] = cmap
[aByte
].g
;
673 ptr
[poffset
+ 2] = cmap
[aByte
].b
;
676 if ( absolute
& 0x01 )
677 aByte
= stream
.GetC();
682 for ( int l
= 0; l
< first
&& column
< width
; l
++ )
684 ptr
[poffset
] = cmap
[aByte
].r
;
685 ptr
[poffset
+ 1] = cmap
[aByte
].g
;
686 ptr
[poffset
+ 2] = cmap
[aByte
].b
;
694 ptr
[poffset
] = cmap
[aByte
].r
;
695 ptr
[poffset
+ 1] = cmap
[aByte
].g
;
696 ptr
[poffset
+ 2] = cmap
[aByte
].b
;
698 // linepos += size; seems to be wrong, RR
702 else if ( bpp
== 24 )
704 stream
.Read(bbuf
, 3);
706 ptr
[poffset
] = (unsigned char)bbuf
[2];
707 ptr
[poffset
+ 1] = (unsigned char)bbuf
[1];
708 ptr
[poffset
+ 2] = (unsigned char)bbuf
[0];
711 else if ( bpp
== 16 )
714 stream
.Read(&aWord
, 2);
715 aWord
= wxUINT16_SWAP_ON_BE(aWord
);
717 temp
= (aWord
& rmask
) >> rshift
;
719 temp
= (aWord
& gmask
) >> gshift
;
720 ptr
[poffset
+ 1] = temp
;
721 temp
= (aWord
& bmask
) >> bshift
;
722 ptr
[poffset
+ 2] = temp
;
728 stream
.Read(&aDword
, 4);
729 aDword
= wxINT32_SWAP_ON_BE(aDword
);
731 temp
= (aDword
& rmask
) >> rshift
;
733 temp
= (aDword
& gmask
) >> gshift
;
734 ptr
[poffset
+ 1] = temp
;
735 temp
= (aDword
& bmask
) >> bshift
;
736 ptr
[poffset
+ 2] = temp
;
740 while ( (linepos
< linesize
) && (comp
!= 1) && (comp
!= 2) )
742 stream
.Read(&aByte
, 1);
744 if ( stream
.LastError() != wxStream_NOERROR
)
751 image
->SetMask(FALSE
);
753 return stream
.IsOk();
756 bool wxBMPHandler::LoadDib(wxImage
*image
, wxInputStream
& stream
,
757 bool verbose
, bool IsBmp
)
764 offset
= 0; // keep gcc quiet
767 // read the header off the .BMP format file
769 offset
= stream
.TellI();
770 if (offset
== wxInvalidOffset
) offset
= 0;
772 stream
.Read(bbuf
, 2);
773 stream
.Read(dbuf
, 16);
777 stream
.Read(dbuf
, 4);
780 wxInt32 size
= wxINT32_SWAP_ON_BE(dbuf
[0]);
782 offset
= offset
+ wxINT32_SWAP_ON_BE(dbuf
[2]);
784 stream
.Read(dbuf
, 4 * 2);
785 int width
= (int)wxINT32_SWAP_ON_BE(dbuf
[0]);
786 int height
= (int)wxINT32_SWAP_ON_BE(dbuf
[1]);
787 if ( !IsBmp
)height
= height
/ 2; // for icons divide by 2
792 wxLogError( _("DIB Header: Image width > 32767 pixels for file.") );
795 if ( height
> 32767 )
798 wxLogError( _("DIB Header: Image height > 32767 pixels for file.") );
802 stream
.Read(&aWord
, 2);
805 int planes = (int)wxUINT16_SWAP_ON_BE( aWord );
807 stream
.Read(&aWord
, 2);
808 int bpp
= (int)wxUINT16_SWAP_ON_BE(aWord
);
809 if ( bpp
!= 1 && bpp
!= 4 && bpp
!= 8 && bpp
!= 16 && bpp
!= 24 && bpp
!= 32 )
812 wxLogError( _("DIB Header: Unknown bitdepth in file.") );
816 stream
.Read(dbuf
, 4 * 4);
817 int comp
= (int)wxINT32_SWAP_ON_BE(dbuf
[0]);
818 if ( comp
!= BI_RGB
&& comp
!= BI_RLE4
&& comp
!= BI_RLE8
&&
819 comp
!= BI_BITFIELDS
)
822 wxLogError( _("DIB Header: Unknown encoding in file.") );
826 stream
.Read(dbuf
, 4 * 2);
827 int ncolors
= (int)wxINT32_SWAP_ON_BE( dbuf
[0] );
830 /* some more sanity checks */
831 if (((comp
== BI_RLE4
) && (bpp
!= 4)) ||
832 ((comp
== BI_RLE8
) && (bpp
!= 8)) ||
833 ((comp
== BI_BITFIELDS
) && (bpp
!= 16 && bpp
!= 32)))
836 wxLogError( _("DIB Header: Encoding doesn't match bitdepth.") );
840 //read DIB; this is the BMP image or the XOR part of an icon image
841 if ( !DoLoadDib(image
, width
, height
, bpp
, ncolors
, comp
, offset
, stream
,
842 verbose
, IsBmp
, TRUE
) )
845 wxLogError( _("Error in reading image DIB .") );
851 //read Icon mask which is monochrome
852 //there is no palette, so we will create one
854 if ( !DoLoadDib(&mask
, width
, height
, 1, 2, BI_RGB
, offset
, stream
,
855 verbose
, IsBmp
, FALSE
) )
858 wxLogError( _("ICO: Error in reading mask DIB.") );
861 image
->SetMaskFromImage(mask
, 255, 255, 255);
868 bool wxBMPHandler::LoadFile(wxImage
*image
, wxInputStream
& stream
,
869 bool verbose
, int WXUNUSED(index
))
871 // Read a single DIB fom the file:
872 return LoadDib(image
, stream
, verbose
, TRUE
/*isBmp*/);
875 bool wxBMPHandler::DoCanRead(wxInputStream
& stream
)
877 unsigned char hdr
[2];
879 if ( !stream
.Read(hdr
, WXSIZEOF(hdr
)) )
882 // do we have the BMP file signature?
883 return hdr
[0] == 'B' && hdr
[1] == 'M';
888 //-----------------------------------------------------------------------------
890 //-----------------------------------------------------------------------------
892 IMPLEMENT_DYNAMIC_CLASS(wxICOHandler
, wxBMPHandler
)
896 wxUint8 bWidth
; // Width of the image
897 wxUint8 bHeight
; // Height of the image (times 2)
898 wxUint8 bColorCount
; // Number of colors in image (0 if >=8bpp)
899 wxUint8 bReserved
; // Reserved
901 // these two are different in icons and cursors:
903 wxUint16 wPlanes
; // Color Planes or XHotSpot
904 wxUint16 wBitCount
; // Bits per pixel or YHotSpot
906 wxUint32 dwBytesInRes
; // how many bytes in this resource?
907 wxUint32 dwImageOffset
; // where in the file is this image
912 wxUint16 idReserved
; // Reserved
913 wxUint16 idType
; // resource type (1 for icons, 2 for cursors)
914 wxUint16 idCount
; // how many images?
918 bool wxICOHandler::SaveFile(wxImage
*image
,
919 wxOutputStream
& stream
,
923 bool bResult
= FALSE
;
924 //sanity check; icon must be less than 127 pixels high and 255 wide
925 if ( image
->GetHeight () > 127 )
928 wxLogError(_("ICO: Image too tall for an icon."));
931 if ( image
->GetWidth () > 255 )
934 wxLogError(_("ICO: Image too wide for an icon."));
938 int images
= 1; // only generate one image
940 // VS: This is a hack of sort - since ICO and CUR files are almost
941 // identical, we have all the meat in wxICOHandler and check for
942 // the actual (handler) type when the code has to distinguish between
944 int type
= (this->GetType() == wxBITMAP_TYPE_CUR
) ? 2 : 1;
946 // write a header, (ICONDIR)
947 // Calculate the header size
948 wxUint32 offset
= 3 * sizeof(wxUint16
);
951 IconDir
.idReserved
= 0;
952 IconDir
.idType
= wxUINT16_SWAP_ON_BE(type
);
953 IconDir
.idCount
= wxUINT16_SWAP_ON_BE(images
);
954 stream
.Write(&IconDir
.idReserved
, sizeof(IconDir
.idReserved
));
955 stream
.Write(&IconDir
.idType
, sizeof(IconDir
.idType
));
956 stream
.Write(&IconDir
.idCount
, sizeof(IconDir
.idCount
));
957 if ( !stream
.IsOk() )
960 wxLogError(_("ICO: Error writing the image file!"));
964 // for each iamage write a description ICONDIRENTRY:
965 ICONDIRENTRY icondirentry
;
966 for (int i
= 0; i
< images
; i
++)
970 if ( image
->HasMask() )
972 // make another image with black/white:
973 mask
= image
->ConvertToMono (image
->GetMaskRed(), image
->GetMaskGreen(), image
->GetMaskBlue() );
975 // now we need to change the masked regions to black:
976 unsigned char r
= image
->GetMaskRed();
977 unsigned char g
= image
->GetMaskGreen();
978 unsigned char b
= image
->GetMaskBlue();
979 if ( (r
!= 0) || (g
!= 0) || (b
!= 0) )
981 // Go round and apply black to the masked bits:
983 for (i
= 0; i
< mask
.GetWidth(); i
++)
985 for (j
= 0; j
< mask
.GetHeight(); j
++)
987 if ((r
== mask
.GetRed(i
, j
)) &&
988 (g
== mask
.GetGreen(i
, j
))&&
989 (b
== mask
.GetBlue(i
, j
)) )
990 image
->SetRGB(i
, j
, 0, 0, 0 );
997 // just make a black mask all over:
998 mask
= image
->Copy();
1000 for (i
= 0; i
< mask
.GetWidth(); i
++)
1001 for (j
= 0; j
< mask
.GetHeight(); j
++)
1002 mask
.SetRGB(i
, j
, 0, 0, 0 );
1004 // Set the formats for image and mask
1005 // (Windows never saves with more than 8 colors):
1006 image
->SetOption(wxIMAGE_OPTION_BMP_FORMAT
, wxBMP_8BPP
);
1008 // monochome bitmap:
1009 mask
.SetOption(wxIMAGE_OPTION_BMP_FORMAT
, wxBMP_1BPP_BW
);
1011 bool IsMask
= FALSE
;
1013 //calculate size and offset of image and mask
1014 wxCountingOutputStream cStream
;
1015 bResult
= SaveDib(image
, cStream
, verbose
, IsBmp
, IsMask
);
1019 wxLogError(_("ICO: Error writing the image file!"));
1024 bResult
= SaveDib(&mask
, cStream
, verbose
, IsBmp
, IsMask
);
1028 wxLogError(_("ICO: Error writing the image file!"));
1031 wxUint32 Size
= cStream
.GetSize();
1033 // wxCountingOutputStream::Ok() always returns TRUE for now and this
1034 // "if" provokes VC++ warnings in optimized build
1036 if ( !cStream
.Ok() )
1039 wxLogError(_("ICO: Error writing the image file!"));
1044 offset
= offset
+ sizeof(ICONDIRENTRY
);
1046 icondirentry
.bWidth
= image
->GetWidth();
1047 icondirentry
.bHeight
= 2 * image
->GetHeight();
1048 icondirentry
.bColorCount
= 0;
1049 icondirentry
.bReserved
= 0;
1050 icondirentry
.wPlanes
= wxUINT16_SWAP_ON_BE(1);
1051 icondirentry
.wBitCount
= wxUINT16_SWAP_ON_BE(wxBMP_8BPP
);
1052 if ( type
== 2 /*CUR*/)
1054 int hx
= image
->HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_X
) ?
1055 image
->GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_X
) :
1056 image
->GetWidth() / 2;
1057 int hy
= image
->HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y
) ?
1058 image
->GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_Y
) :
1059 image
->GetHeight() / 2;
1061 // actually write the values of the hot spot here:
1062 icondirentry
.wPlanes
= wxUINT16_SWAP_ON_BE((wxUint16
)hx
);
1063 icondirentry
.wBitCount
= wxUINT16_SWAP_ON_BE((wxUint16
)hy
);
1065 icondirentry
.dwBytesInRes
= wxUINT32_SWAP_ON_BE(Size
);
1066 icondirentry
.dwImageOffset
= wxUINT32_SWAP_ON_BE(offset
);
1068 // increase size to allow for the data written:
1072 stream
.Write(&icondirentry
.bWidth
, sizeof(icondirentry
.bWidth
));
1073 stream
.Write(&icondirentry
.bHeight
, sizeof(icondirentry
.bHeight
));
1074 stream
.Write(&icondirentry
.bColorCount
, sizeof(icondirentry
.bColorCount
));
1075 stream
.Write(&icondirentry
.bReserved
, sizeof(icondirentry
.bReserved
));
1076 stream
.Write(&icondirentry
.wPlanes
, sizeof(icondirentry
.wPlanes
));
1077 stream
.Write(&icondirentry
.wBitCount
, sizeof(icondirentry
.wBitCount
));
1078 stream
.Write(&icondirentry
.dwBytesInRes
, sizeof(icondirentry
.dwBytesInRes
));
1079 stream
.Write(&icondirentry
.dwImageOffset
, sizeof(icondirentry
.dwImageOffset
));
1080 if ( !stream
.IsOk() )
1083 wxLogError(_("ICO: Error writing the image file!"));
1087 // actually save it:
1089 bResult
= SaveDib(image
, stream
, verbose
, IsBmp
, IsMask
);
1093 wxLogError(_("ICO: Error writing the image file!"));
1098 bResult
= SaveDib(&mask
, stream
, verbose
, IsBmp
, IsMask
);
1102 wxLogError(_("ICO: Error writing the image file!"));
1106 } // end of for loop
1111 bool wxICOHandler::LoadFile(wxImage
*image
, wxInputStream
& stream
,
1112 bool verbose
, int index
)
1115 return DoLoadFile(image
, stream
, verbose
, index
);
1118 bool wxICOHandler::DoLoadFile(wxImage
*image
, wxInputStream
& stream
,
1119 bool WXUNUSED(verbose
), int index
)
1121 bool bResult
= FALSE
;
1126 off_t iPos
= stream
.TellI();
1127 stream
.Read(&IconDir
, sizeof(IconDir
));
1128 wxUint16 nIcons
= wxUINT16_SWAP_ON_BE(IconDir
.idCount
);
1129 // nType is 1 for Icons, 2 for Cursors:
1130 wxUint16 nType
= wxUINT16_SWAP_ON_BE(IconDir
.idType
);
1132 // loop round the icons and choose the best one:
1133 ICONDIRENTRY
*pIconDirEntry
= new ICONDIRENTRY
[nIcons
];
1134 ICONDIRENTRY
*pCurrentEntry
= pIconDirEntry
;
1137 int iSel
= wxNOT_FOUND
;
1139 for (int i
= 0; i
< nIcons
; i
++ )
1141 stream
.Read(pCurrentEntry
, sizeof(ICONDIRENTRY
));
1142 // bHeight and bColorCount are wxUint8
1143 if ( pCurrentEntry
->bWidth
>= wMax
)
1145 // see if we have more colors, ==0 indicates > 8bpp:
1146 if ( pCurrentEntry
->bColorCount
== 0 )
1147 pCurrentEntry
->bColorCount
= 255;
1148 if ( pCurrentEntry
->bColorCount
>= colmax
)
1151 wMax
= pCurrentEntry
->bWidth
;
1152 colmax
= pCurrentEntry
->bColorCount
;
1160 // VS: Note that we *have* to run the loop above even if index != -1, because
1161 // it reads ICONDIRENTRies.
1165 if ( iSel
== wxNOT_FOUND
|| iSel
< 0 || iSel
>= nIcons
)
1167 wxLogError(_("ICO: Invalid icon index."));
1172 // seek to selected icon:
1173 pCurrentEntry
= pIconDirEntry
+ iSel
;
1174 stream
.SeekI(iPos
+ wxUINT32_SWAP_ON_BE(pCurrentEntry
->dwImageOffset
), wxFromStart
);
1175 bResult
= LoadDib(image
, stream
, TRUE
, IsBmp
);
1176 bool bIsCursorType
= (this->GetType() == wxBITMAP_TYPE_CUR
) || (this->GetType() == wxBITMAP_TYPE_ANI
);
1177 if ( bResult
&& bIsCursorType
&& nType
== 2 )
1179 // it is a cursor, so let's set the hotspot:
1180 image
->SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X
, wxUINT16_SWAP_ON_BE(pCurrentEntry
->wPlanes
));
1181 image
->SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y
, wxUINT16_SWAP_ON_BE(pCurrentEntry
->wBitCount
));
1184 delete[] pIconDirEntry
;
1188 int wxICOHandler::GetImageCount(wxInputStream
& stream
)
1191 off_t iPos
= stream
.TellI();
1193 stream
.Read(&IconDir
, sizeof(IconDir
));
1194 wxUint16 nIcons
= wxUINT16_SWAP_ON_BE(IconDir
.idCount
);
1199 bool wxICOHandler::DoCanRead(wxInputStream
& stream
)
1202 unsigned char hdr
[4];
1203 if ( !stream
.Read(hdr
, WXSIZEOF(hdr
)) )
1206 // hdr[2] is one for an icon and two for a cursor
1207 return hdr
[0] == '\0' && hdr
[1] == '\0' && hdr
[2] == '\1' && hdr
[3] == '\0';
1212 //-----------------------------------------------------------------------------
1214 //-----------------------------------------------------------------------------
1216 IMPLEMENT_DYNAMIC_CLASS(wxCURHandler
, wxICOHandler
)
1218 bool wxCURHandler::DoCanRead(wxInputStream
& stream
)
1221 unsigned char hdr
[4];
1222 if ( !stream
.Read(hdr
, WXSIZEOF(hdr
)) )
1225 // hdr[2] is one for an icon and two for a cursor
1226 return hdr
[0] == '\0' && hdr
[1] == '\0' && hdr
[2] == '\2' && hdr
[3] == '\0';
1229 //-----------------------------------------------------------------------------
1231 //-----------------------------------------------------------------------------
1233 IMPLEMENT_DYNAMIC_CLASS(wxANIHandler
, wxCURHandler
)
1235 bool wxANIHandler::LoadFile(wxImage
*image
, wxInputStream
& stream
,
1236 bool verbose
, int index
)
1240 static const char *rifftxt
= "RIFF";
1241 static const char *listtxt
= "LIST";
1242 static const char *icotxt
= "icon";
1244 wxInt32
*riff32
= (wxInt32
*) rifftxt
;
1245 wxInt32
*list32
= (wxInt32
*) listtxt
;
1246 wxInt32
*ico32
= (wxInt32
*) icotxt
;
1251 stream
.Read(&FCC1
, 4);
1252 if ( FCC1
!= *riff32
)
1255 // we have a riff file:
1256 while (stream
.IsOk())
1258 // we always have a data size
1259 stream
.Read(&datalen
, 4);
1260 datalen
= wxINT32_SWAP_ON_BE(datalen
) ;
1261 //data should be padded to make even number of bytes
1262 if (datalen
% 2 == 1) datalen
++ ;
1263 //now either data or a FCC
1264 if ( (FCC1
== *riff32
) || (FCC1
== *list32
) )
1266 stream
.Read(&FCC2
, 4);
1270 if (FCC1
== *ico32
&& iIcon
>= index
)
1272 return DoLoadFile(image
, stream
, verbose
, -1);
1276 stream
.SeekI(stream
.TellI() + datalen
);
1277 if ( FCC1
== *ico32
)
1282 // try to read next data chunk:
1283 stream
.Read(&FCC1
, 4);
1288 bool wxANIHandler::DoCanRead(wxInputStream
& stream
)
1292 static const char *rifftxt
= "RIFF";
1293 static const char *listtxt
= "LIST";
1294 static const char *anihtxt
= "anih";
1296 wxInt32
*riff32
= (wxInt32
*) rifftxt
;
1297 wxInt32
*list32
= (wxInt32
*) listtxt
;
1298 wxInt32
*anih32
= (wxInt32
*) anihtxt
;
1301 if ( !stream
.Read(&FCC1
, 4) )
1304 if ( FCC1
!= *riff32
)
1307 // we have a riff file:
1308 while ( stream
.IsOk() )
1310 if ( FCC1
== *anih32
)
1312 // we always have a data size:
1313 stream
.Read(&datalen
, 4);
1314 datalen
= wxINT32_SWAP_ON_BE(datalen
) ;
1315 //data should be padded to make even number of bytes
1316 if (datalen
% 2 == 1) datalen
++ ;
1317 // now either data or a FCC:
1318 if ( (FCC1
== *riff32
) || (FCC1
== *list32
) )
1320 stream
.Read(&FCC2
, 4);
1324 stream
.SeekI(stream
.TellI() + datalen
);
1327 // try to read next data chunk:
1328 if ( !stream
.Read(&FCC1
, 4) )
1330 // reading failed -- either EOF or IO error, bail out anyhow
1338 int wxANIHandler::GetImageCount(wxInputStream
& stream
)
1342 static const char *rifftxt
= "RIFF";
1343 static const char *listtxt
= "LIST";
1344 static const char *anihtxt
= "anih";
1346 wxInt32
*riff32
= (wxInt32
*) rifftxt
;
1347 wxInt32
*list32
= (wxInt32
*) listtxt
;
1348 wxInt32
*anih32
= (wxInt32
*) anihtxt
;
1351 stream
.Read(&FCC1
, 4);
1352 if ( FCC1
!= *riff32
)
1355 // we have a riff file:
1356 while ( stream
.IsOk() )
1358 // we always have a data size:
1359 stream
.Read(&datalen
, 4);
1360 datalen
= wxINT32_SWAP_ON_BE(datalen
) ;
1361 //data should be padded to make even number of bytes
1362 if (datalen
% 2 == 1) datalen
++ ;
1363 // now either data or a FCC:
1364 if ( (FCC1
== *riff32
) || (FCC1
== *list32
) )
1366 stream
.Read(&FCC2
, 4);
1370 if ( FCC1
== *anih32
)
1372 wxUint32
*pData
= new wxUint32
[datalen
/4];
1373 stream
.Read(pData
, datalen
);
1374 int nIcons
= wxINT32_SWAP_ON_BE(*(pData
+ 1));
1379 stream
.SeekI(stream
.TellI() + datalen
);
1382 // try to read next data chunk:
1383 stream
.Read(&FCC1
, 4);
1389 #endif // wxUSE_ICO_CUR
1391 #endif // wxUSE_IMAGE && wxUSE_STREAMS