]> git.saurik.com Git - wxWidgets.git/blob - src/common/imagbmp.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
don't use negative sizes for row/column labels subwindows to avoid GTK warnings ...
[wxWidgets.git] / src / common / imagbmp.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/imagbmp.cpp
3 // Purpose: wxImage BMP,ICO and CUR handlers
4 // Author: Robert Roebling, Chris Elliott
5 // RCS-ID: $Id$
6 // Copyright: (c) Robert Roebling, Chris Elliott
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
9
10 // For compilers that support precompilation, includes "wx.h".
11 #include "wx/wxprec.h"
12
13 #ifdef __BORLANDC__
14 #pragma hdrstop
15 #endif
16
17 #if wxUSE_IMAGE
18
19 #include "wx/imagbmp.h"
20
21 #ifndef WX_PRECOMP
22 #ifdef __WXMSW__
23 #include "wx/msw/wrapwin.h"
24 #endif
25 #include "wx/log.h"
26 #include "wx/app.h"
27 #include "wx/bitmap.h"
28 #include "wx/palette.h"
29 #include "wx/intl.h"
30 #include "wx/math.h"
31 #endif
32
33 #include "wx/filefn.h"
34 #include "wx/wfstream.h"
35 #include "wx/quantize.h"
36 #include "wx/anidecod.h"
37
38 // For memcpy
39 #include <string.h>
40
41 //-----------------------------------------------------------------------------
42 // wxBMPHandler
43 //-----------------------------------------------------------------------------
44
45 IMPLEMENT_DYNAMIC_CLASS(wxBMPHandler,wxImageHandler)
46
47 #if wxUSE_STREAMS
48
49 #ifndef BI_RGB
50 #define BI_RGB 0
51 #endif
52
53 #ifndef BI_RLE8
54 #define BI_RLE8 1
55 #endif
56
57 #ifndef BI_RLE4
58 #define BI_RLE4 2
59 #endif
60
61 #ifndef BI_BITFIELDS
62 #define BI_BITFIELDS 3
63 #endif
64
65 #define poffset (line * width * 3 + column * 3)
66
67 bool wxBMPHandler::SaveFile(wxImage *image,
68 wxOutputStream& stream,
69 bool verbose)
70 {
71 return SaveDib(image, stream, verbose, true/*IsBmp*/, false/*IsMask*/);
72 }
73
74 bool wxBMPHandler::SaveDib(wxImage *image,
75 wxOutputStream& stream,
76 bool verbose,
77 bool IsBmp,
78 bool IsMask)
79
80 {
81 wxCHECK_MSG( image, false, _T("invalid pointer in wxBMPHandler::SaveFile") );
82
83 if ( !image->Ok() )
84 {
85 if ( verbose )
86 wxLogError(_("BMP: Couldn't save invalid image."));
87 return false;
88 }
89
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);
94
95 wxUint16 bpp; // # of bits per pixel
96 int palette_size; // # of color map entries, ie. 2^bpp colors
97
98 // set the bpp and appropriate palette_size, and do additional checks
99 if ( (format == wxBMP_1BPP) || (format == wxBMP_1BPP_BW) )
100 {
101 bpp = 1;
102 palette_size = 2;
103 }
104 else if ( format == wxBMP_4BPP )
105 {
106 bpp = 4;
107 palette_size = 16;
108 }
109 else if ( (format == wxBMP_8BPP) || (format == wxBMP_8BPP_GREY) ||
110 (format == wxBMP_8BPP_RED) || (format == wxBMP_8BPP_PALETTE) )
111 {
112 // need to set a wxPalette to use this, HOW TO CHECK IF VALID, SIZE?
113 if ((format == wxBMP_8BPP_PALETTE)
114 #if wxUSE_PALETTE
115 && !image->HasPalette()
116 #endif // wxUSE_PALETTE
117 )
118 {
119 if ( verbose )
120 wxLogError(_("BMP: wxImage doesn't have own wxPalette."));
121 return false;
122 }
123 bpp = 8;
124 palette_size = 256;
125 }
126 else // you get 24bpp
127 {
128 format = wxBMP_24BPP;
129 bpp = 24;
130 palette_size = 0;
131 }
132
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
136
137 struct
138 {
139 // BitmapHeader:
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
144
145 // BitmapInfoHeader:
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 pixels-per-meter
153 wxUint32 num_clrs; // number of colors used
154 wxUint32 num_signif_clrs;// number of significant colors
155 } hdr;
156
157 wxUint32 hdr_size = 14/*BitmapHeader*/ + 40/*BitmapInfoHeader*/;
158
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() );
162 hdr.reserved = 0;
163 hdr.data_offset = wxUINT32_SWAP_ON_BE(hdr_size + palette_size*4);
164
165 hdr.bih_size = wxUINT32_SWAP_ON_BE(hdr_size - 14);
166 hdr.width = wxUINT32_SWAP_ON_BE(image->GetWidth());
167 if ( IsBmp )
168 {
169 hdr.height = wxUINT32_SWAP_ON_BE(image->GetHeight());
170 }
171 else
172 {
173 hdr.height = wxUINT32_SWAP_ON_BE(2 * image->GetHeight());
174 }
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
180 // get the resolution from the image options or fall back to 72dpi standard
181 // for the BMP format if not specified
182 wxUint32 hres = image->GetOptionInt(wxIMAGE_OPTION_RESOLUTIONX),
183 vres = image->GetOptionInt(wxIMAGE_OPTION_RESOLUTIONY);
184 switch ( image->GetOptionInt(wxIMAGE_OPTION_RESOLUTION) )
185 {
186 default:
187 wxFAIL_MSG( _T("unexpected image resolution units") );
188 // fall through
189
190 case wxIMAGE_RESOLUTION_NONE:
191 hres =
192 vres = 72;
193 // fall through to convert it to correct units
194
195 case wxIMAGE_RESOLUTION_INCHES:
196 // convert resolution in inches to resolution in centimeters
197 hres = (wxUint32)(100*mm2inches*hres);
198 vres = (wxUint32)(100*mm2inches*vres);
199 // fall through to convert it to resolution in meters
200
201 case wxIMAGE_RESOLUTION_CM:
202 // convert resolution in centimeters to resolution in meters
203 hres *= 100;
204 vres *= 100;
205 break;
206 }
207
208 hdr.h_res = wxUINT32_SWAP_ON_BE(hres);
209 hdr.v_res = wxUINT32_SWAP_ON_BE(vres);
210 hdr.num_clrs = wxUINT32_SWAP_ON_BE(palette_size); // # colors in colormap
211 hdr.num_signif_clrs = 0; // all colors are significant
212
213 if ( IsBmp )
214 {
215 if (// VS: looks ugly but compilers tend to do ugly things with structs,
216 // like aligning hdr.filesize's ofset to dword :(
217 // VZ: we should add padding then...
218 !stream.Write(&hdr.magic, 2) ||
219 !stream.Write(&hdr.filesize, 4) ||
220 !stream.Write(&hdr.reserved, 4) ||
221 !stream.Write(&hdr.data_offset, 4)
222 )
223 {
224 if (verbose)
225 wxLogError(_("BMP: Couldn't write the file (Bitmap) header."));
226 return false;
227 }
228 }
229 if ( !IsMask )
230 {
231 if (
232 !stream.Write(&hdr.bih_size, 4) ||
233 !stream.Write(&hdr.width, 4) ||
234 !stream.Write(&hdr.height, 4) ||
235 !stream.Write(&hdr.planes, 2) ||
236 !stream.Write(&hdr.bpp, 2) ||
237 !stream.Write(&hdr.compression, 4) ||
238 !stream.Write(&hdr.size_of_bmp, 4) ||
239 !stream.Write(&hdr.h_res, 4) ||
240 !stream.Write(&hdr.v_res, 4) ||
241 !stream.Write(&hdr.num_clrs, 4) ||
242 !stream.Write(&hdr.num_signif_clrs, 4)
243 )
244 {
245 if (verbose)
246 wxLogError(_("BMP: Couldn't write the file (BitmapInfo) header."));
247 return false;
248 }
249 }
250
251 wxPalette *palette = NULL; // entries for quantized images
252 wxUint8 *rgbquad = NULL; // for the RGBQUAD bytes for the colormap
253 wxImage *q_image = NULL; // destination for quantized image
254
255 // if <24bpp use quantization to reduce colors for *some* of the formats
256 if ( (format == wxBMP_1BPP) || (format == wxBMP_4BPP) ||
257 (format == wxBMP_8BPP) || (format == wxBMP_8BPP_PALETTE) )
258 {
259 // make a new palette and quantize the image
260 if (format != wxBMP_8BPP_PALETTE)
261 {
262 q_image = new wxImage();
263
264 // I get a delete error using Quantize when desired colors > 236
265 int quantize = ((palette_size > 236) ? 236 : palette_size);
266 // fill the destination too, it gives much nicer 4bpp images
267 wxQuantize::Quantize( *image, *q_image, &palette, quantize, 0,
268 wxQUANTIZE_FILL_DESTINATION_IMAGE );
269 }
270 else
271 {
272 #if wxUSE_PALETTE
273 palette = new wxPalette(image->GetPalette());
274 #endif // wxUSE_PALETTE
275 }
276
277 int i;
278 unsigned char r, g, b;
279 rgbquad = new wxUint8 [palette_size*4];
280
281 for (i = 0; i < palette_size; i++)
282 {
283 #if wxUSE_PALETTE
284 if ( !palette->GetRGB(i, &r, &g, &b) )
285 #endif // wxUSE_PALETTE
286 r = g = b = 0;
287
288 rgbquad[i*4] = b;
289 rgbquad[i*4+1] = g;
290 rgbquad[i*4+2] = r;
291 rgbquad[i*4+3] = 0;
292 }
293 }
294 // make a 256 entry greyscale colormap or 2 entry black & white
295 else if ( (format == wxBMP_8BPP_GREY) || (format == wxBMP_8BPP_RED) ||
296 (format == wxBMP_1BPP_BW) )
297 {
298 rgbquad = new wxUint8 [palette_size*4];
299
300 for ( int i = 0; i < palette_size; i++ )
301 {
302 // if 1BPP_BW then the value should be either 0 or 255
303 wxUint8 c = (wxUint8)((i > 0) && (format == wxBMP_1BPP_BW) ? 255 : i);
304
305 rgbquad[i*4] =
306 rgbquad[i*4+1] =
307 rgbquad[i*4+2] = c;
308 rgbquad[i*4+3] = 0;
309 }
310 }
311
312 // if the colormap was made, then it needs to be written
313 if (rgbquad)
314 {
315 if ( !IsMask )
316 {
317 if ( !stream.Write(rgbquad, palette_size*4) )
318 {
319 if (verbose)
320 wxLogError(_("BMP: Couldn't write RGB color map."));
321 delete[] rgbquad;
322 #if wxUSE_PALETTE
323 delete palette;
324 #endif // wxUSE_PALETTE
325 delete q_image;
326 return false;
327 }
328 }
329 delete []rgbquad;
330 }
331
332 // pointer to the image data, use quantized if available
333 wxUint8 *data = (wxUint8*) image->GetData();
334 if (q_image) if (q_image->Ok()) data = (wxUint8*) q_image->GetData();
335
336 wxUint8 *buffer = new wxUint8[row_width];
337 memset(buffer, 0, row_width);
338 int y; unsigned x;
339 long int pixel;
340
341 for (y = image->GetHeight() -1; y >= 0; y--)
342 {
343 if ( format == wxBMP_24BPP ) // 3 bytes per pixel red,green,blue
344 {
345 for ( x = 0; x < width; x++ )
346 {
347 pixel = 3*(y*width + x);
348
349 buffer[3*x ] = data[pixel+2];
350 buffer[3*x + 1] = data[pixel+1];
351 buffer[3*x + 2] = data[pixel];
352 }
353 }
354 else if ((format == wxBMP_8BPP) || // 1 byte per pixel in color
355 (format == wxBMP_8BPP_PALETTE))
356 {
357 for (x = 0; x < width; x++)
358 {
359 pixel = 3*(y*width + x);
360 #if wxUSE_PALETTE
361 buffer[x] = (wxUint8)palette->GetPixel( data[pixel],
362 data[pixel+1],
363 data[pixel+2] );
364 #else
365 // FIXME: what should this be? use some std palette maybe?
366 buffer[x] = 0;
367 #endif // wxUSE_PALETTE
368 }
369 }
370 else if ( format == wxBMP_8BPP_GREY ) // 1 byte per pix, rgb ave to grey
371 {
372 for (x = 0; x < width; x++)
373 {
374 pixel = 3*(y*width + x);
375 buffer[x] = (wxUint8)(.299*data[pixel] +
376 .587*data[pixel+1] +
377 .114*data[pixel+2]);
378 }
379 }
380 else if ( format == wxBMP_8BPP_RED ) // 1 byte per pixel, red as greys
381 {
382 for (x = 0; x < width; x++)
383 {
384 buffer[x] = (wxUint8)data[3*(y*width + x)];
385 }
386 }
387 else if ( format == wxBMP_4BPP ) // 4 bpp in color
388 {
389 for (x = 0; x < width; x+=2)
390 {
391 pixel = 3*(y*width + x);
392
393 // fill buffer, ignore if > width
394 #if wxUSE_PALETTE
395 buffer[x/2] = (wxUint8)(
396 ((wxUint8)palette->GetPixel(data[pixel],
397 data[pixel+1],
398 data[pixel+2]) << 4) |
399 (((x+1) > width)
400 ? 0
401 : ((wxUint8)palette->GetPixel(data[pixel+3],
402 data[pixel+4],
403 data[pixel+5]) )) );
404 #else
405 // FIXME: what should this be? use some std palette maybe?
406 buffer[x/2] = 0;
407 #endif // wxUSE_PALETTE
408 }
409 }
410 else if ( format == wxBMP_1BPP ) // 1 bpp in "color"
411 {
412 for (x = 0; x < width; x+=8)
413 {
414 pixel = 3*(y*width + x);
415
416 #if wxUSE_PALETTE
417 buffer[x/8] = (wxUint8)(
418 ((wxUint8)palette->GetPixel(data[pixel], data[pixel+1], data[pixel+2]) << 7) |
419 (((x+1) > width) ? 0 : ((wxUint8)palette->GetPixel(data[pixel+3], data[pixel+4], data[pixel+5]) << 6)) |
420 (((x+2) > width) ? 0 : ((wxUint8)palette->GetPixel(data[pixel+6], data[pixel+7], data[pixel+8]) << 5)) |
421 (((x+3) > width) ? 0 : ((wxUint8)palette->GetPixel(data[pixel+9], data[pixel+10], data[pixel+11]) << 4)) |
422 (((x+4) > width) ? 0 : ((wxUint8)palette->GetPixel(data[pixel+12], data[pixel+13], data[pixel+14]) << 3)) |
423 (((x+5) > width) ? 0 : ((wxUint8)palette->GetPixel(data[pixel+15], data[pixel+16], data[pixel+17]) << 2)) |
424 (((x+6) > width) ? 0 : ((wxUint8)palette->GetPixel(data[pixel+18], data[pixel+19], data[pixel+20]) << 1)) |
425 (((x+7) > width) ? 0 : ((wxUint8)palette->GetPixel(data[pixel+21], data[pixel+22], data[pixel+23]) )) );
426 #else
427 // FIXME: what should this be? use some std palette maybe?
428 buffer[x/8] = 0;
429 #endif // wxUSE_PALETTE
430 }
431 }
432 else if ( format == wxBMP_1BPP_BW ) // 1 bpp B&W colormap from red color ONLY
433 {
434 for (x = 0; x < width; x+=8)
435 {
436 pixel = 3*(y*width + x);
437
438 buffer[x/8] = (wxUint8)(
439 (((wxUint8)(data[pixel] /128.)) << 7) |
440 (((x+1) > width) ? 0 : (((wxUint8)(data[pixel+3] /128.)) << 6)) |
441 (((x+2) > width) ? 0 : (((wxUint8)(data[pixel+6] /128.)) << 5)) |
442 (((x+3) > width) ? 0 : (((wxUint8)(data[pixel+9] /128.)) << 4)) |
443 (((x+4) > width) ? 0 : (((wxUint8)(data[pixel+12]/128.)) << 3)) |
444 (((x+5) > width) ? 0 : (((wxUint8)(data[pixel+15]/128.)) << 2)) |
445 (((x+6) > width) ? 0 : (((wxUint8)(data[pixel+18]/128.)) << 1)) |
446 (((x+7) > width) ? 0 : (((wxUint8)(data[pixel+21]/128.)) )) );
447 }
448 }
449
450 if ( !stream.Write(buffer, row_width) )
451 {
452 if (verbose)
453 wxLogError(_("BMP: Couldn't write data."));
454 delete[] buffer;
455 #if wxUSE_PALETTE
456 delete palette;
457 #endif // wxUSE_PALETTE
458 delete q_image;
459 return false;
460 }
461 }
462 delete[] buffer;
463 #if wxUSE_PALETTE
464 delete palette;
465 #endif // wxUSE_PALETTE
466 delete q_image;
467
468 return true;
469 }
470
471
472 typedef struct
473 {
474 unsigned char r, g, b;
475 } _cmap;
476
477 bool wxBMPHandler::DoLoadDib(wxImage * image, int width, int height,
478 int bpp, int ncolors, int comp,
479 wxFileOffset bmpOffset, wxInputStream& stream,
480 bool verbose, bool IsBmp, bool hasPalette)
481 {
482 wxInt32 aDword, rmask = 0, gmask = 0, bmask = 0;
483 int rshift = 0, gshift = 0, bshift = 0;
484 int rbits = 0, gbits = 0, bbits = 0;
485 wxInt32 dbuf[4];
486 wxInt8 bbuf[4];
487 wxUint8 aByte;
488 wxUint16 aWord;
489
490 // allocate space for palette if needed:
491 _cmap *cmap;
492
493 if ( bpp < 16 )
494 {
495 cmap = new _cmap[ncolors];
496 if ( !cmap )
497 {
498 if (verbose)
499 wxLogError(_("BMP: Couldn't allocate memory."));
500 return false;
501 }
502 }
503 else
504 cmap = NULL;
505
506 // destroy existing here instead of:
507 image->Destroy();
508 image->Create(width, height);
509
510 unsigned char *ptr = image->GetData();
511
512 if ( !ptr )
513 {
514 if ( verbose )
515 wxLogError( _("BMP: Couldn't allocate memory.") );
516 if ( cmap )
517 delete[] cmap;
518 return false;
519 }
520
521 // Reading the palette, if it exists:
522 if ( bpp < 16 && ncolors != 0 )
523 {
524 unsigned char* r = new unsigned char[ncolors];
525 unsigned char* g = new unsigned char[ncolors];
526 unsigned char* b = new unsigned char[ncolors];
527 for (int j = 0; j < ncolors; j++)
528 {
529 if (hasPalette)
530 {
531 stream.Read(bbuf, 4);
532 cmap[j].b = bbuf[0];
533 cmap[j].g = bbuf[1];
534 cmap[j].r = bbuf[2];
535
536 r[j] = cmap[j].r;
537 g[j] = cmap[j].g;
538 b[j] = cmap[j].b;
539 }
540 else
541 {
542 //used in reading .ico file mask
543 r[j] = cmap[j].r =
544 g[j] = cmap[j].g =
545 b[j] = cmap[j].b = ( j ? 255 : 0 );
546 }
547 }
548
549 #if wxUSE_PALETTE
550 // Set the palette for the wxImage
551 image->SetPalette(wxPalette(ncolors, r, g, b));
552 #endif // wxUSE_PALETTE
553
554 delete[] r;
555 delete[] g;
556 delete[] b;
557 }
558 else if ( bpp == 16 || bpp == 32 )
559 {
560 if ( comp == BI_BITFIELDS )
561 {
562 int bit = 0;
563 stream.Read(dbuf, 4 * 3);
564 rmask = wxINT32_SWAP_ON_BE(dbuf[0]);
565 gmask = wxINT32_SWAP_ON_BE(dbuf[1]);
566 bmask = wxINT32_SWAP_ON_BE(dbuf[2]);
567 // find shift amount (Least significant bit of mask)
568 for (bit = bpp-1; bit>=0; bit--)
569 {
570 if (bmask & (1 << bit))
571 bshift = bit;
572 if (gmask & (1 << bit))
573 gshift = bit;
574 if (rmask & (1 << bit))
575 rshift = bit;
576 }
577 // Find number of bits in mask (MSB-LSB+1)
578 for (bit = 0; bit < bpp; bit++)
579 {
580 if (bmask & (1 << bit))
581 bbits = bit-bshift+1;
582 if (gmask & (1 << bit))
583 gbits = bit-gshift+1;
584 if (rmask & (1 << bit))
585 rbits = bit-rshift+1;
586 }
587 }
588 else if ( bpp == 16 )
589 {
590 rmask = 0x7C00;
591 gmask = 0x03E0;
592 bmask = 0x001F;
593 rshift = 10;
594 gshift = 5;
595 bshift = 0;
596 rbits = 5;
597 gbits = 5;
598 bbits = 5;
599 }
600 else if ( bpp == 32 )
601 {
602 rmask = 0x00FF0000;
603 gmask = 0x0000FF00;
604 bmask = 0x000000FF;
605 rshift = 16;
606 gshift = 8;
607 bshift = 0;
608 rbits = 8;
609 gbits = 8;
610 bbits = 8;
611 }
612 }
613
614 /*
615 * Reading the image data
616 */
617 if ( IsBmp )
618 stream.SeekI(bmpOffset); // else icon, just carry on
619
620 unsigned char *data = ptr;
621
622 /* set the whole image to the background color */
623 if ( bpp < 16 && (comp == BI_RLE4 || comp == BI_RLE8) )
624 {
625 for (int i = 0; i < width * height; i++)
626 {
627 *ptr++ = cmap[0].r;
628 *ptr++ = cmap[0].g;
629 *ptr++ = cmap[0].b;
630 }
631 ptr = data;
632 }
633
634 int linesize = ((width * bpp + 31) / 32) * 4;
635
636 /* BMPs are stored upside down */
637 for ( int line = (height - 1); line >= 0; line-- )
638 {
639 int linepos = 0;
640 for ( int column = 0; column < width ; )
641 {
642 if ( bpp < 16 )
643 {
644 linepos++;
645 aByte = stream.GetC();
646 if ( bpp == 1 )
647 {
648 for (int bit = 0; bit < 8 && column < width; bit++)
649 {
650 int index = ((aByte & (0x80 >> bit)) ? 1 : 0);
651 ptr[poffset] = cmap[index].r;
652 ptr[poffset + 1] = cmap[index].g;
653 ptr[poffset + 2] = cmap[index].b;
654 column++;
655 }
656 }
657 else if ( bpp == 4 )
658 {
659 if ( comp == BI_RLE4 )
660 {
661 wxUint8 first;
662 first = aByte;
663 aByte = stream.GetC();
664 if ( first == 0 )
665 {
666 if ( aByte == 0 )
667 {
668 if ( column > 0 )
669 column = width;
670 }
671 else if ( aByte == 1 )
672 {
673 column = width;
674 line = -1;
675 }
676 else if ( aByte == 2 )
677 {
678 aByte = stream.GetC();
679 column += aByte;
680 linepos = column * bpp / 4;
681 aByte = stream.GetC();
682 line -= aByte; // upside down
683 }
684 else
685 {
686 int absolute = aByte;
687 wxUint8 nibble[2] ;
688 int readBytes = 0 ;
689 for (int k = 0; k < absolute; k++)
690 {
691 if ( !(k % 2 ) )
692 {
693 ++readBytes ;
694 aByte = stream.GetC();
695 nibble[0] = (wxUint8)( (aByte & 0xF0) >> 4 ) ;
696 nibble[1] = (wxUint8)( aByte & 0x0F ) ;
697 }
698 ptr[poffset ] = cmap[nibble[k%2]].r;
699 ptr[poffset + 1] = cmap[nibble[k%2]].g;
700 ptr[poffset + 2] = cmap[nibble[k%2]].b;
701 column++;
702 if ( k % 2 )
703 linepos++;
704 }
705 if ( readBytes & 0x01 )
706 aByte = stream.GetC();
707 }
708 }
709 else
710 {
711 wxUint8 nibble[2] ;
712 nibble[0] = (wxUint8)( (aByte & 0xF0) >> 4 ) ;
713 nibble[1] = (wxUint8)( aByte & 0x0F ) ;
714
715 for ( int l = 0; l < first && column < width; l++ )
716 {
717 ptr[poffset ] = cmap[nibble[l%2]].r;
718 ptr[poffset + 1] = cmap[nibble[l%2]].g;
719 ptr[poffset + 2] = cmap[nibble[l%2]].b;
720 column++;
721 if ( l % 2 )
722 linepos++;
723 }
724 }
725 }
726 else
727 {
728 for (int nibble = 0; nibble < 2 && column < width; nibble++)
729 {
730 int index = ((aByte & (0xF0 >> nibble * 4)) >> (!nibble * 4));
731 if ( index >= 16 )
732 index = 15;
733 ptr[poffset] = cmap[index].r;
734 ptr[poffset + 1] = cmap[index].g;
735 ptr[poffset + 2] = cmap[index].b;
736 column++;
737 }
738 }
739 }
740 else if ( bpp == 8 )
741 {
742 if ( comp == BI_RLE8 )
743 {
744 unsigned char first;
745 first = aByte;
746 aByte = stream.GetC();
747 if ( first == 0 )
748 {
749 if ( aByte == 0 )
750 {
751 /* column = width; */
752 }
753 else if ( aByte == 1 )
754 {
755 column = width;
756 line = -1;
757 }
758 else if ( aByte == 2 )
759 {
760 aByte = stream.GetC();
761 column += aByte;
762 linepos = column * bpp / 8;
763 aByte = stream.GetC();
764 line += aByte;
765 }
766 else
767 {
768 int absolute = aByte;
769 for (int k = 0; k < absolute; k++)
770 {
771 linepos++;
772 aByte = stream.GetC();
773 ptr[poffset ] = cmap[aByte].r;
774 ptr[poffset + 1] = cmap[aByte].g;
775 ptr[poffset + 2] = cmap[aByte].b;
776 column++;
777 }
778 if ( absolute & 0x01 )
779 aByte = stream.GetC();
780 }
781 }
782 else
783 {
784 for ( int l = 0; l < first && column < width; l++ )
785 {
786 ptr[poffset ] = cmap[aByte].r;
787 ptr[poffset + 1] = cmap[aByte].g;
788 ptr[poffset + 2] = cmap[aByte].b;
789 column++;
790 linepos++;
791 }
792 }
793 }
794 else
795 {
796 ptr[poffset ] = cmap[aByte].r;
797 ptr[poffset + 1] = cmap[aByte].g;
798 ptr[poffset + 2] = cmap[aByte].b;
799 column++;
800 // linepos += size; seems to be wrong, RR
801 }
802 }
803 }
804 else if ( bpp == 24 )
805 {
806 stream.Read(bbuf, 3);
807 linepos += 3;
808 ptr[poffset ] = (unsigned char)bbuf[2];
809 ptr[poffset + 1] = (unsigned char)bbuf[1];
810 ptr[poffset + 2] = (unsigned char)bbuf[0];
811 column++;
812 }
813 else if ( bpp == 16 )
814 {
815 unsigned char temp;
816 stream.Read(&aWord, 2);
817 aWord = wxUINT16_SWAP_ON_BE(aWord);
818 linepos += 2;
819 /* use the masks and calculated amonut of shift
820 to retrieve the color data out of the word. Then
821 shift it left by (8 - number of bits) such that
822 the image has the proper dynamic range */
823 temp = (unsigned char)((aWord & rmask) >> rshift << (8-rbits));
824 ptr[poffset] = temp;
825 temp = (unsigned char)((aWord & gmask) >> gshift << (8-gbits));
826 ptr[poffset + 1] = temp;
827 temp = (unsigned char)((aWord & bmask) >> bshift << (8-bbits));
828 ptr[poffset + 2] = temp;
829 column++;
830 }
831 else
832 {
833 unsigned char temp;
834 stream.Read(&aDword, 4);
835 aDword = wxINT32_SWAP_ON_BE(aDword);
836 linepos += 4;
837 temp = (unsigned char)((aDword & rmask) >> rshift);
838 ptr[poffset] = temp;
839 temp = (unsigned char)((aDword & gmask) >> gshift);
840 ptr[poffset + 1] = temp;
841 temp = (unsigned char)((aDword & bmask) >> bshift);
842 ptr[poffset + 2] = temp;
843 column++;
844 }
845 }
846 while ( (linepos < linesize) && (comp != 1) && (comp != 2) )
847 {
848 stream.Read(&aByte, 1);
849 linepos += 1;
850 if ( !stream )
851 break;
852 }
853 }
854
855 delete[] cmap;
856
857 image->SetMask(false);
858
859 const wxStreamError err = stream.GetLastError();
860 return err == wxSTREAM_NO_ERROR || err == wxSTREAM_EOF;
861 }
862
863 bool wxBMPHandler::LoadDib(wxImage *image, wxInputStream& stream,
864 bool verbose, bool IsBmp)
865 {
866 wxUint16 aWord;
867 wxInt32 dbuf[4];
868 wxInt8 bbuf[4];
869
870 wxFileOffset offset = 0; // keep gcc quiet
871 if ( IsBmp )
872 {
873 // read the header off the .BMP format file
874
875 offset = stream.TellI();
876 if (offset == wxInvalidOffset)
877 offset = 0;
878
879 stream.Read(bbuf, 2);
880 stream.Read(dbuf, 16);
881 }
882 else
883 {
884 stream.Read(dbuf, 4);
885 }
886 #if 0 // unused
887 wxInt32 size = wxINT32_SWAP_ON_BE(dbuf[0]);
888 #endif
889 offset = offset + wxINT32_SWAP_ON_BE(dbuf[2]);
890
891 stream.Read(dbuf, 4 * 2);
892 int width = wxINT32_SWAP_ON_BE((int)dbuf[0]);
893 int height = wxINT32_SWAP_ON_BE((int)dbuf[1]);
894 if ( !IsBmp)height = height / 2; // for icons divide by 2
895
896 if ( width > 32767 )
897 {
898 if (verbose)
899 wxLogError( _("DIB Header: Image width > 32767 pixels for file.") );
900 return false;
901 }
902 if ( height > 32767 )
903 {
904 if (verbose)
905 wxLogError( _("DIB Header: Image height > 32767 pixels for file.") );
906 return false;
907 }
908
909 stream.Read(&aWord, 2);
910 /*
911 TODO
912 int planes = (int)wxUINT16_SWAP_ON_BE( aWord );
913 */
914 stream.Read(&aWord, 2);
915 int bpp = wxUINT16_SWAP_ON_BE((int)aWord);
916 if ( bpp != 1 && bpp != 4 && bpp != 8 && bpp != 16 && bpp != 24 && bpp != 32 )
917 {
918 if (verbose)
919 wxLogError( _("DIB Header: Unknown bitdepth in file.") );
920 return false;
921 }
922
923 stream.Read(dbuf, 4 * 4);
924 int comp = wxINT32_SWAP_ON_BE((int)dbuf[0]);
925 if ( comp != BI_RGB && comp != BI_RLE4 && comp != BI_RLE8 &&
926 comp != BI_BITFIELDS )
927 {
928 if (verbose)
929 wxLogError( _("DIB Header: Unknown encoding in file.") );
930 return false;
931 }
932
933 stream.Read(dbuf, 4 * 2);
934
935 int ncolors = wxINT32_SWAP_ON_BE( (int)dbuf[0] );
936 if (ncolors == 0)
937 ncolors = 1 << bpp;
938 /* some more sanity checks */
939 if (((comp == BI_RLE4) && (bpp != 4)) ||
940 ((comp == BI_RLE8) && (bpp != 8)) ||
941 ((comp == BI_BITFIELDS) && (bpp != 16 && bpp != 32)))
942 {
943 if (verbose)
944 wxLogError( _("DIB Header: Encoding doesn't match bitdepth.") );
945 return false;
946 }
947
948 //read DIB; this is the BMP image or the XOR part of an icon image
949 if ( !DoLoadDib(image, width, height, bpp, ncolors, comp, offset, stream,
950 verbose, IsBmp, true) )
951 {
952 if (verbose)
953 wxLogError( _("Error in reading image DIB.") );
954 return false;
955 }
956
957 if ( !IsBmp )
958 {
959 //read Icon mask which is monochrome
960 //there is no palette, so we will create one
961 wxImage mask;
962 if ( !DoLoadDib(&mask, width, height, 1, 2, BI_RGB, offset, stream,
963 verbose, IsBmp, false) )
964 {
965 if (verbose)
966 wxLogError( _("ICO: Error in reading mask DIB.") );
967 return false;
968 }
969 image->SetMaskFromImage(mask, 255, 255, 255);
970
971 }
972
973 // the resolution in the bitmap header is in meters, convert to centimeters
974 image->SetOption(wxIMAGE_OPTION_RESOLUTIONUNIT, wxIMAGE_RESOLUTION_CM);
975 image->SetOption(wxIMAGE_OPTION_RESOLUTIONX, dbuf[2]/100);
976 image->SetOption(wxIMAGE_OPTION_RESOLUTIONY, dbuf[3]/100);
977
978 return true;
979 }
980
981 bool wxBMPHandler::LoadFile(wxImage *image, wxInputStream& stream,
982 bool verbose, int WXUNUSED(index))
983 {
984 // Read a single DIB fom the file:
985 return LoadDib(image, stream, verbose, true/*isBmp*/);
986 }
987
988 bool wxBMPHandler::DoCanRead(wxInputStream& stream)
989 {
990 unsigned char hdr[2];
991
992 if ( !stream.Read(hdr, WXSIZEOF(hdr)) )
993 return false;
994
995 // do we have the BMP file signature?
996 return hdr[0] == 'B' && hdr[1] == 'M';
997 }
998
999 #endif // wxUSE_STREAMS
1000
1001
1002 #if wxUSE_ICO_CUR
1003 //-----------------------------------------------------------------------------
1004 // wxICOHandler
1005 //-----------------------------------------------------------------------------
1006
1007 IMPLEMENT_DYNAMIC_CLASS(wxICOHandler, wxBMPHandler)
1008
1009 #if wxUSE_STREAMS
1010
1011 struct ICONDIRENTRY
1012 {
1013 wxUint8 bWidth; // Width of the image
1014 wxUint8 bHeight; // Height of the image (times 2)
1015 wxUint8 bColorCount; // Number of colors in image (0 if >=8bpp)
1016 wxUint8 bReserved; // Reserved
1017
1018 // these two are different in icons and cursors:
1019 // icon or cursor
1020 wxUint16 wPlanes; // Color Planes or XHotSpot
1021 wxUint16 wBitCount; // Bits per pixel or YHotSpot
1022
1023 wxUint32 dwBytesInRes; // how many bytes in this resource?
1024 wxUint32 dwImageOffset; // where in the file is this image
1025 };
1026
1027 struct ICONDIR
1028 {
1029 wxUint16 idReserved; // Reserved
1030 wxUint16 idType; // resource type (1 for icons, 2 for cursors)
1031 wxUint16 idCount; // how many images?
1032 };
1033
1034
1035 bool wxICOHandler::SaveFile(wxImage *image,
1036 wxOutputStream& stream,
1037 bool verbose)
1038
1039 {
1040 //sanity check; icon must be less than 127 pixels high and 255 wide
1041 if ( image->GetHeight () > 127 )
1042 {
1043 if ( verbose )
1044 wxLogError(_("ICO: Image too tall for an icon."));
1045 return false;
1046 }
1047 if ( image->GetWidth () > 255 )
1048 {
1049 if ( verbose )
1050 wxLogError(_("ICO: Image too wide for an icon."));
1051 return false;
1052 }
1053
1054 const int images = 1; // only generate one image
1055
1056 // VS: This is a hack of sort - since ICO and CUR files are almost
1057 // identical, we have all the meat in wxICOHandler and check for
1058 // the actual (handler) type when the code has to distinguish between
1059 // the two formats
1060 int type = (this->GetType() == wxBITMAP_TYPE_CUR) ? 2 : 1;
1061
1062 // write a header, (ICONDIR)
1063 // Calculate the header size
1064 wxUint32 offset = 3 * sizeof(wxUint16);
1065
1066 ICONDIR IconDir;
1067 IconDir.idReserved = 0;
1068 IconDir.idType = wxUINT16_SWAP_ON_BE((wxUint16)type);
1069 IconDir.idCount = wxUINT16_SWAP_ON_BE((wxUint16)images);
1070 stream.Write(&IconDir.idReserved, sizeof(IconDir.idReserved));
1071 stream.Write(&IconDir.idType, sizeof(IconDir.idType));
1072 stream.Write(&IconDir.idCount, sizeof(IconDir.idCount));
1073 if ( !stream.IsOk() )
1074 {
1075 if ( verbose )
1076 wxLogError(_("ICO: Error writing the image file!"));
1077 return false;
1078 }
1079
1080 // for each iamage write a description ICONDIRENTRY:
1081 ICONDIRENTRY icondirentry;
1082 for (int img = 0; img < images; img++)
1083 {
1084 wxImage mask;
1085
1086 if ( image->HasMask() )
1087 {
1088 // make another image with black/white:
1089 mask = image->ConvertToMono (image->GetMaskRed(), image->GetMaskGreen(), image->GetMaskBlue() );
1090
1091 // now we need to change the masked regions to black:
1092 unsigned char r = image->GetMaskRed();
1093 unsigned char g = image->GetMaskGreen();
1094 unsigned char b = image->GetMaskBlue();
1095 if ( (r != 0) || (g != 0) || (b != 0) )
1096 {
1097 // Go round and apply black to the masked bits:
1098 int i, j;
1099 for (i = 0; i < mask.GetWidth(); i++)
1100 {
1101 for (j = 0; j < mask.GetHeight(); j++)
1102 {
1103 if ((r == mask.GetRed(i, j)) &&
1104 (g == mask.GetGreen(i, j))&&
1105 (b == mask.GetBlue(i, j)) )
1106 image->SetRGB(i, j, 0, 0, 0 );
1107 }
1108 }
1109 }
1110 }
1111 else
1112 {
1113 // just make a black mask all over:
1114 mask = image->Copy();
1115 int i, j;
1116 for (i = 0; i < mask.GetWidth(); i++)
1117 for (j = 0; j < mask.GetHeight(); j++)
1118 mask.SetRGB(i, j, 0, 0, 0 );
1119 }
1120 // Set the formats for image and mask
1121 // (Windows never saves with more than 8 colors):
1122 image->SetOption(wxIMAGE_OPTION_BMP_FORMAT, wxBMP_8BPP);
1123
1124 // monochome bitmap:
1125 mask.SetOption(wxIMAGE_OPTION_BMP_FORMAT, wxBMP_1BPP_BW);
1126 bool IsBmp = false;
1127 bool IsMask = false;
1128
1129 //calculate size and offset of image and mask
1130 wxCountingOutputStream cStream;
1131 bool bResult = SaveDib(image, cStream, verbose, IsBmp, IsMask);
1132 if ( !bResult )
1133 {
1134 if ( verbose )
1135 wxLogError(_("ICO: Error writing the image file!"));
1136 return false;
1137 }
1138 IsMask = true;
1139
1140 bResult = SaveDib(&mask, cStream, verbose, IsBmp, IsMask);
1141 if ( !bResult )
1142 {
1143 if ( verbose )
1144 wxLogError(_("ICO: Error writing the image file!"));
1145 return false;
1146 }
1147 wxUint32 Size = cStream.GetSize();
1148
1149 // wxCountingOutputStream::IsOk() always returns true for now and this
1150 // "if" provokes VC++ warnings in optimized build
1151 #if 0
1152 if ( !cStream.Ok() )
1153 {
1154 if ( verbose )
1155 wxLogError(_("ICO: Error writing the image file!"));
1156 return false;
1157 }
1158 #endif // 0
1159
1160 offset = offset + sizeof(ICONDIRENTRY);
1161
1162 icondirentry.bWidth = (wxUint8)image->GetWidth();
1163 icondirentry.bHeight = (wxUint8)(2 * image->GetHeight());
1164 icondirentry.bColorCount = 0;
1165 icondirentry.bReserved = 0;
1166 icondirentry.wPlanes = wxUINT16_SWAP_ON_BE(1);
1167 icondirentry.wBitCount = wxUINT16_SWAP_ON_BE(wxBMP_8BPP);
1168 if ( type == 2 /*CUR*/)
1169 {
1170 int hx = image->HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_X) ?
1171 image->GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_X) :
1172 image->GetWidth() / 2;
1173 int hy = image->HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y) ?
1174 image->GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_Y) :
1175 image->GetHeight() / 2;
1176
1177 // actually write the values of the hot spot here:
1178 icondirentry.wPlanes = wxUINT16_SWAP_ON_BE((wxUint16)hx);
1179 icondirentry.wBitCount = wxUINT16_SWAP_ON_BE((wxUint16)hy);
1180 }
1181 icondirentry.dwBytesInRes = wxUINT32_SWAP_ON_BE(Size);
1182 icondirentry.dwImageOffset = wxUINT32_SWAP_ON_BE(offset);
1183
1184 // increase size to allow for the data written:
1185 offset += Size;
1186
1187 // write to stream:
1188 stream.Write(&icondirentry.bWidth, sizeof(icondirentry.bWidth));
1189 stream.Write(&icondirentry.bHeight, sizeof(icondirentry.bHeight));
1190 stream.Write(&icondirentry.bColorCount, sizeof(icondirentry.bColorCount));
1191 stream.Write(&icondirentry.bReserved, sizeof(icondirentry.bReserved));
1192 stream.Write(&icondirentry.wPlanes, sizeof(icondirentry.wPlanes));
1193 stream.Write(&icondirentry.wBitCount, sizeof(icondirentry.wBitCount));
1194 stream.Write(&icondirentry.dwBytesInRes, sizeof(icondirentry.dwBytesInRes));
1195 stream.Write(&icondirentry.dwImageOffset, sizeof(icondirentry.dwImageOffset));
1196 if ( !stream.IsOk() )
1197 {
1198 if ( verbose )
1199 wxLogError(_("ICO: Error writing the image file!"));
1200 return false;
1201 }
1202
1203 // actually save it:
1204 IsMask = false;
1205 bResult = SaveDib(image, stream, verbose, IsBmp, IsMask);
1206 if ( !bResult )
1207 {
1208 if ( verbose )
1209 wxLogError(_("ICO: Error writing the image file!"));
1210 return false;
1211 }
1212 IsMask = true;
1213
1214 bResult = SaveDib(&mask, stream, verbose, IsBmp, IsMask);
1215 if ( !bResult )
1216 {
1217 if ( verbose )
1218 wxLogError(_("ICO: Error writing the image file!"));
1219 return false;
1220 }
1221
1222 } // end of for loop
1223
1224 return true;
1225 }
1226
1227 bool wxICOHandler::LoadFile(wxImage *image, wxInputStream& stream,
1228 bool verbose, int index)
1229 {
1230 stream.SeekI(0);
1231 return DoLoadFile(image, stream, verbose, index);
1232 }
1233
1234 bool wxICOHandler::DoLoadFile(wxImage *image, wxInputStream& stream,
1235 bool WXUNUSED(verbose), int index)
1236 {
1237 bool bResult wxDUMMY_INITIALIZE(false);
1238 bool IsBmp = false;
1239
1240 ICONDIR IconDir;
1241
1242 wxFileOffset iPos = stream.TellI();
1243 stream.Read(&IconDir, sizeof(IconDir));
1244 wxUint16 nIcons = wxUINT16_SWAP_ON_BE(IconDir.idCount);
1245 // nType is 1 for Icons, 2 for Cursors:
1246 wxUint16 nType = wxUINT16_SWAP_ON_BE(IconDir.idType);
1247
1248 // loop round the icons and choose the best one:
1249 ICONDIRENTRY *pIconDirEntry = new ICONDIRENTRY[nIcons];
1250 ICONDIRENTRY *pCurrentEntry = pIconDirEntry;
1251 int wMax = 0;
1252 int colmax = 0;
1253 int iSel = wxNOT_FOUND;
1254
1255 for (int i = 0; i < nIcons; i++ )
1256 {
1257 stream.Read(pCurrentEntry, sizeof(ICONDIRENTRY));
1258 // bHeight and bColorCount are wxUint8
1259 if ( pCurrentEntry->bWidth >= wMax )
1260 {
1261 // see if we have more colors, ==0 indicates > 8bpp:
1262 if ( pCurrentEntry->bColorCount == 0 )
1263 pCurrentEntry->bColorCount = 255;
1264 if ( pCurrentEntry->bColorCount >= colmax )
1265 {
1266 iSel = i;
1267 wMax = pCurrentEntry->bWidth;
1268 colmax = pCurrentEntry->bColorCount;
1269 }
1270 }
1271 pCurrentEntry++;
1272 }
1273
1274 if ( index != -1 )
1275 {
1276 // VS: Note that we *have* to run the loop above even if index != -1, because
1277 // it reads ICONDIRENTRies.
1278 iSel = index;
1279 }
1280
1281 if ( iSel == wxNOT_FOUND || iSel < 0 || iSel >= nIcons )
1282 {
1283 wxLogError(_("ICO: Invalid icon index."));
1284 bResult = false;
1285 }
1286 else
1287 {
1288 // seek to selected icon:
1289 pCurrentEntry = pIconDirEntry + iSel;
1290 stream.SeekI(iPos + wxUINT32_SWAP_ON_BE(pCurrentEntry->dwImageOffset), wxFromStart);
1291 bResult = LoadDib(image, stream, true, IsBmp);
1292 bool bIsCursorType = (this->GetType() == wxBITMAP_TYPE_CUR) || (this->GetType() == wxBITMAP_TYPE_ANI);
1293 if ( bResult && bIsCursorType && nType == 2 )
1294 {
1295 // it is a cursor, so let's set the hotspot:
1296 image->SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X, wxUINT16_SWAP_ON_BE(pCurrentEntry->wPlanes));
1297 image->SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, wxUINT16_SWAP_ON_BE(pCurrentEntry->wBitCount));
1298 }
1299 }
1300 delete[] pIconDirEntry;
1301 return bResult;
1302 }
1303
1304 int wxICOHandler::GetImageCount(wxInputStream& stream)
1305 {
1306 ICONDIR IconDir;
1307 wxFileOffset iPos = stream.TellI();
1308 stream.SeekI(0);
1309 stream.Read(&IconDir, sizeof(IconDir));
1310 wxUint16 nIcons = wxUINT16_SWAP_ON_BE(IconDir.idCount);
1311 stream.SeekI(iPos);
1312 return (int)nIcons;
1313 }
1314
1315 bool wxICOHandler::DoCanRead(wxInputStream& stream)
1316 {
1317 stream.SeekI(0);
1318 unsigned char hdr[4];
1319 if ( !stream.Read(hdr, WXSIZEOF(hdr)) )
1320 return false;
1321
1322 // hdr[2] is one for an icon and two for a cursor
1323 return hdr[0] == '\0' && hdr[1] == '\0' && hdr[2] == '\1' && hdr[3] == '\0';
1324 }
1325
1326 #endif // wxUSE_STREAMS
1327
1328
1329 //-----------------------------------------------------------------------------
1330 // wxCURHandler
1331 //-----------------------------------------------------------------------------
1332
1333 IMPLEMENT_DYNAMIC_CLASS(wxCURHandler, wxICOHandler)
1334
1335 #if wxUSE_STREAMS
1336
1337 bool wxCURHandler::DoCanRead(wxInputStream& stream)
1338 {
1339 stream.SeekI(0);
1340 unsigned char hdr[4];
1341 if ( !stream.Read(hdr, WXSIZEOF(hdr)) )
1342 return false;
1343
1344 // hdr[2] is one for an icon and two for a cursor
1345 return hdr[0] == '\0' && hdr[1] == '\0' && hdr[2] == '\2' && hdr[3] == '\0';
1346 }
1347
1348 #endif // wxUSE_STREAMS
1349
1350 //-----------------------------------------------------------------------------
1351 // wxANIHandler
1352 //-----------------------------------------------------------------------------
1353
1354 IMPLEMENT_DYNAMIC_CLASS(wxANIHandler, wxCURHandler)
1355
1356 #if wxUSE_STREAMS
1357
1358 bool wxANIHandler::LoadFile(wxImage *image, wxInputStream& stream,
1359 bool WXUNUSED(verbose), int index)
1360 {
1361 wxANIDecoder decoder;
1362 if (!decoder.Load(stream))
1363 return false;
1364
1365 return decoder.ConvertToImage(index != -1 ? (size_t)index : 0, image);
1366 }
1367
1368 bool wxANIHandler::DoCanRead(wxInputStream& stream)
1369 {
1370 wxANIDecoder decod;
1371 return decod.CanRead(stream);
1372 }
1373
1374 int wxANIHandler::GetImageCount(wxInputStream& stream)
1375 {
1376 wxANIDecoder decoder;
1377 if (!decoder.Load(stream))
1378 return wxNOT_FOUND;
1379
1380 return decoder.GetFrameCount();
1381 }
1382
1383 #endif // wxUSE_STREAMS
1384
1385 #endif // wxUSE_ICO_CUR
1386
1387 #endif // wxUSE_IMAGE
wxWidgets (Impactor)