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