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