]> 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
implement button support for pre-XP systems (or with themes disabled); using only...
[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 int hres, vres;
184 switch ( GetResolutionFromOptions(*image, &hres, &vres) )
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 = (int)(10*mm2inches*hres);
198 vres = (int)(10*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 struct BMPPalette
473 {
474 static void Free(BMPPalette* pal) { delete [] pal; }
475
476 unsigned char r, g, b;
477 };
478
479 bool wxBMPHandler::DoLoadDib(wxImage * image, int width, int height,
480 int bpp, int ncolors, int comp,
481 wxFileOffset bmpOffset, wxInputStream& stream,
482 bool verbose, bool IsBmp, bool hasPalette)
483 {
484 wxInt32 aDword, rmask = 0, gmask = 0, bmask = 0, amask = 0;
485 int rshift = 0, gshift = 0, bshift = 0, ashift = 0;
486 int rbits = 0, gbits = 0, bbits = 0;
487 wxInt32 dbuf[4];
488 wxInt8 bbuf[4];
489 wxUint8 aByte;
490 wxUint16 aWord;
491
492 // allocate space for palette if needed:
493 BMPPalette *cmap;
494
495 if ( bpp < 16 )
496 {
497 cmap = new BMPPalette[ncolors];
498 if ( !cmap )
499 {
500 if (verbose)
501 wxLogError(_("BMP: Couldn't allocate memory."));
502 return false;
503 }
504 }
505 else // no palette
506 {
507 cmap = NULL;
508 }
509
510 wxON_BLOCK_EXIT1(&BMPPalette::Free, cmap);
511
512 // destroy existing here instead of:
513 image->Destroy();
514 image->Create(width, height);
515
516 unsigned char *ptr = image->GetData();
517
518 if ( !ptr )
519 {
520 if ( verbose )
521 wxLogError( _("BMP: Couldn't allocate memory.") );
522 return false;
523 }
524
525 unsigned char *alpha;
526 if ( bpp == 32 )
527 {
528 // tell the image to allocate an alpha buffer
529 image->SetAlpha();
530 alpha = image->GetAlpha();
531 if ( !alpha )
532 {
533 if ( verbose )
534 wxLogError(_("BMP: Couldn't allocate memory."));
535 return false;
536 }
537 }
538 else // no alpha
539 {
540 alpha = NULL;
541 }
542
543 // Reading the palette, if it exists:
544 if ( bpp < 16 && ncolors != 0 )
545 {
546 unsigned char* r = new unsigned char[ncolors];
547 unsigned char* g = new unsigned char[ncolors];
548 unsigned char* b = new unsigned char[ncolors];
549 for (int j = 0; j < ncolors; j++)
550 {
551 if (hasPalette)
552 {
553 stream.Read(bbuf, 4);
554 cmap[j].b = bbuf[0];
555 cmap[j].g = bbuf[1];
556 cmap[j].r = bbuf[2];
557
558 r[j] = cmap[j].r;
559 g[j] = cmap[j].g;
560 b[j] = cmap[j].b;
561 }
562 else
563 {
564 //used in reading .ico file mask
565 r[j] = cmap[j].r =
566 g[j] = cmap[j].g =
567 b[j] = cmap[j].b = ( j ? 255 : 0 );
568 }
569 }
570
571 #if wxUSE_PALETTE
572 // Set the palette for the wxImage
573 image->SetPalette(wxPalette(ncolors, r, g, b));
574 #endif // wxUSE_PALETTE
575
576 delete[] r;
577 delete[] g;
578 delete[] b;
579 }
580 else if ( bpp == 16 || bpp == 32 )
581 {
582 if ( comp == BI_BITFIELDS )
583 {
584 int bit = 0;
585 stream.Read(dbuf, 4 * 3);
586 rmask = wxINT32_SWAP_ON_BE(dbuf[0]);
587 gmask = wxINT32_SWAP_ON_BE(dbuf[1]);
588 bmask = wxINT32_SWAP_ON_BE(dbuf[2]);
589 // find shift amount (Least significant bit of mask)
590 for (bit = bpp-1; bit>=0; bit--)
591 {
592 if (bmask & (1 << bit))
593 bshift = bit;
594 if (gmask & (1 << bit))
595 gshift = bit;
596 if (rmask & (1 << bit))
597 rshift = bit;
598 }
599 // Find number of bits in mask (MSB-LSB+1)
600 for (bit = 0; bit < bpp; bit++)
601 {
602 if (bmask & (1 << bit))
603 bbits = bit-bshift+1;
604 if (gmask & (1 << bit))
605 gbits = bit-gshift+1;
606 if (rmask & (1 << bit))
607 rbits = bit-rshift+1;
608 }
609 }
610 else if ( bpp == 16 )
611 {
612 rmask = 0x7C00;
613 gmask = 0x03E0;
614 bmask = 0x001F;
615 rshift = 10;
616 gshift = 5;
617 bshift = 0;
618 rbits = 5;
619 gbits = 5;
620 bbits = 5;
621 }
622 else if ( bpp == 32 )
623 {
624 rmask = 0x00FF0000;
625 gmask = 0x0000FF00;
626 bmask = 0x000000FF;
627 amask = 0xFF000000;
628
629 ashift = 24;
630 rshift = 16;
631 gshift = 8;
632 bshift = 0;
633 rbits = 8;
634 gbits = 8;
635 bbits = 8;
636 }
637 }
638
639 /*
640 * Reading the image data
641 */
642 if ( IsBmp )
643 {
644 // NOTE: seeking a positive amount in wxFromCurrent mode allows us to
645 // load even non-seekable streams (see wxInputStream::SeekI docs)!
646 if (stream.SeekI(bmpOffset, wxFromCurrent) == wxInvalidOffset)
647 return false;
648 //else: icon, just carry on
649 }
650
651 unsigned char *data = ptr;
652
653 /* set the whole image to the background color */
654 if ( bpp < 16 && (comp == BI_RLE4 || comp == BI_RLE8) )
655 {
656 for (int i = 0; i < width * height; i++)
657 {
658 *ptr++ = cmap[0].r;
659 *ptr++ = cmap[0].g;
660 *ptr++ = cmap[0].b;
661 }
662 ptr = data;
663 }
664
665 int linesize = ((width * bpp + 31) / 32) * 4;
666
667 /* BMPs are stored upside down */
668 for ( int line = (height - 1); line >= 0; line-- )
669 {
670 int linepos = 0;
671 for ( int column = 0; column < width ; )
672 {
673 if ( bpp < 16 )
674 {
675 linepos++;
676 aByte = stream.GetC();
677 if ( bpp == 1 )
678 {
679 for (int bit = 0; bit < 8 && column < width; bit++)
680 {
681 int index = ((aByte & (0x80 >> bit)) ? 1 : 0);
682 ptr[poffset] = cmap[index].r;
683 ptr[poffset + 1] = cmap[index].g;
684 ptr[poffset + 2] = cmap[index].b;
685 column++;
686 }
687 }
688 else if ( bpp == 4 )
689 {
690 if ( comp == BI_RLE4 )
691 {
692 wxUint8 first;
693 first = aByte;
694 aByte = stream.GetC();
695 if ( first == 0 )
696 {
697 if ( aByte == 0 )
698 {
699 if ( column > 0 )
700 column = width;
701 }
702 else if ( aByte == 1 )
703 {
704 column = width;
705 line = -1;
706 }
707 else if ( aByte == 2 )
708 {
709 aByte = stream.GetC();
710 column += aByte;
711 linepos = column * bpp / 4;
712 aByte = stream.GetC();
713 line -= aByte; // upside down
714 }
715 else
716 {
717 int absolute = aByte;
718 wxUint8 nibble[2] ;
719 int readBytes = 0 ;
720 for (int k = 0; k < absolute; k++)
721 {
722 if ( !(k % 2 ) )
723 {
724 ++readBytes ;
725 aByte = stream.GetC();
726 nibble[0] = (wxUint8)( (aByte & 0xF0) >> 4 ) ;
727 nibble[1] = (wxUint8)( aByte & 0x0F ) ;
728 }
729 ptr[poffset ] = cmap[nibble[k%2]].r;
730 ptr[poffset + 1] = cmap[nibble[k%2]].g;
731 ptr[poffset + 2] = cmap[nibble[k%2]].b;
732 column++;
733 if ( k % 2 )
734 linepos++;
735 }
736 if ( readBytes & 0x01 )
737 aByte = stream.GetC();
738 }
739 }
740 else
741 {
742 wxUint8 nibble[2] ;
743 nibble[0] = (wxUint8)( (aByte & 0xF0) >> 4 ) ;
744 nibble[1] = (wxUint8)( aByte & 0x0F ) ;
745
746 for ( int l = 0; l < first && column < width; l++ )
747 {
748 ptr[poffset ] = cmap[nibble[l%2]].r;
749 ptr[poffset + 1] = cmap[nibble[l%2]].g;
750 ptr[poffset + 2] = cmap[nibble[l%2]].b;
751 column++;
752 if ( l % 2 )
753 linepos++;
754 }
755 }
756 }
757 else
758 {
759 for (int nibble = 0; nibble < 2 && column < width; nibble++)
760 {
761 int index = ((aByte & (0xF0 >> nibble * 4)) >> (!nibble * 4));
762 if ( index >= 16 )
763 index = 15;
764 ptr[poffset] = cmap[index].r;
765 ptr[poffset + 1] = cmap[index].g;
766 ptr[poffset + 2] = cmap[index].b;
767 column++;
768 }
769 }
770 }
771 else if ( bpp == 8 )
772 {
773 if ( comp == BI_RLE8 )
774 {
775 unsigned char first;
776 first = aByte;
777 aByte = stream.GetC();
778 if ( first == 0 )
779 {
780 if ( aByte == 0 )
781 {
782 /* column = width; */
783 }
784 else if ( aByte == 1 )
785 {
786 column = width;
787 line = -1;
788 }
789 else if ( aByte == 2 )
790 {
791 aByte = stream.GetC();
792 column += aByte;
793 linepos = column * bpp / 8;
794 aByte = stream.GetC();
795 line += aByte;
796 }
797 else
798 {
799 int absolute = aByte;
800 for (int k = 0; k < absolute; k++)
801 {
802 linepos++;
803 aByte = stream.GetC();
804 ptr[poffset ] = cmap[aByte].r;
805 ptr[poffset + 1] = cmap[aByte].g;
806 ptr[poffset + 2] = cmap[aByte].b;
807 column++;
808 }
809 if ( absolute & 0x01 )
810 aByte = stream.GetC();
811 }
812 }
813 else
814 {
815 for ( int l = 0; l < first && column < width; l++ )
816 {
817 ptr[poffset ] = cmap[aByte].r;
818 ptr[poffset + 1] = cmap[aByte].g;
819 ptr[poffset + 2] = cmap[aByte].b;
820 column++;
821 linepos++;
822 }
823 }
824 }
825 else
826 {
827 ptr[poffset ] = cmap[aByte].r;
828 ptr[poffset + 1] = cmap[aByte].g;
829 ptr[poffset + 2] = cmap[aByte].b;
830 column++;
831 // linepos += size; seems to be wrong, RR
832 }
833 }
834 }
835 else if ( bpp == 24 )
836 {
837 stream.Read(bbuf, 3);
838 linepos += 3;
839 ptr[poffset ] = (unsigned char)bbuf[2];
840 ptr[poffset + 1] = (unsigned char)bbuf[1];
841 ptr[poffset + 2] = (unsigned char)bbuf[0];
842 column++;
843 }
844 else if ( bpp == 16 )
845 {
846 unsigned char temp;
847 stream.Read(&aWord, 2);
848 aWord = wxUINT16_SWAP_ON_BE(aWord);
849 linepos += 2;
850 /* use the masks and calculated amonut of shift
851 to retrieve the color data out of the word. Then
852 shift it left by (8 - number of bits) such that
853 the image has the proper dynamic range */
854 temp = (unsigned char)((aWord & rmask) >> rshift << (8-rbits));
855 ptr[poffset] = temp;
856 temp = (unsigned char)((aWord & gmask) >> gshift << (8-gbits));
857 ptr[poffset + 1] = temp;
858 temp = (unsigned char)((aWord & bmask) >> bshift << (8-bbits));
859 ptr[poffset + 2] = temp;
860 column++;
861 }
862 else
863 {
864 unsigned char temp;
865 stream.Read(&aDword, 4);
866 aDword = wxINT32_SWAP_ON_BE(aDword);
867 linepos += 4;
868 temp = (unsigned char)((aDword & rmask) >> rshift);
869 ptr[poffset] = temp;
870 temp = (unsigned char)((aDword & gmask) >> gshift);
871 ptr[poffset + 1] = temp;
872 temp = (unsigned char)((aDword & bmask) >> bshift);
873 ptr[poffset + 2] = temp;
874 if ( alpha )
875 {
876 temp = (unsigned char)((aDword & amask) >> ashift);
877 alpha[line * width + column] = temp;
878 }
879 column++;
880 }
881 }
882 while ( (linepos < linesize) && (comp != 1) && (comp != 2) )
883 {
884 stream.Read(&aByte, 1);
885 linepos += 1;
886 if ( !stream )
887 break;
888 }
889 }
890
891 image->SetMask(false);
892
893 const wxStreamError err = stream.GetLastError();
894 return err == wxSTREAM_NO_ERROR || err == wxSTREAM_EOF;
895 }
896
897 bool wxBMPHandler::LoadDib(wxImage *image, wxInputStream& stream,
898 bool verbose, bool IsBmp)
899 {
900 wxUint16 aWord;
901 wxInt32 dbuf[4];
902 wxInt8 bbuf[4];
903
904 if ( IsBmp )
905 {
906 // read the header off the .BMP format file
907 stream.Read(bbuf, 2);
908 stream.Read(dbuf, 16);
909 }
910 else
911 {
912 stream.Read(dbuf, 4);
913 }
914 #if 0 // unused
915 wxInt32 size = wxINT32_SWAP_ON_BE(dbuf[0]);
916 #endif
917 wxFileOffset offset = wxINT32_SWAP_ON_BE(dbuf[2]);
918
919 stream.Read(dbuf, 4 * 2);
920 int width = wxINT32_SWAP_ON_BE((int)dbuf[0]);
921 int height = wxINT32_SWAP_ON_BE((int)dbuf[1]);
922 if ( !IsBmp)height = height / 2; // for icons divide by 2
923
924 if ( width > 32767 )
925 {
926 if (verbose)
927 wxLogError( _("DIB Header: Image width > 32767 pixels for file.") );
928 return false;
929 }
930 if ( height > 32767 )
931 {
932 if (verbose)
933 wxLogError( _("DIB Header: Image height > 32767 pixels for file.") );
934 return false;
935 }
936
937 stream.Read(&aWord, 2);
938 /*
939 TODO
940 int planes = (int)wxUINT16_SWAP_ON_BE( aWord );
941 */
942 stream.Read(&aWord, 2);
943 int bpp = wxUINT16_SWAP_ON_BE((int)aWord);
944 if ( bpp != 1 && bpp != 4 && bpp != 8 && bpp != 16 && bpp != 24 && bpp != 32 )
945 {
946 if (verbose)
947 wxLogError( _("DIB Header: Unknown bitdepth in file.") );
948 return false;
949 }
950
951 stream.Read(dbuf, 4 * 4);
952 int comp = wxINT32_SWAP_ON_BE((int)dbuf[0]);
953 if ( comp != BI_RGB && comp != BI_RLE4 && comp != BI_RLE8 &&
954 comp != BI_BITFIELDS )
955 {
956 if (verbose)
957 wxLogError( _("DIB Header: Unknown encoding in file.") );
958 return false;
959 }
960
961 stream.Read(dbuf, 4 * 2);
962
963 int ncolors = wxINT32_SWAP_ON_BE( (int)dbuf[0] );
964 if (ncolors == 0)
965 ncolors = 1 << bpp;
966 /* some more sanity checks */
967 if (((comp == BI_RLE4) && (bpp != 4)) ||
968 ((comp == BI_RLE8) && (bpp != 8)) ||
969 ((comp == BI_BITFIELDS) && (bpp != 16 && bpp != 32)))
970 {
971 if (verbose)
972 wxLogError( _("DIB Header: Encoding doesn't match bitdepth.") );
973 return false;
974 }
975
976 //read DIB; this is the BMP image or the XOR part of an icon image
977 if ( !DoLoadDib(image, width, height, bpp, ncolors, comp, offset, stream,
978 verbose, IsBmp, true) )
979 {
980 if (verbose)
981 wxLogError( _("Error in reading image DIB.") );
982 return false;
983 }
984
985 if ( !IsBmp )
986 {
987 //read Icon mask which is monochrome
988 //there is no palette, so we will create one
989 wxImage mask;
990 if ( !DoLoadDib(&mask, width, height, 1, 2, BI_RGB, offset, stream,
991 verbose, IsBmp, false) )
992 {
993 if (verbose)
994 wxLogError( _("ICO: Error in reading mask DIB.") );
995 return false;
996 }
997 image->SetMaskFromImage(mask, 255, 255, 255);
998
999 }
1000
1001 // the resolution in the bitmap header is in meters, convert to centimeters
1002 image->SetOption(wxIMAGE_OPTION_RESOLUTIONUNIT, wxIMAGE_RESOLUTION_CM);
1003 image->SetOption(wxIMAGE_OPTION_RESOLUTIONX, dbuf[2]/100);
1004 image->SetOption(wxIMAGE_OPTION_RESOLUTIONY, dbuf[3]/100);
1005
1006 return true;
1007 }
1008
1009 bool wxBMPHandler::LoadFile(wxImage *image, wxInputStream& stream,
1010 bool verbose, int WXUNUSED(index))
1011 {
1012 // Read a single DIB fom the file:
1013 return LoadDib(image, stream, verbose, true/*isBmp*/);
1014 }
1015
1016 bool wxBMPHandler::DoCanRead(wxInputStream& stream)
1017 {
1018 unsigned char hdr[2];
1019
1020 if ( !stream.Read(hdr, WXSIZEOF(hdr)) ) // it's ok to modify the stream position here
1021 return false;
1022
1023 // do we have the BMP file signature?
1024 return hdr[0] == 'B' && hdr[1] == 'M';
1025 }
1026
1027 #endif // wxUSE_STREAMS
1028
1029
1030 #if wxUSE_ICO_CUR
1031 //-----------------------------------------------------------------------------
1032 // wxICOHandler
1033 //-----------------------------------------------------------------------------
1034
1035 IMPLEMENT_DYNAMIC_CLASS(wxICOHandler, wxBMPHandler)
1036
1037 #if wxUSE_STREAMS
1038
1039 struct ICONDIRENTRY
1040 {
1041 wxUint8 bWidth; // Width of the image
1042 wxUint8 bHeight; // Height of the image (times 2)
1043 wxUint8 bColorCount; // Number of colors in image (0 if >=8bpp)
1044 wxUint8 bReserved; // Reserved
1045
1046 // these two are different in icons and cursors:
1047 // icon or cursor
1048 wxUint16 wPlanes; // Color Planes or XHotSpot
1049 wxUint16 wBitCount; // Bits per pixel or YHotSpot
1050
1051 wxUint32 dwBytesInRes; // how many bytes in this resource?
1052 wxUint32 dwImageOffset; // where in the file is this image
1053 };
1054
1055 struct ICONDIR
1056 {
1057 wxUint16 idReserved; // Reserved
1058 wxUint16 idType; // resource type (1 for icons, 2 for cursors)
1059 wxUint16 idCount; // how many images?
1060 };
1061
1062
1063 bool wxICOHandler::SaveFile(wxImage *image,
1064 wxOutputStream& stream,
1065 bool verbose)
1066
1067 {
1068 //sanity check; icon must be less than 127 pixels high and 255 wide
1069 if ( image->GetHeight () > 127 )
1070 {
1071 if ( verbose )
1072 wxLogError(_("ICO: Image too tall for an icon."));
1073 return false;
1074 }
1075 if ( image->GetWidth () > 255 )
1076 {
1077 if ( verbose )
1078 wxLogError(_("ICO: Image too wide for an icon."));
1079 return false;
1080 }
1081
1082 const int images = 1; // only generate one image
1083
1084 // VS: This is a hack of sort - since ICO and CUR files are almost
1085 // identical, we have all the meat in wxICOHandler and check for
1086 // the actual (handler) type when the code has to distinguish between
1087 // the two formats
1088 int type = (this->GetType() == wxBITMAP_TYPE_CUR) ? 2 : 1;
1089
1090 // write a header, (ICONDIR)
1091 // Calculate the header size
1092 wxUint32 offset = 3 * sizeof(wxUint16);
1093
1094 ICONDIR IconDir;
1095 IconDir.idReserved = 0;
1096 IconDir.idType = wxUINT16_SWAP_ON_BE((wxUint16)type);
1097 IconDir.idCount = wxUINT16_SWAP_ON_BE((wxUint16)images);
1098 stream.Write(&IconDir.idReserved, sizeof(IconDir.idReserved));
1099 stream.Write(&IconDir.idType, sizeof(IconDir.idType));
1100 stream.Write(&IconDir.idCount, sizeof(IconDir.idCount));
1101 if ( !stream.IsOk() )
1102 {
1103 if ( verbose )
1104 wxLogError(_("ICO: Error writing the image file!"));
1105 return false;
1106 }
1107
1108 // for each iamage write a description ICONDIRENTRY:
1109 ICONDIRENTRY icondirentry;
1110 for (int img = 0; img < images; img++)
1111 {
1112 wxImage mask;
1113
1114 if ( image->HasMask() )
1115 {
1116 // make another image with black/white:
1117 mask = image->ConvertToMono (image->GetMaskRed(), image->GetMaskGreen(), image->GetMaskBlue() );
1118
1119 // now we need to change the masked regions to black:
1120 unsigned char r = image->GetMaskRed();
1121 unsigned char g = image->GetMaskGreen();
1122 unsigned char b = image->GetMaskBlue();
1123 if ( (r != 0) || (g != 0) || (b != 0) )
1124 {
1125 // Go round and apply black to the masked bits:
1126 int i, j;
1127 for (i = 0; i < mask.GetWidth(); i++)
1128 {
1129 for (j = 0; j < mask.GetHeight(); j++)
1130 {
1131 if ((r == mask.GetRed(i, j)) &&
1132 (g == mask.GetGreen(i, j))&&
1133 (b == mask.GetBlue(i, j)) )
1134 image->SetRGB(i, j, 0, 0, 0 );
1135 }
1136 }
1137 }
1138 }
1139 else
1140 {
1141 // just make a black mask all over:
1142 mask = image->Copy();
1143 int i, j;
1144 for (i = 0; i < mask.GetWidth(); i++)
1145 for (j = 0; j < mask.GetHeight(); j++)
1146 mask.SetRGB(i, j, 0, 0, 0 );
1147 }
1148 // Set the formats for image and mask
1149 // (Windows never saves with more than 8 colors):
1150 image->SetOption(wxIMAGE_OPTION_BMP_FORMAT, wxBMP_8BPP);
1151
1152 // monochome bitmap:
1153 mask.SetOption(wxIMAGE_OPTION_BMP_FORMAT, wxBMP_1BPP_BW);
1154 bool IsBmp = false;
1155 bool IsMask = false;
1156
1157 //calculate size and offset of image and mask
1158 wxCountingOutputStream cStream;
1159 bool bResult = SaveDib(image, cStream, verbose, IsBmp, IsMask);
1160 if ( !bResult )
1161 {
1162 if ( verbose )
1163 wxLogError(_("ICO: Error writing the image file!"));
1164 return false;
1165 }
1166 IsMask = true;
1167
1168 bResult = SaveDib(&mask, cStream, verbose, IsBmp, IsMask);
1169 if ( !bResult )
1170 {
1171 if ( verbose )
1172 wxLogError(_("ICO: Error writing the image file!"));
1173 return false;
1174 }
1175 wxUint32 Size = cStream.GetSize();
1176
1177 // wxCountingOutputStream::IsOk() always returns true for now and this
1178 // "if" provokes VC++ warnings in optimized build
1179 #if 0
1180 if ( !cStream.Ok() )
1181 {
1182 if ( verbose )
1183 wxLogError(_("ICO: Error writing the image file!"));
1184 return false;
1185 }
1186 #endif // 0
1187
1188 offset = offset + sizeof(ICONDIRENTRY);
1189
1190 icondirentry.bWidth = (wxUint8)image->GetWidth();
1191 icondirentry.bHeight = (wxUint8)(2 * image->GetHeight());
1192 icondirentry.bColorCount = 0;
1193 icondirentry.bReserved = 0;
1194 icondirentry.wPlanes = wxUINT16_SWAP_ON_BE(1);
1195 icondirentry.wBitCount = wxUINT16_SWAP_ON_BE(wxBMP_8BPP);
1196 if ( type == 2 /*CUR*/)
1197 {
1198 int hx = image->HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_X) ?
1199 image->GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_X) :
1200 image->GetWidth() / 2;
1201 int hy = image->HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y) ?
1202 image->GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_Y) :
1203 image->GetHeight() / 2;
1204
1205 // actually write the values of the hot spot here:
1206 icondirentry.wPlanes = wxUINT16_SWAP_ON_BE((wxUint16)hx);
1207 icondirentry.wBitCount = wxUINT16_SWAP_ON_BE((wxUint16)hy);
1208 }
1209 icondirentry.dwBytesInRes = wxUINT32_SWAP_ON_BE(Size);
1210 icondirentry.dwImageOffset = wxUINT32_SWAP_ON_BE(offset);
1211
1212 // increase size to allow for the data written:
1213 offset += Size;
1214
1215 // write to stream:
1216 stream.Write(&icondirentry.bWidth, sizeof(icondirentry.bWidth));
1217 stream.Write(&icondirentry.bHeight, sizeof(icondirentry.bHeight));
1218 stream.Write(&icondirentry.bColorCount, sizeof(icondirentry.bColorCount));
1219 stream.Write(&icondirentry.bReserved, sizeof(icondirentry.bReserved));
1220 stream.Write(&icondirentry.wPlanes, sizeof(icondirentry.wPlanes));
1221 stream.Write(&icondirentry.wBitCount, sizeof(icondirentry.wBitCount));
1222 stream.Write(&icondirentry.dwBytesInRes, sizeof(icondirentry.dwBytesInRes));
1223 stream.Write(&icondirentry.dwImageOffset, sizeof(icondirentry.dwImageOffset));
1224 if ( !stream.IsOk() )
1225 {
1226 if ( verbose )
1227 wxLogError(_("ICO: Error writing the image file!"));
1228 return false;
1229 }
1230
1231 // actually save it:
1232 IsMask = false;
1233 bResult = SaveDib(image, stream, verbose, IsBmp, IsMask);
1234 if ( !bResult )
1235 {
1236 if ( verbose )
1237 wxLogError(_("ICO: Error writing the image file!"));
1238 return false;
1239 }
1240 IsMask = true;
1241
1242 bResult = SaveDib(&mask, stream, verbose, IsBmp, IsMask);
1243 if ( !bResult )
1244 {
1245 if ( verbose )
1246 wxLogError(_("ICO: Error writing the image file!"));
1247 return false;
1248 }
1249
1250 } // end of for loop
1251
1252 return true;
1253 }
1254
1255 bool wxICOHandler::LoadFile(wxImage *image, wxInputStream& stream,
1256 bool verbose, int index)
1257 {
1258 return DoLoadFile(image, stream, verbose, index);
1259 }
1260
1261 bool wxICOHandler::DoLoadFile(wxImage *image, wxInputStream& stream,
1262 bool WXUNUSED(verbose), int index)
1263 {
1264 bool bResult wxDUMMY_INITIALIZE(false);
1265 bool IsBmp = false;
1266
1267 ICONDIR IconDir;
1268
1269 stream.Read(&IconDir, sizeof(IconDir));
1270 wxUint16 nIcons = wxUINT16_SWAP_ON_BE(IconDir.idCount);
1271
1272 // nType is 1 for Icons, 2 for Cursors:
1273 wxUint16 nType = wxUINT16_SWAP_ON_BE(IconDir.idType);
1274
1275 // loop round the icons and choose the best one:
1276 ICONDIRENTRY *pIconDirEntry = new ICONDIRENTRY[nIcons];
1277 ICONDIRENTRY *pCurrentEntry = pIconDirEntry;
1278 int wMax = 0;
1279 int colmax = 0;
1280 int iSel = wxNOT_FOUND;
1281
1282 // remember how many bytes we read from the stream:
1283 wxFileOffset alreadySeeked = sizeof(IconDir);
1284
1285 for (unsigned int i = 0; i < nIcons; i++ )
1286 {
1287 alreadySeeked += stream.Read(pCurrentEntry, sizeof(ICONDIRENTRY)).LastRead();
1288
1289 // bHeight and bColorCount are wxUint8
1290 if ( pCurrentEntry->bWidth >= wMax )
1291 {
1292 // see if we have more colors, ==0 indicates > 8bpp:
1293 if ( pCurrentEntry->bColorCount == 0 )
1294 pCurrentEntry->bColorCount = 255;
1295 if ( pCurrentEntry->bColorCount >= colmax )
1296 {
1297 iSel = i;
1298 wMax = pCurrentEntry->bWidth;
1299 colmax = pCurrentEntry->bColorCount;
1300 }
1301 }
1302
1303 pCurrentEntry++;
1304 }
1305
1306 if ( index != -1 )
1307 {
1308 // VS: Note that we *have* to run the loop above even if index != -1, because
1309 // it reads ICONDIRENTRies.
1310 iSel = index;
1311 }
1312
1313 if ( iSel == wxNOT_FOUND || iSel < 0 || iSel >= nIcons )
1314 {
1315 wxLogError(_("ICO: Invalid icon index."));
1316 bResult = false;
1317 }
1318 else
1319 {
1320 // seek to selected icon:
1321 pCurrentEntry = pIconDirEntry + iSel;
1322
1323 // NOTE: seeking a positive amount in wxFromCurrent mode allows us to
1324 // load even non-seekable streams (see wxInputStream::SeekI docs)!
1325 wxFileOffset offset = wxUINT32_SWAP_ON_BE(pCurrentEntry->dwImageOffset) - alreadySeeked;
1326 if (offset != 0 && stream.SeekI(offset, wxFromCurrent) == wxInvalidOffset)
1327 return false;
1328
1329 bResult = LoadDib(image, stream, true, IsBmp);
1330 bool bIsCursorType = (this->GetType() == wxBITMAP_TYPE_CUR) || (this->GetType() == wxBITMAP_TYPE_ANI);
1331 if ( bResult && bIsCursorType && nType == 2 )
1332 {
1333 // it is a cursor, so let's set the hotspot:
1334 image->SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X, wxUINT16_SWAP_ON_BE(pCurrentEntry->wPlanes));
1335 image->SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, wxUINT16_SWAP_ON_BE(pCurrentEntry->wBitCount));
1336 }
1337 }
1338
1339 delete [] pIconDirEntry;
1340
1341 return bResult;
1342 }
1343
1344 int wxICOHandler::DoGetImageCount(wxInputStream& stream)
1345 {
1346 ICONDIR IconDir;
1347
1348 if (stream.Read(&IconDir, sizeof(IconDir)).LastRead() != sizeof(IconDir))
1349 // it's ok to modify the stream position here
1350 return 0;
1351
1352 return (int)wxUINT16_SWAP_ON_BE(IconDir.idCount);
1353 }
1354
1355 bool wxICOHandler::DoCanRead(wxInputStream& stream)
1356 {
1357 unsigned char hdr[4];
1358 if ( !stream.Read(hdr, WXSIZEOF(hdr)) ) // it's ok to modify the stream position here
1359 return false;
1360
1361 // hdr[2] is one for an icon and two for a cursor
1362 return hdr[0] == '\0' && hdr[1] == '\0' && hdr[2] == '\1' && hdr[3] == '\0';
1363 }
1364
1365 #endif // wxUSE_STREAMS
1366
1367
1368 //-----------------------------------------------------------------------------
1369 // wxCURHandler
1370 //-----------------------------------------------------------------------------
1371
1372 IMPLEMENT_DYNAMIC_CLASS(wxCURHandler, wxICOHandler)
1373
1374 #if wxUSE_STREAMS
1375
1376 bool wxCURHandler::DoCanRead(wxInputStream& stream)
1377 {
1378 unsigned char hdr[4];
1379 if ( !stream.Read(hdr, WXSIZEOF(hdr)) ) // it's ok to modify the stream position here
1380 return false;
1381
1382 // hdr[2] is one for an icon and two for a cursor
1383 return hdr[0] == '\0' && hdr[1] == '\0' && hdr[2] == '\2' && hdr[3] == '\0';
1384 }
1385
1386 #endif // wxUSE_STREAMS
1387
1388 //-----------------------------------------------------------------------------
1389 // wxANIHandler
1390 //-----------------------------------------------------------------------------
1391
1392 IMPLEMENT_DYNAMIC_CLASS(wxANIHandler, wxCURHandler)
1393
1394 #if wxUSE_STREAMS
1395
1396 bool wxANIHandler::LoadFile(wxImage *image, wxInputStream& stream,
1397 bool WXUNUSED(verbose), int index)
1398 {
1399 wxANIDecoder decoder;
1400 if (!decoder.Load(stream))
1401 return false;
1402
1403 return decoder.ConvertToImage(index != -1 ? (size_t)index : 0, image);
1404 }
1405
1406 bool wxANIHandler::DoCanRead(wxInputStream& stream)
1407 {
1408 wxANIDecoder decod;
1409 return decod.CanRead(stream);
1410 // it's ok to modify the stream position here
1411 }
1412
1413 int wxANIHandler::DoGetImageCount(wxInputStream& stream)
1414 {
1415 wxANIDecoder decoder;
1416 if (!decoder.Load(stream)) // it's ok to modify the stream position here
1417 return wxNOT_FOUND;
1418
1419 return decoder.GetFrameCount();
1420 }
1421
1422 #endif // wxUSE_STREAMS
1423
1424 #endif // wxUSE_ICO_CUR
1425
1426 #endif // wxUSE_IMAGE
wxWidgets (Impactor)