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