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(wxBMP_FORMAT
) )
93 format
= image
->GetOptionInt(wxBMP_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];
880 stream
.SeekI(-2, wxFromCurrent
);
881 return (hdr
[0] == 'B' && hdr
[1] == 'M');
886 //-----------------------------------------------------------------------------
888 //-----------------------------------------------------------------------------
890 IMPLEMENT_DYNAMIC_CLASS(wxICOHandler
, wxBMPHandler
)
894 wxUint8 bWidth
; // Width of the image
895 wxUint8 bHeight
; // Height of the image (times 2)
896 wxUint8 bColorCount
; // Number of colors in image (0 if >=8bpp)
897 wxUint8 bReserved
; // Reserved
899 // these two are different in icons and cursors:
901 wxUint16 wPlanes
; // Color Planes or XHotSpot
902 wxUint16 wBitCount
; // Bits per pixel or YHotSpot
904 wxUint32 dwBytesInRes
; // how many bytes in this resource?
905 wxUint32 dwImageOffset
; // where in the file is this image
910 wxUint16 idReserved
; // Reserved
911 wxUint16 idType
; // resource type (1 for icons, 2 for cursors)
912 wxUint16 idCount
; // how many images?
916 bool wxICOHandler::SaveFile(wxImage
*image
,
917 wxOutputStream
& stream
,
921 bool bResult
= FALSE
;
922 //sanity check; icon must be less than 127 pixels high and 255 wide
923 if ( image
->GetHeight () > 127 )
926 wxLogError(_("ICO: Image too tall for an icon."));
929 if ( image
->GetWidth () > 255 )
932 wxLogError(_("ICO: Image too wide for an icon."));
936 int images
= 1; // only generate one image
938 // VS: This is a hack of sort - since ICO and CUR files are almost
939 // identical, we have all the meat in wxICOHandler and check for
940 // the actual (handler) type when the code has to distinguish between
942 int type
= (this->GetType() == wxBITMAP_TYPE_CUR
) ? 2 : 1;
944 // write a header, (ICONDIR)
945 // Calculate the header size
946 wxUint32 offset
= 3 * sizeof(wxUint16
);
949 IconDir
.idReserved
= 0;
950 IconDir
.idType
= wxUINT16_SWAP_ON_BE(type
);
951 IconDir
.idCount
= wxUINT16_SWAP_ON_BE(images
);
952 stream
.Write(&IconDir
.idReserved
, sizeof(IconDir
.idReserved
));
953 stream
.Write(&IconDir
.idType
, sizeof(IconDir
.idType
));
954 stream
.Write(&IconDir
.idCount
, sizeof(IconDir
.idCount
));
955 if ( !stream
.IsOk() )
958 wxLogError(_("ICO: Error writing the image file!"));
962 // for each iamage write a description ICONDIRENTRY:
963 ICONDIRENTRY icondirentry
;
964 for (int i
= 0; i
< images
; i
++)
968 if ( image
->HasMask() )
970 // make another image with black/white:
971 mask
= image
->ConvertToMono (image
->GetMaskRed(), image
->GetMaskGreen(), image
->GetMaskBlue() );
973 // now we need to change the masked regions to black:
974 unsigned char r
= image
->GetMaskRed();
975 unsigned char g
= image
->GetMaskGreen();
976 unsigned char b
= image
->GetMaskBlue();
977 if ( (r
!= 0) || (g
!= 0) || (b
!= 0) )
979 // Go round and apply black to the masked bits:
981 for (i
= 0; i
< mask
.GetWidth(); i
++)
983 for (j
= 0; j
< mask
.GetHeight(); j
++)
985 if ((r
== mask
.GetRed(i
, j
)) &&
986 (g
== mask
.GetGreen(i
, j
))&&
987 (b
== mask
.GetBlue(i
, j
)) )
988 image
->SetRGB(i
, j
, 0, 0, 0 );
995 // just make a black mask all over:
996 mask
= image
->Copy();
998 for (i
= 0; i
< mask
.GetWidth(); i
++)
999 for (j
= 0; j
< mask
.GetHeight(); j
++)
1000 mask
.SetRGB(i
, j
, 0, 0, 0 );
1002 // Set the formats for image and mask
1003 // (Windows never saves with more than 8 colors):
1004 image
->SetOption(wxBMP_FORMAT
, wxBMP_8BPP
);
1006 // monochome bitmap:
1007 mask
.SetOption(wxBMP_FORMAT
, wxBMP_1BPP_BW
);
1009 bool IsMask
= FALSE
;
1011 //calculate size and offset of image and mask
1012 wxCountingOutputStream cStream
;
1013 bResult
= SaveDib(image
, cStream
, verbose
, IsBmp
, IsMask
);
1017 wxLogError(_("ICO: Error writing the image file!"));
1022 bResult
= SaveDib(&mask
, cStream
, verbose
, IsBmp
, IsMask
);
1026 wxLogError(_("ICO: Error writing the image file!"));
1029 wxUint32 Size
= cStream
.GetSize();
1031 // wxCountingOutputStream::Ok() always returns TRUE for now and this
1032 // "if" provokes VC++ warnings in optimized build
1034 if ( !cStream
.Ok() )
1037 wxLogError(_("ICO: Error writing the image file!"));
1042 offset
= offset
+ sizeof(ICONDIRENTRY
);
1044 icondirentry
.bWidth
= image
->GetWidth();
1045 icondirentry
.bHeight
= 2 * image
->GetHeight();
1046 icondirentry
.bColorCount
= 0;
1047 icondirentry
.bReserved
= 0;
1048 icondirentry
.wPlanes
= wxUINT16_SWAP_ON_BE(1);
1049 icondirentry
.wBitCount
= wxUINT16_SWAP_ON_BE(wxBMP_8BPP
);
1050 if ( type
== 2 /*CUR*/)
1052 int hx
= image
->HasOption(wxCUR_HOTSPOT_X
) ?
1053 image
->GetOptionInt(wxCUR_HOTSPOT_X
) :
1054 image
->GetWidth() / 2;
1055 int hy
= image
->HasOption(wxCUR_HOTSPOT_Y
) ?
1056 image
->GetOptionInt(wxCUR_HOTSPOT_Y
) :
1057 image
->GetHeight() / 2;
1059 // actually write the values of the hot spot here:
1060 icondirentry
.wPlanes
= wxUINT16_SWAP_ON_BE((wxUint16
)hx
);
1061 icondirentry
.wBitCount
= wxUINT16_SWAP_ON_BE((wxUint16
)hy
);
1063 icondirentry
.dwBytesInRes
= wxUINT32_SWAP_ON_BE(Size
);
1064 icondirentry
.dwImageOffset
= wxUINT32_SWAP_ON_BE(offset
);
1066 // increase size to allow for the data written:
1070 stream
.Write(&icondirentry
.bWidth
, sizeof(icondirentry
.bWidth
));
1071 stream
.Write(&icondirentry
.bHeight
, sizeof(icondirentry
.bHeight
));
1072 stream
.Write(&icondirentry
.bColorCount
, sizeof(icondirentry
.bColorCount
));
1073 stream
.Write(&icondirentry
.bReserved
, sizeof(icondirentry
.bReserved
));
1074 stream
.Write(&icondirentry
.wPlanes
, sizeof(icondirentry
.wPlanes
));
1075 stream
.Write(&icondirentry
.wBitCount
, sizeof(icondirentry
.wBitCount
));
1076 stream
.Write(&icondirentry
.dwBytesInRes
, sizeof(icondirentry
.dwBytesInRes
));
1077 stream
.Write(&icondirentry
.dwImageOffset
, sizeof(icondirentry
.dwImageOffset
));
1078 if ( !stream
.IsOk() )
1081 wxLogError(_("ICO: Error writing the image file!"));
1085 // actually save it:
1087 bResult
= SaveDib(image
, stream
, verbose
, IsBmp
, IsMask
);
1091 wxLogError(_("ICO: Error writing the image file!"));
1096 bResult
= SaveDib(&mask
, stream
, verbose
, IsBmp
, IsMask
);
1100 wxLogError(_("ICO: Error writing the image file!"));
1104 } // end of for loop
1109 bool wxICOHandler::LoadFile(wxImage
*image
, wxInputStream
& stream
,
1110 bool verbose
, int index
)
1113 return DoLoadFile(image
, stream
, verbose
, index
);
1116 bool wxICOHandler::DoLoadFile(wxImage
*image
, wxInputStream
& stream
,
1117 bool verbose
, int index
)
1120 bool bResult
= FALSE
;
1125 off_t iPos
= stream
.TellI();
1126 stream
.Read(&IconDir
, sizeof(IconDir
));
1127 wxUint16 nIcons
= wxUINT16_SWAP_ON_BE(IconDir
.idCount
);
1128 // nType is 1 for Icons, 2 for Cursors:
1129 wxUint16 nType
= wxUINT16_SWAP_ON_BE(IconDir
.idType
);
1131 // loop round the icons and choose the best one:
1132 ICONDIRENTRY
*pIconDirEntry
= new ICONDIRENTRY
[nIcons
];
1133 ICONDIRENTRY
*pCurrentEntry
= pIconDirEntry
;
1136 int iSel
= wxNOT_FOUND
;
1138 for (int i
= 0; i
< nIcons
; i
++ )
1140 stream
.Read(pCurrentEntry
, sizeof(ICONDIRENTRY
));
1141 // bHeight and bColorCount are wxUint8
1142 if ( pCurrentEntry
->bWidth
>= wMax
)
1144 // see if we have more colors, ==0 indicates > 8bpp:
1145 if ( pCurrentEntry
->bColorCount
== 0 )
1146 pCurrentEntry
->bColorCount
= 255;
1147 if ( pCurrentEntry
->bColorCount
>= colmax
)
1150 wMax
= pCurrentEntry
->bWidth
;
1151 colmax
= pCurrentEntry
->bColorCount
;
1159 // VS: Note that we *have* to run the loop above even if index != -1, because
1160 // it reads ICONDIRENTRies.
1164 if ( iSel
== wxNOT_FOUND
|| iSel
< 0 || iSel
>= nIcons
)
1166 wxLogError(_("ICO: Invalid icon index."));
1171 // seek to selected icon:
1172 pCurrentEntry
= pIconDirEntry
+ iSel
;
1173 stream
.SeekI(iPos
+ wxUINT32_SWAP_ON_BE(pCurrentEntry
->dwImageOffset
), wxFromStart
);
1174 bResult
= LoadDib(image
, stream
, TRUE
, IsBmp
);
1175 bool bIsCursorType
= (this->GetType() == wxBITMAP_TYPE_CUR
) || (this->GetType() == wxBITMAP_TYPE_ANI
);
1176 if ( bResult
&& bIsCursorType
&& nType
== 2 )
1178 // it is a cursor, so let's set the hotspot:
1179 image
->SetOption(wxCUR_HOTSPOT_X
, wxUINT16_SWAP_ON_BE(pCurrentEntry
->wPlanes
));
1180 image
->SetOption(wxCUR_HOTSPOT_Y
, wxUINT16_SWAP_ON_BE(pCurrentEntry
->wBitCount
));
1183 delete[] pIconDirEntry
;
1187 int wxICOHandler::GetImageCount(wxInputStream
& stream
)
1190 off_t iPos
= stream
.TellI();
1192 stream
.Read(&IconDir
, sizeof(IconDir
));
1193 wxUint16 nIcons
= wxUINT16_SWAP_ON_BE(IconDir
.idCount
);
1198 bool wxICOHandler::DoCanRead(wxInputStream
& stream
)
1200 unsigned char hdr
[4];
1201 off_t iPos
= stream
.TellI();
1203 stream
.Read(hdr
, 4);
1205 //hdr[2] is one for an icon and two for a cursor
1206 return (hdr
[0] == '\0' && hdr
[1] == '\0' && hdr
[2] == '\1' && hdr
[3] == '\0');
1211 //-----------------------------------------------------------------------------
1213 //-----------------------------------------------------------------------------
1215 IMPLEMENT_DYNAMIC_CLASS(wxCURHandler
, wxICOHandler
)
1217 bool wxCURHandler::DoCanRead(wxInputStream
& stream
)
1219 unsigned char hdr
[4];
1220 off_t iPos
= stream
.TellI();
1222 stream
.Read(hdr
, 4);
1224 //hdr[2] is one for an icon and two for a cursor
1225 return (hdr
[0] == '\0' && hdr
[1] == '\0' && hdr
[2] == '\2' && hdr
[3] == '\0');
1228 //-----------------------------------------------------------------------------
1230 //-----------------------------------------------------------------------------
1232 IMPLEMENT_DYNAMIC_CLASS(wxANIHandler
, wxCURHandler
)
1234 bool wxANIHandler::LoadFile(wxImage
*image
, wxInputStream
& stream
,
1235 bool verbose
, int index
)
1239 static const char *rifftxt
= "RIFF";
1240 static const char *listtxt
= "LIST";
1241 static const char *icotxt
= "icon";
1243 wxInt32
*riff32
= (wxInt32
*) rifftxt
;
1244 wxInt32
*list32
= (wxInt32
*) listtxt
;
1245 wxInt32
*ico32
= (wxInt32
*) icotxt
;
1250 stream
.Read(&FCC1
, 4);
1251 if ( FCC1
!= *riff32
)
1254 // we have a riff file:
1255 while (stream
.IsOk())
1257 // we always have a data size
1258 stream
.Read(&datalen
, 4);
1260 //now either data or a FCC
1261 if ( (FCC1
== *riff32
) || (FCC1
== *list32
) )
1263 stream
.Read(&FCC2
, 4);
1267 if (FCC1
== *ico32
&& iIcon
>= index
)
1269 return DoLoadFile(image
, stream
, verbose
, -1);
1273 stream
.SeekI(stream
.TellI() + datalen
);
1274 if ( FCC1
== *ico32
)
1279 // try to read next data chunk:
1280 stream
.Read(&FCC1
, 4);
1285 bool wxANIHandler::DoCanRead(wxInputStream
& stream
)
1289 static const char *rifftxt
= "RIFF";
1290 static const char *listtxt
= "LIST";
1291 static const char *anihtxt
= "anih";
1293 wxInt32
*riff32
= (wxInt32
*) rifftxt
;
1294 wxInt32
*list32
= (wxInt32
*) listtxt
;
1295 wxInt32
*anih32
= (wxInt32
*) anihtxt
;
1298 stream
.Read(&FCC1
, 4);
1299 if ( FCC1
!= *riff32
)
1302 // we have a riff file:
1303 while ( stream
.IsOk() )
1305 if ( FCC1
!= *anih32
)
1307 // we always have a data size:
1308 stream
.Read(&datalen
, 4);
1310 // now either data or a FCC:
1311 if ( (FCC1
== *riff32
) || (FCC1
== *list32
) )
1313 stream
.Read(&FCC2
, 4);
1317 stream
.SeekI(stream
.TellI() + datalen
);
1320 // try to read next data chunk:
1321 stream
.Read(&FCC1
, 4);
1327 int wxANIHandler::GetImageCount(wxInputStream
& stream
)
1331 static const char *rifftxt
= "RIFF";
1332 static const char *listtxt
= "LIST";
1333 static const char *anihtxt
= "anih";
1335 wxInt32
*riff32
= (wxInt32
*) rifftxt
;
1336 wxInt32
*list32
= (wxInt32
*) listtxt
;
1337 wxInt32
*anih32
= (wxInt32
*) anihtxt
;
1340 stream
.Read(&FCC1
, 4);
1341 if ( FCC1
!= *riff32
)
1344 // we have a riff file:
1345 while ( stream
.IsOk() )
1347 // we always have a data size:
1348 stream
.Read(&datalen
, 4);
1350 // now either data or a FCC:
1351 if ( (FCC1
== *riff32
) || (FCC1
== *list32
) )
1353 stream
.Read(&FCC2
, 4);
1357 if ( FCC1
== *anih32
)
1359 wxUint32
*pData
= new wxUint32
[datalen
/4];
1360 stream
.Read(pData
, datalen
);
1361 int nIcons
= *(pData
+ 1);
1366 stream
.SeekI(stream
.TellI() + datalen
);
1369 // try to read next data chunk:
1370 stream
.Read(&FCC1
, 4);
1376 #endif // wxUSE_ICO_CUR
1378 #endif // wxUSE_IMAGE && wxUSE_STREAMS