src/common/image.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        image.cpp
   3 // Purpose:     wxImage
   4 // Author:      Robert Roebling
   5 // RCS-ID:      $Id$
   6 // Copyright:   (c) Robert Roebling
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 #ifdef __GNUG__
  11 #pragma implementation "image.h"
  12 #endif
  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
  21 #include "wx/image.h"
  22 #include "wx/bitmap.h"
  23 #include "wx/debug.h"
  24 #include "wx/log.h"
  25 #include "wx/app.h"
  26 #ifdef wxUSE_LIBPNG
  27 #include "../png/png.h"
  28 #endif
  29 #include "wx/filefn.h"
  30 #include "wx/wfstream.h"
  31 #include "wx/intl.h"
  32
  33 #ifdef __SALFORDC__
  34 #ifdef FAR
  35 #undef FAR
  36 #endif
  37 #endif
  38
  39 #ifdef __WXMSW__
  40 #include <windows.h>
  41 #endif
  42
  43 //-----------------------------------------------------------------------------
  44 // wxImage
  45 //-----------------------------------------------------------------------------
  46
  47 class wxImageRefData: public wxObjectRefData
  48 {
  49
  50 public:
  51   wxImageRefData(void);
  52   ~wxImageRefData(void);
  53
  54   int             m_width;
  55   int             m_height;
  56   unsigned char  *m_data;
  57   bool            m_hasMask;
  58   unsigned char   m_maskRed,m_maskGreen,m_maskBlue;
  59   bool            m_ok;
  60 };
  61
  62 wxImageRefData::wxImageRefData(void)
  63 {
  64     m_width = 0;
  65     m_height = 0;
  66     m_data = (unsigned char*) NULL;
  67     m_ok = FALSE;
  68     m_maskRed = 0;
  69     m_maskGreen = 0;
  70     m_maskBlue = 0;
  71     m_hasMask = FALSE;
  72 }
  73
  74 wxImageRefData::~wxImageRefData(void)
  75 {
  76     if (m_data) free( m_data );
  77 }
  78
  79 wxList wxImage::sm_handlers;
  80
  81 //-----------------------------------------------------------------------------
  82
  83 #define M_IMGDATA ((wxImageRefData *)m_refData)
  84
  85 #if !USE_SHARED_LIBRARIES
  86 IMPLEMENT_DYNAMIC_CLASS(wxImage, wxObject)
  87 #endif
  88
  89 wxImage::wxImage()
  90 {
  91 }
  92
  93 wxImage::wxImage( int width, int height )
  94 {
  95     Create( width, height );
  96 }
  97
  98 wxImage::wxImage( const wxString& name, long type )
  99 {
 100     LoadFile( name, type );
 101 }
 102
 103 wxImage::wxImage( wxInputStream& stream, long type )
 104 {
 105     LoadFile( stream, type );
 106 }
 107
 108 wxImage::wxImage( const wxImage& image )
 109 {
 110     Ref(image);
 111 }
 112
 113 wxImage::wxImage( const wxImage* image )
 114 {
 115     if (image) Ref(*image);
 116 }
 117
 118 void wxImage::Create( int width, int height )
 119 {
 120     m_refData = new wxImageRefData();
 121
 122     M_IMGDATA->m_data = (unsigned char *) malloc( width*height*3 );
 123     if (M_IMGDATA->m_data)
 124     {
 125         for (int l = 0; l < width*height*3; l++) M_IMGDATA->m_data[l] = 0;
 126
 127         M_IMGDATA->m_width = width;
 128         M_IMGDATA->m_height = height;
 129         M_IMGDATA->m_ok = TRUE;
 130     }
 131     else
 132     {
 133         UnRef();
 134     }
 135 }
 136
 137 void wxImage::Destroy()
 138 {
 139     UnRef();
 140 }
 141
 142 wxImage wxImage::Scale( int width, int height )
 143 {
 144     wxImage image;
 145
 146     wxCHECK_MSG( Ok(), image, "invlaid image" );
 147
 148     wxCHECK_MSG( (width > 0) && (height > 0), image, "invalid image size" );
 149
 150     image.Create( width, height );
 151
 152     char unsigned *data = image.GetData();
 153
 154     wxCHECK_MSG( data, image, "unable to create image" );
 155
 156     if (M_IMGDATA->m_hasMask)
 157         image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
 158
 159     double xscale = (double)width / (double)M_IMGDATA->m_width;
 160     double yscale = (double)height / (double)M_IMGDATA->m_height;
 161
 162     for (int j = 0; j < height; j++)
 163     {
 164         for (int i = 0; i < width; i++)
 165         {
 166             int new_pos = 3*(j*width + i);
 167             int old_pos = 3*((long)(j/yscale)*M_IMGDATA->m_width + (long)(i/xscale));
 168             data[ new_pos   ] = M_IMGDATA->m_data[ old_pos   ];
 169             data[ new_pos+1 ] = M_IMGDATA->m_data[ old_pos+1 ];
 170             data[ new_pos+2 ] = M_IMGDATA->m_data[ old_pos+2 ];
 171         }
 172     }
 173
 174     return image;
 175 }
 176
 177 void wxImage::SetRGB( int x, int y, unsigned char r, unsigned char g, unsigned char b )
 178 {
 179     wxCHECK_RET( Ok(), "invalid image" );
 180
 181     int w = M_IMGDATA->m_width;
 182     int h = M_IMGDATA->m_height;
 183
 184     wxCHECK_RET( (x>=0) && (y>=0) && (x<w) && (y<h), "invalid image index" );
 185
 186     long pos = (y * w + x) * 3;
 187
 188     M_IMGDATA->m_data[ pos   ] = r;
 189     M_IMGDATA->m_data[ pos+1 ] = g;
 190     M_IMGDATA->m_data[ pos+2 ] = b;
 191 }
 192
 193 unsigned char wxImage::GetRed( int x, int y )
 194 {
 195     wxCHECK_MSG( Ok(), 0, "invalid image" );
 196
 197     int w = M_IMGDATA->m_width;
 198     int h = M_IMGDATA->m_height;
 199
 200     wxCHECK_MSG( (x>=0) && (y>=0) && (x<w) && (y<h), 0, "invalid image index" );
 201
 202     long pos = (y * w + x) * 3;
 203
 204     return M_IMGDATA->m_data[pos];
 205 }
 206
 207 unsigned char wxImage::GetGreen( int x, int y )
 208 {
 209     wxCHECK_MSG( Ok(), 0, "invalid image" );
 210
 211     int w = M_IMGDATA->m_width;
 212     int h = M_IMGDATA->m_height;
 213
 214     wxCHECK_MSG( (x>=0) && (y>=0) && (x<w) && (y<h), 0, "invalid image index" );
 215
 216     long pos = (y * w + x) * 3;
 217
 218     return M_IMGDATA->m_data[pos+1];
 219 }
 220
 221 unsigned char wxImage::GetBlue( int x, int y )
 222 {
 223     wxCHECK_MSG( Ok(), 0, "invalid image" );
 224
 225     int w = M_IMGDATA->m_width;
 226     int h = M_IMGDATA->m_height;
 227
 228     wxCHECK_MSG( (x>=0) && (y>=0) && (x<w) && (y<h), 0, "invalid image index" );
 229
 230     long pos = (y * w + x) * 3;
 231
 232     return M_IMGDATA->m_data[pos+2];
 233 }
 234
 235 bool wxImage::Ok() const
 236 {
 237     return (M_IMGDATA && M_IMGDATA->m_ok);
 238 }
 239
 240 char unsigned *wxImage::GetData() const
 241 {
 242     wxCHECK_MSG( Ok(), (char unsigned *)NULL, "invalid image" );
 243
 244     return M_IMGDATA->m_data;
 245 }
 246
 247 void wxImage::SetData( char unsigned *WXUNUSED(data) )
 248 {
 249     wxCHECK_RET( Ok(), "invalid image" );
 250 }
 251
 252 void wxImage::SetMaskColour( unsigned char r, unsigned char g, unsigned char b )
 253 {
 254     wxCHECK_RET( Ok(), "invalid image" );
 255
 256     M_IMGDATA->m_maskRed = r;
 257     M_IMGDATA->m_maskGreen = g;
 258     M_IMGDATA->m_maskBlue = b;
 259     M_IMGDATA->m_hasMask = TRUE;
 260 }
 261
 262 unsigned char wxImage::GetMaskRed() const
 263 {
 264     wxCHECK_MSG( Ok(), 0, "invalid image" );
 265
 266     return M_IMGDATA->m_maskRed;
 267 }
 268
 269 unsigned char wxImage::GetMaskGreen() const
 270 {
 271     wxCHECK_MSG( Ok(), 0, "invalid image" );
 272
 273     return M_IMGDATA->m_maskGreen;
 274 }
 275
 276 unsigned char wxImage::GetMaskBlue() const
 277 {
 278     wxCHECK_MSG( Ok(), 0, "invalid image" );
 279
 280     return M_IMGDATA->m_maskBlue;
 281 }
 282
 283 void wxImage::SetMask( bool mask )
 284 {
 285     wxCHECK_RET( Ok(), "invalid image" );
 286
 287     M_IMGDATA->m_hasMask = mask;
 288 }
 289
 290 bool wxImage::HasMask() const
 291 {
 292     wxCHECK_MSG( Ok(), FALSE, "invalid image" );
 293
 294     return M_IMGDATA->m_hasMask;
 295 }
 296
 297 int wxImage::GetWidth() const
 298 {
 299     wxCHECK_MSG( Ok(), 0, "invalid image" );
 300
 301     return M_IMGDATA->m_width;
 302 }
 303
 304 int wxImage::GetHeight() const
 305 {
 306     wxCHECK_MSG( Ok(), 0, "invalid image" );
 307
 308     return M_IMGDATA->m_height;
 309 }
 310
 311 bool wxImage::LoadFile( const wxString& filename, long type )
 312 {
 313     if (wxFileExists(filename))
 314     {
 315         wxFileInputStream stream(filename);
 316         return LoadFile(stream, type);
 317     }
 318
 319     else {
 320         wxLogWarning( "Image file does not exist." );
 321
 322         return FALSE;
 323     }
 324 }
 325
 326 bool wxImage::LoadFile( wxInputStream& stream, long type )
 327 {
 328     UnRef();
 329
 330     m_refData = new wxImageRefData;
 331
 332     wxImageHandler *handler = FindHandler(type);
 333
 334     if (handler == NULL)
 335     {
 336         wxLogWarning( "No image handler for type %d defined.", type );
 337
 338         return FALSE;
 339     }
 340
 341     return handler->LoadFile( this, stream );
 342 }
 343
 344 bool wxImage::SaveFile( const wxString& filename, int type )
 345 {
 346     wxFileOutputStream stream(filename);
 347
 348     if ( stream.LastError() == wxStream_NOERROR )
 349         return SaveFile(stream, type);
 350     else
 351         return FALSE;
 352 }
 353
 354 bool wxImage::SaveFile( wxOutputStream& stream, int type )
 355 {
 356     wxCHECK_MSG( Ok(), FALSE, "invalid image" );
 357
 358     wxImageHandler *handler = FindHandler(type);
 359
 360     if (handler == NULL)
 361     {
 362       wxLogWarning( "No image handler for type %d defined.", type );
 363
 364       return FALSE;
 365     }
 366
 367     return handler->SaveFile( this, stream );
 368 }
 369
 370 void wxImage::AddHandler( wxImageHandler *handler )
 371 {
 372     // make sure that the memory will be freed at the program end
 373     sm_handlers.DeleteContents(TRUE);
 374
 375     sm_handlers.Append( handler );
 376 }
 377
 378 void wxImage::InsertHandler( wxImageHandler *handler )
 379 {
 380     // make sure that the memory will be freed at the program end
 381     sm_handlers.DeleteContents(TRUE);
 382
 383     sm_handlers.Insert( handler );
 384 }
 385
 386 bool wxImage::RemoveHandler( const wxString& name )
 387 {
 388     wxImageHandler *handler = FindHandler(name);
 389     if (handler)
 390     {
 391         sm_handlers.DeleteObject(handler);
 392         return TRUE;
 393     }
 394     else
 395         return FALSE;
 396 }
 397
 398 wxImageHandler *wxImage::FindHandler( const wxString& name )
 399 {
 400     wxNode *node = sm_handlers.First();
 401     while (node)
 402     {
 403         wxImageHandler *handler = (wxImageHandler*)node->Data();
 404         if (handler->GetName() == name) return handler;
 405
 406         node = node->Next();
 407     }
 408     return (wxImageHandler *)NULL;
 409 }
 410
 411 wxImageHandler *wxImage::FindHandler( const wxString& extension, long bitmapType )
 412 {
 413     wxNode *node = sm_handlers.First();
 414     while (node)
 415     {
 416         wxImageHandler *handler = (wxImageHandler*)node->Data();
 417         if ( handler->GetExtension() == extension &&
 418             (bitmapType == -1 || handler->GetType() == bitmapType) )
 419         return handler;
 420         node = node->Next();
 421     }
 422     return (wxImageHandler*)NULL;
 423 }
 424
 425 wxImageHandler *wxImage::FindHandler( long bitmapType )
 426 {
 427     wxNode *node = sm_handlers.First();
 428     while (node)
 429     {
 430         wxImageHandler *handler = (wxImageHandler *)node->Data();
 431         if (handler->GetType() == bitmapType) return handler;
 432         node = node->Next();
 433     }
 434     return NULL;
 435 }
 436
 437 void wxImage::InitStandardHandlers()
 438 {
 439     AddHandler( new wxBMPHandler );
 440 #ifdef wxUSE_LIBPNG
 441     AddHandler( new wxPNGHandler );
 442 #endif
 443 }
 444
 445 void wxImage::CleanUpHandlers()
 446 {
 447     wxNode *node = sm_handlers.First();
 448     while (node)
 449     {
 450         wxImageHandler *handler = (wxImageHandler *)node->Data();
 451         wxNode *next = node->Next();
 452         delete handler;
 453         delete node;
 454         node = next;
 455     }
 456 }
 457
 458 //-----------------------------------------------------------------------------
 459 // wxImageHandler
 460 //-----------------------------------------------------------------------------
 461
 462 #if !USE_SHARED_LIBRARIES
 463 IMPLEMENT_DYNAMIC_CLASS(wxImageHandler,wxObject)
 464 #endif
 465
 466 bool wxImageHandler::LoadFile( wxImage *WXUNUSED(image), wxInputStream& WXUNUSED(stream) )
 467 {
 468     return FALSE;
 469 }
 470
 471 bool wxImageHandler::SaveFile( wxImage *WXUNUSED(image), wxOutputStream& WXUNUSED(stream) )
 472 {
 473     return FALSE;
 474 }
 475
 476 //-----------------------------------------------------------------------------
 477 // wxPNGHandler
 478 //-----------------------------------------------------------------------------
 479
 480 #ifdef wxUSE_LIBPNG
 481
 482 #if !USE_SHARED_LIBRARIES
 483 IMPLEMENT_DYNAMIC_CLASS(wxPNGHandler,wxImageHandler)
 484 #endif
 485
 486
 487 static void _PNG_stream_reader( png_structp png_ptr, png_bytep data, png_size_t length )
 488 {
 489    ((wxInputStream*) png_get_io_ptr( png_ptr )) -> Read(data, length);
 490 }
 491
 492 static void _PNG_stream_writer( png_structp png_ptr, png_bytep data, png_size_t length )
 493 {
 494    ((wxOutputStream*) png_get_io_ptr( png_ptr )) -> Write(data, length);
 495 }
 496
 497 bool wxPNGHandler::LoadFile( wxImage *image, wxInputStream& stream )
 498 {
 499     // VZ: as this function uses setjmp() the only fool proof error handling
 500     //     method is to use goto (setjmp is not really C++ dtors friendly...)
 501
 502     unsigned char **lines = (unsigned char **) NULL;
 503     unsigned int i;
 504     png_infop info_ptr = (png_infop) NULL;
 505
 506     image->Destroy();
 507
 508     png_structp png_ptr = png_create_read_struct( PNG_LIBPNG_VER_STRING,
 509                                                   (voidp) NULL,
 510                                                   (png_error_ptr) NULL,
 511                                                   (png_error_ptr) NULL );
 512     if (!png_ptr)
 513         goto error;
 514
 515     info_ptr = png_create_info_struct( png_ptr );
 516     if (!info_ptr)
 517         goto error;
 518
 519     if (setjmp(png_ptr->jmpbuf))
 520         goto error;
 521
 522     if (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
 523         goto error;
 524
 525     png_set_read_fn( png_ptr, &stream, _PNG_stream_reader);
 526
 527     png_uint_32 width,height;
 528     int bit_depth,color_type,interlace_type;
 529
 530     png_read_info( png_ptr, info_ptr );
 531     png_get_IHDR( png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, (int*) NULL, (int*) NULL );
 532
 533     if (color_type == PNG_COLOR_TYPE_PALETTE)
 534         png_set_expand( png_ptr );
 535
 536     png_set_strip_16( png_ptr );
 537     png_set_packing( png_ptr );
 538     if (png_get_valid( png_ptr, info_ptr, PNG_INFO_tRNS))
 539         png_set_expand( png_ptr );
 540     png_set_filler( png_ptr, 0xff, PNG_FILLER_AFTER );
 541
 542     image->Create( width, height );
 543
 544     if (!image->Ok())
 545         goto error;
 546
 547     lines = (unsigned char **)malloc( height * sizeof(unsigned char *) );
 548     if (lines == NULL)
 549         goto error;
 550
 551     for (i = 0; i < height; i++)
 552     {
 553         if ((lines[i] = (unsigned char *)malloc(width * (sizeof(unsigned char) * 4))) == NULL)
 554         {
 555             for ( unsigned int n = 0; n < i; n++ )
 556                 free( lines[n] );
 557             goto error;
 558         }
 559     }
 560
 561     // loaded successfully!
 562     {
 563         int transp = 0;
 564         png_read_image( png_ptr, lines );
 565         png_destroy_read_struct( &png_ptr, &info_ptr, (png_infopp) NULL );
 566         unsigned char *ptr = image->GetData();
 567         if ((color_type == PNG_COLOR_TYPE_GRAY) ||
 568             (color_type == PNG_COLOR_TYPE_GRAY_ALPHA))
 569         {
 570             for (unsigned int y = 0; y < height; y++)
 571             {
 572                 unsigned char *ptr2 = lines[y];
 573                 for (unsigned int x = 0; x < width; x++)
 574                 {
 575                     unsigned char r = *ptr2++;
 576                     unsigned char a = *ptr2++;
 577                     if (a < 128)
 578                     {
 579                         *ptr++ = 255;
 580                         *ptr++ = 0;
 581                         *ptr++ = 255;
 582                         transp = 1;
 583                     }
 584                     else
 585                     {
 586                         *ptr++ = r;
 587                         *ptr++ = r;
 588                         *ptr++ = r;
 589                     }
 590                 }
 591             }
 592         }
 593         else
 594         {
 595             for (unsigned int y = 0; y < height; y++)
 596             {
 597                 unsigned char *ptr2 = lines[y];
 598                 for (unsigned int x = 0; x < width; x++)
 599                 {
 600                     unsigned char r = *ptr2++;
 601                     unsigned char g = *ptr2++;
 602                     unsigned char b = *ptr2++;
 603                     unsigned char a = *ptr2++;
 604                     if (a < 128)
 605                     {
 606                         *ptr++ = 255;
 607                         *ptr++ = 0;
 608                         *ptr++ = 255;
 609                         transp = 1;
 610                     }
 611                     else
 612                     {
 613                         if ((r == 255) && (g == 0) && (b == 255)) r = 254;
 614                         *ptr++ = r;
 615                         *ptr++ = g;
 616                         *ptr++ = b;
 617                     }
 618                 }
 619             }
 620         }
 621
 622         for ( unsigned int j = 0; j < height; j++ )
 623             free( lines[j] );
 624         free( lines );
 625
 626         if (transp)
 627         {
 628             image->SetMaskColour( 255, 0, 255 );
 629         }
 630         else
 631         {
 632             image->SetMask( FALSE );
 633         }
 634     }
 635
 636     return TRUE;
 637
 638 error:
 639     wxLogError(_("Couldn't load a PNG image - probably file is corrupted."));
 640
 641     if ( image->Ok() )
 642     {
 643         image->Destroy();
 644     }
 645
 646     if ( lines )
 647     {
 648         free( lines );
 649     }
 650
 651     if ( png_ptr )
 652     {
 653         if ( info_ptr )
 654         {
 655             png_destroy_read_struct( &png_ptr, &info_ptr, (png_infopp) NULL );
 656             free(info_ptr);
 657         }
 658         else
 659             png_destroy_read_struct( &png_ptr, (png_infopp) NULL, (png_infopp) NULL );
 660     }
 661     return FALSE;
 662 }
 663
 664
 665 bool wxPNGHandler::SaveFile( wxImage *image, wxOutputStream& stream )
 666 {
 667   {
 668     png_structp png_ptr = png_create_write_struct( PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
 669     if (!png_ptr)
 670     {
 671       return FALSE;
 672     }
 673
 674     png_infop info_ptr = png_create_info_struct(png_ptr);
 675     if (info_ptr == NULL)
 676     {
 677       png_destroy_write_struct( &png_ptr, (png_infopp)NULL );
 678       return FALSE;
 679     }
 680
 681     if (setjmp(png_ptr->jmpbuf))
 682     {
 683       png_destroy_write_struct( &png_ptr, (png_infopp)NULL );
 684       return FALSE;
 685     }
 686
 687     png_set_write_fn( png_ptr, &stream, _PNG_stream_writer, NULL);
 688
 689     png_set_IHDR( png_ptr, info_ptr, image->GetWidth(), image->GetHeight(), 8,
 690                   PNG_COLOR_TYPE_RGB_ALPHA, PNG_INTERLACE_NONE,
 691                   PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
 692
 693     png_color_8 sig_bit;
 694     sig_bit.red = 8;
 695     sig_bit.green = 8;
 696     sig_bit.blue = 8;
 697     sig_bit.alpha = 8;
 698     png_set_sBIT( png_ptr, info_ptr, &sig_bit );
 699     png_write_info( png_ptr, info_ptr );
 700     png_set_shift( png_ptr, &sig_bit );
 701     png_set_packing( png_ptr );
 702
 703     unsigned char *data = (unsigned char *)malloc( image->GetWidth()*4 );
 704     if (!data)
 705     {
 706       png_destroy_write_struct( &png_ptr, (png_infopp)NULL );
 707       return FALSE;
 708     }
 709
 710     for (int y = 0; y < image->GetHeight(); y++)
 711     {
 712         unsigned char *ptr = image->GetData() + (y * image->GetWidth() * 3);
 713         for (int x = 0; x < image->GetWidth(); x++)
 714         {
 715             data[(x << 2) + 0] = *ptr++;
 716             data[(x << 2) + 1] = *ptr++;
 717             data[(x << 2) + 2] = *ptr++;
 718             if ((data[(x << 2) + 0] == image->GetMaskRed()) &&
 719                 (data[(x << 2) + 1] == image->GetMaskGreen()) &&
 720                 (data[(x << 2) + 2] == image->GetMaskBlue()))
 721             {
 722                 data[(x << 2) + 3] = 0;
 723             }
 724             else
 725             {
 726                 data[(x << 2) + 3] = 255;
 727             }
 728         }
 729         png_bytep row_ptr = data;
 730         png_write_rows( png_ptr, &row_ptr, 1 );
 731     }
 732
 733     free(data);
 734     png_write_end( png_ptr, info_ptr );
 735     png_destroy_write_struct( &png_ptr, (png_infopp)&info_ptr );
 736   }
 737   return TRUE;
 738 }
 739
 740 #endif
 741
 742   // wxUSE_LIBPNG
 743
 744 //-----------------------------------------------------------------------------
 745 // wxBMPHandler
 746 //-----------------------------------------------------------------------------
 747
 748 #if !USE_SHARED_LIBRARIES
 749 IMPLEMENT_DYNAMIC_CLASS(wxBMPHandler,wxImageHandler)
 750 #endif
 751
 752 bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream )
 753 {
 754    unsigned char      *data, *ptr;
 755    int                 done, i, bpp, planes, comp, ncolors, line, column,
 756                        linesize, linepos, rshift = 0, gshift = 0, bshift = 0;
 757    unsigned char       aByte;
 758    short int           word;
 759    long int            dbuf[4], dword, rmask = 0, gmask = 0, bmask = 0, offset,
 760                        size;
 761    off_t               start_offset = stream.TellI();
 762    signed char         bbuf[4];
 763    struct _cmap
 764      {
 765         unsigned char       r, g, b;
 766      }
 767                       *cmap = NULL;
 768 #ifndef BI_RGB
 769 #define BI_RGB       0
 770 #define BI_RLE8      1
 771 #define BI_RLE4      2
 772 #endif
 773
 774 #ifndef BI_BITFIELDS
 775 #define BI_BITFIELDS 3
 776 #endif
 777
 778   image->Destroy();
 779
 780    done = 0;
 781    /*
 782     * Reading the bmp header
 783     */
 784
 785    stream.Read(&bbuf, 2);
 786
 787    stream.Read(dbuf, 4 * 4);
 788
 789    size = dbuf[0];
 790    offset = dbuf[2];
 791
 792    stream.Read(dbuf, 4 * 2);
 793    int width = (int)dbuf[0];
 794    int height = (int)dbuf[1];
 795    if (width > 32767)
 796      {
 797         wxLogError( "Image width > 32767 pixels for file\n" );
 798         return FALSE;
 799      }
 800    if (height > 32767)
 801      {
 802         wxLogError( "Image height > 32767 pixels for file\n" );
 803         return FALSE;
 804      }
 805    stream.Read(&word, 2);
 806    planes = (int)word;
 807    stream.Read(&word, 2);
 808    bpp = (int)word;
 809    if (bpp != 1 && bpp != 4 && bpp != 8 && bpp && 16 && bpp != 24 && bpp != 32)
 810      {
 811         wxLogError( "unknown bitdepth in file\n" );
 812         return FALSE;
 813      }
 814    stream.Read(dbuf, 4 * 4);
 815    comp = (int)dbuf[0];
 816    if (comp != BI_RGB && comp != BI_RLE4 && comp != BI_RLE8 && comp != BI_BITFIELDS)
 817      {
 818         wxLogError( "unknown encoding in Windows BMP file\n" );
 819         return FALSE;
 820      }
 821    stream.Read(dbuf, 4 * 2);
 822    ncolors = (int)dbuf[0];
 823    if (ncolors == 0)
 824       ncolors = 1 << bpp;
 825    /* some more sanity checks */
 826    if (((comp == BI_RLE4) && (bpp != 4)) || ((comp == BI_RLE8) && (bpp != 8)) || ((comp == BI_BITFIELDS) && (bpp != 16 && bpp != 32)))
 827      {
 828         wxLogError( "encoding of BMP doesn't match bitdepth\n" );
 829         return FALSE;
 830      }
 831    if (bpp < 16)
 832      {
 833         cmap = (struct _cmap *)malloc(sizeof(struct _cmap) * ncolors);
 834
 835         if (!cmap)
 836           {
 837              wxLogError( "Cannot allocate RAM for color map in BMP file\n" );
 838              return FALSE;
 839           }
 840      }
 841    else
 842       cmap = NULL;
 843
 844    image->Create( width, height );
 845    ptr = image->GetData();
 846    if (!ptr)
 847      {
 848         wxLogError( "Cannot allocate RAM for RGB data in file\n" );
 849         if (cmap)
 850            free(cmap);
 851         return FALSE;
 852      }
 853
 854    /*
 855     * Reading the palette, if it exists.
 856     */
 857    if (bpp < 16 && ncolors != 0)
 858      {
 859         for (i = 0; i < ncolors; i++)
 860           {
 861              stream.Read(bbuf, 4);
 862              cmap[i].b = bbuf[0];
 863              cmap[i].g = bbuf[1];
 864              cmap[i].r = bbuf[2];
 865           }
 866      }
 867    else if (bpp == 16 || bpp == 32)
 868      {
 869         if (comp == BI_BITFIELDS)
 870           {
 871              int                 bit = 0;
 872
 873              stream.Read(dbuf, 4 * 3);
 874              bmask = dbuf[0];
 875              gmask = dbuf[1];
 876              rmask = dbuf[2];
 877              /* find shift amount.. ugly, but i can't think of a better way */
 878              for (bit = 0; bit < bpp; bit++)
 879                {
 880                   if (bmask & (1 << bit))
 881                      bshift = bit;
 882                   if (gmask & (1 << bit))
 883                      gshift = bit;
 884                   if (rmask & (1 << bit))
 885                      rshift = bit;
 886                }
 887           }
 888         else if (bpp == 16)
 889           {
 890              rmask = 0x7C00;
 891              gmask = 0x03E0;
 892              bmask = 0x001F;
 893              rshift = 10;
 894              gshift = 5;
 895              bshift = 0;
 896           }
 897         else if (bpp == 32)
 898           {
 899              rmask = 0x00FF0000;
 900              gmask = 0x0000FF00;
 901              bmask = 0x000000FF;
 902              rshift = 16;
 903              gshift = 8;
 904              bshift = 0;
 905           }
 906      }
 907
 908    /*
 909     * Reading the image data
 910     */
 911    stream.SeekI(start_offset + offset);
 912    data = ptr;
 913
 914    /* set the whole image to the background color */
 915    if (bpp < 16 && (comp == BI_RLE4 || comp == BI_RLE8))
 916      {
 917         for (i = 0; i < width * height; i++)
 918           {
 919              *ptr++ = cmap[0].r;
 920              *ptr++ = cmap[0].g;
 921              *ptr++ = cmap[0].b;
 922           }
 923         ptr = data;
 924      }
 925    line = 0;
 926    column = 0;
 927 #define poffset (line * width * 3 + column * 3)
 928
 929    /*
 930     * BMPs are stored upside down... hmmmmmmmmmm....
 931     */
 932
 933    linesize = ((width * bpp + 31) / 32) * 4;
 934    for (line = (height - 1); line >= 0; line--)
 935      {
 936         linepos = 0;
 937         for (column = 0; column < width;)
 938           {
 939              if (bpp < 16)
 940                {
 941                   int                 index;
 942
 943                   linepos++;
 944                   aByte = stream.GetC();
 945                   if (bpp == 1)
 946                     {
 947                        int                 bit = 0;
 948
 949                        for (bit = 0; bit < 8; bit++)
 950                          {
 951                             index = ((aByte & (0x80 >> bit)) ? 1 : 0);
 952                             ptr[poffset] = cmap[index].r;
 953                             ptr[poffset + 1] = cmap[index].g;
 954                             ptr[poffset + 2] = cmap[index].b;
 955                             column++;
 956                          }
 957                     }
 958                   else if (bpp == 4)
 959                     {
 960                        if (comp == BI_RLE4)
 961                          {
 962                             wxLogError( "can't deal with 4bit encoded yet.\n");
 963                             image->Destroy();
 964                             free(cmap);
 965                             return FALSE;
 966                          }
 967                        else
 968                          {
 969                             int                 nibble = 0;
 970
 971                             for (nibble = 0; nibble < 2; nibble++)
 972                               {
 973                                  index = ((aByte & (0xF0 >> nibble * 4)) >> (!nibble * 4));
 974                                  if (index >= 16)
 975                                     index = 15;
 976                                  ptr[poffset] = cmap[index].r;
 977                                  ptr[poffset + 1] = cmap[index].g;
 978                                  ptr[poffset + 2] = cmap[index].b;
 979                                  column++;
 980                               }
 981                          }
 982                     }
 983                   else if (bpp == 8)
 984                     {
 985                        if (comp == BI_RLE8)
 986                          {
 987                             unsigned char       first;
 988
 989                             first = aByte;
 990                             aByte = stream.GetC();
 991                             if (first == 0)
 992                               {
 993                                  if (aByte == 0)
 994                                    {
 995 /*                                    column = width; */
 996                                    }
 997                                  else if (aByte == 1)
 998                                    {
 999                                       column = width;
1000                                       line = -1;
1001                                    }
1002                                  else if (aByte == 2)
1003                                    {
1004                                       aByte = stream.GetC();
1005                                       column += aByte;
1006                                       linepos = column * bpp / 8;
1007                                       aByte = stream.GetC();
1008                                       line += aByte;
1009                                    }
1010                                  else
1011                                    {
1012                                       int                 absolute = aByte;
1013
1014                                       for (i = 0; i < absolute; i++)
1015                                         {
1016                                            linepos++;
1017                                            aByte = stream.GetC();
1018                                            ptr[poffset] = cmap[aByte].r;
1019                                            ptr[poffset + 1] = cmap[aByte].g;
1020                                            ptr[poffset + 2] = cmap[aByte].b;
1021                                            column++;
1022                                         }
1023                                       if (absolute & 0x01)
1024                                          aByte = stream.GetC();
1025                                    }
1026                               }
1027                             else
1028                               {
1029                                  for (i = 0; i < first; i++)
1030                                    {
1031                                       ptr[poffset] = cmap[aByte].r;
1032                                       ptr[poffset + 1] = cmap[aByte].g;
1033                                       ptr[poffset + 2] = cmap[aByte].b;
1034                                       column++;
1035                                       linepos++;
1036                                    }
1037                               }
1038                          }
1039                        else
1040                          {
1041                             ptr[poffset] = cmap[aByte].r;
1042                             ptr[poffset + 1] = cmap[aByte].g;
1043                             ptr[poffset + 2] = cmap[aByte].b;
1044                             column++;
1045                             linepos += size;
1046                          }
1047                     }
1048                }
1049              else if (bpp == 24)
1050                {
1051               stream.Read(&bbuf, 3);
1052                   linepos += 3;
1053                   ptr[poffset] = (unsigned char)bbuf[2];
1054                   ptr[poffset + 1] = (unsigned char)bbuf[1];
1055                   ptr[poffset + 2] = (unsigned char)bbuf[0];
1056                   column++;
1057                }
1058              else if (bpp == 16)
1059                {
1060                   unsigned char       temp;
1061
1062                   stream.Read(&word, 2);
1063                   linepos += 2;
1064                   temp = (word & rmask) >> rshift;
1065                   ptr[poffset] = temp;
1066                   temp = (word & gmask) >> gshift;
1067                   ptr[poffset + 1] = temp;
1068                   temp = (word & bmask) >> gshift;
1069                   ptr[poffset + 2] = temp;
1070                   column++;
1071                }
1072              else
1073                {
1074                   unsigned char       temp;
1075
1076                   stream.Read(&dword, 4);
1077                   linepos += 4;
1078                   temp = (dword & rmask) >> rshift;
1079                   ptr[poffset] = temp;
1080                   temp = (dword & gmask) >> gshift;
1081                   ptr[poffset + 1] = temp;
1082                   temp = (dword & bmask) >> bshift;
1083                   ptr[poffset + 2] = temp;
1084                   column++;
1085                }
1086           }
1087         while ((linepos < linesize) && (comp != 1) && (comp != 2))
1088           {
1089              stream.Read(&aByte, 1);
1090              linepos += 1;
1091              if (stream.LastError() != wxStream_NOERROR)
1092                 break;
1093           }
1094      }
1095    if (cmap) free(cmap);
1096
1097    image->SetMask( FALSE );
1098
1099    return TRUE;
1100 }
1101
1102 #ifdef __WXMSW__
1103
1104 wxBitmap wxImage::ConvertToBitmap() const
1105 {
1106 // sizeLimit is the MS upper limit for the DIB size
1107     int sizeLimit = 1024*768*3;
1108
1109 // width and height of the device-dependent bitmap
1110     int width = GetWidth();
1111     int bmpHeight = GetHeight();
1112
1113 // calc the number of bytes per scanline and padding
1114     int bytePerLine = width*3;
1115     int sizeDWORD = sizeof( DWORD );
1116     div_t lineBoundary = div( bytePerLine, sizeDWORD );
1117     int padding = 0;
1118     if( lineBoundary.rem > 0 )
1119     {
1120         padding = sizeDWORD - lineBoundary.rem;
1121         bytePerLine += padding;
1122     }
1123 // calc the number of DIBs and heights of DIBs
1124     int numDIB = 1;
1125     int hRemain = 0;
1126     int height = sizeLimit/bytePerLine;
1127     if( height >= bmpHeight )
1128         height = bmpHeight;
1129     else
1130     {
1131         div_t result = div( bmpHeight, height );
1132         numDIB = result.quot;
1133         hRemain = result.rem;
1134         if( hRemain >0 )  numDIB++;
1135     }
1136
1137 // set bitmap parameters
1138     wxBitmap bitmap;
1139     wxCHECK_MSG( Ok(), bitmap, "invalid image" );
1140     bitmap.SetWidth( width );
1141     bitmap.SetHeight( bmpHeight );
1142     bitmap.SetDepth( wxDisplayDepth() );
1143
1144 // create a DIB header
1145     int headersize = sizeof(BITMAPINFOHEADER);
1146     LPBITMAPINFO lpDIBh = (BITMAPINFO *) malloc( headersize );
1147     wxCHECK_MSG( lpDIBh, bitmap, "could not allocate memory for DIB header" );
1148 // Fill in the DIB header
1149     lpDIBh->bmiHeader.biSize = headersize;
1150     lpDIBh->bmiHeader.biWidth = (DWORD)width;
1151     lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
1152     lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
1153 //   the general formula for biSizeImage:
1154 //      ( ( ( ((DWORD)width*24) +31 ) & ~31 ) >> 3 ) * height;
1155     lpDIBh->bmiHeader.biPlanes = 1;
1156     lpDIBh->bmiHeader.biBitCount = 24;
1157     lpDIBh->bmiHeader.biCompression = BI_RGB;
1158     lpDIBh->bmiHeader.biClrUsed = 0;
1159 // These seem not really needed for our purpose here.
1160     lpDIBh->bmiHeader.biClrImportant = 0;
1161     lpDIBh->bmiHeader.biXPelsPerMeter = 0;
1162     lpDIBh->bmiHeader.biYPelsPerMeter = 0;
1163 // memory for DIB data
1164     unsigned char *lpBits;
1165     lpBits = (unsigned char *)malloc( lpDIBh->bmiHeader.biSizeImage );
1166     if( !lpBits )
1167     {
1168         wxFAIL_MSG( "could not allocate memory for DIB" );
1169         free( lpDIBh );
1170         return bitmap;
1171     }
1172
1173 // create and set the device-dependent bitmap
1174     HDC hdc = ::GetDC(NULL);
1175     HDC memdc = ::CreateCompatibleDC( hdc );
1176     HBITMAP hbitmap;
1177     hbitmap = ::CreateCompatibleBitmap( hdc, width, bmpHeight );
1178     ::SelectObject( memdc, hbitmap);
1179
1180 // copy image data into DIB data and then into DDB (in a loop)
1181     unsigned char *data = GetData();
1182     int i, j, n;
1183     int origin = 0;
1184     unsigned char *ptdata = data;
1185     unsigned char *ptbits;
1186
1187     for( n=0; n<numDIB; n++ )
1188     {
1189         if( numDIB > 1 && n == numDIB-1 && hRemain > 0 )
1190         {
1191             // redefine height and size of the (possibly) last smaller DIB
1192             // memory is not reallocated
1193             height = hRemain;
1194             lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
1195             lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
1196         }
1197         ptbits = lpBits;
1198
1199         for( j=0; j<height; j++ )
1200         {
1201             for( i=0; i<width; i++ )
1202             {
1203                 *(ptbits++) = *(ptdata+2);
1204                 *(ptbits++) = *(ptdata+1);
1205                 *(ptbits++) = *(ptdata  );
1206                 ptdata += 3;
1207             }
1208             for( i=0; i< padding; i++ )   *(ptbits++) = 0;
1209         }
1210         ::StretchDIBits( memdc, 0, origin, width, height,\
1211             0, 0, width, height, lpBits, lpDIBh, DIB_RGB_COLORS, SRCCOPY);
1212         origin += height;
1213 // if numDIB = 1,  lines below can also be used
1214 //    hbitmap = CreateDIBitmap( hdc, &(lpDIBh->bmiHeader), CBM_INIT, lpBits, lpDIBh, DIB_RGB_COLORS );
1215 // The above line is equivalent to the following two lines.
1216 //    hbitmap = ::CreateCompatibleBitmap( hdc, width, height );
1217 //    ::SetDIBits( hdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS);
1218 // or the following lines
1219 //    hbitmap = ::CreateCompatibleBitmap( hdc, width, height );
1220 //    HDC memdc = ::CreateCompatibleDC( hdc );
1221 //    ::SelectObject( memdc, hbitmap);
1222 //    ::SetDIBitsToDevice( memdc, 0, 0, width, height,
1223 //          0, 0, 0, height, (void *)lpBits, lpDIBh, DIB_RGB_COLORS);
1224 //    ::SelectObject( memdc, 0 );
1225 //    ::DeleteDC( memdc );
1226     }
1227     bitmap.SetHBITMAP( (WXHBITMAP) hbitmap );
1228
1229 // similarly, created an mono-bitmap for the possible mask
1230     if( HasMask() )
1231     {
1232         hbitmap = ::CreateBitmap( (WORD)width, (WORD)bmpHeight, 1, 1, NULL );
1233         ::SelectObject( memdc, hbitmap);
1234         if( numDIB == 1 )   height = bmpHeight;
1235         else                height = sizeLimit/bytePerLine;
1236         lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
1237         lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
1238         origin = 0;
1239         unsigned char r = GetMaskRed();
1240         unsigned char g = GetMaskGreen();
1241         unsigned char b = GetMaskBlue();
1242         unsigned char zero = 0, one = 255;
1243         ptdata = data;
1244         for( n=0; n<numDIB; n++ )
1245         {
1246             if( numDIB > 1 && n == numDIB - 1 && hRemain > 0 )
1247             {
1248                 // redefine height and size of the (possibly) last smaller DIB
1249                 // memory is not reallocated
1250                 height = hRemain;
1251                 lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
1252                 lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
1253             }
1254             ptbits = lpBits;
1255             for( int j=0; j<height; j++ )
1256             {
1257                 for( int i=0; i<width; i++ )
1258                 {
1259                     if( (*(ptdata++)!=r) | (*(ptdata++)!=g) | (*(ptdata++)!=b) )
1260                     {
1261                         *(ptbits++) = one;
1262                         *(ptbits++) = one;
1263                         *(ptbits++) = one;
1264                     }
1265                     else
1266                     {
1267                         *(ptbits++) = zero;
1268                         *(ptbits++) = zero;
1269                         *(ptbits++) = zero;
1270                     }
1271                 }
1272                 for( i=0; i< padding; i++ )   *(ptbits++) = zero;
1273             }
1274             ::StretchDIBits( memdc, 0, origin, width, height,\
1275                 0, 0, width, height, lpBits, lpDIBh, DIB_RGB_COLORS, SRCCOPY);
1276             origin += height;
1277         }
1278 // create a wxMask object
1279         wxMask *mask = new wxMask();
1280         mask->SetMaskBitmap( (WXHBITMAP) hbitmap );
1281         bitmap.SetMask( mask );
1282 // It will be deleted when the wxBitmap object is deleted (as of 01/1999)
1283 /* The following can also be used but is slow to run
1284         wxColour colour( GetMaskRed(), GetMaskGreen(), GetMaskBlue());
1285         wxMask *mask = new wxMask( bitmap, colour );
1286         bitmap.SetMask( mask );
1287 */
1288     }
1289
1290 // free allocated resources
1291     ::SelectObject( memdc, 0 );
1292     ::DeleteDC( memdc );
1293     ::ReleaseDC(NULL, hdc);
1294     free(lpDIBh);
1295     free(lpBits);
1296
1297 // check the wxBitmap object
1298     if( bitmap.GetHBITMAP() )
1299         bitmap.SetOk( TRUE );
1300     else
1301         bitmap.SetOk( FALSE );
1302
1303     return bitmap;
1304 }
1305
1306 wxImage::wxImage( const wxBitmap &bitmap )
1307 {
1308 // check the bitmap
1309     if( !bitmap.Ok() )
1310     {
1311         wxFAIL_MSG( "invalid bitmap" );
1312         return;
1313     }
1314
1315 // create an wxImage object
1316     int width = bitmap.GetWidth();
1317     int height = bitmap.GetHeight();
1318     Create( width, height );
1319     unsigned char *data = GetData();
1320     if( !data )
1321     {
1322         wxFAIL_MSG( "could not allocate data for image" );
1323         return;
1324     }
1325
1326 // calc the number of bytes per scanline and padding in the DIB
1327     int bytePerLine = width*3;
1328     int sizeDWORD = sizeof( DWORD );
1329     div_t lineBoundary = div( bytePerLine, sizeDWORD );
1330     int padding = 0;
1331     if( lineBoundary.rem > 0 )
1332     {
1333         padding = sizeDWORD - lineBoundary.rem;
1334         bytePerLine += padding;
1335     }
1336
1337 // create a DIB header
1338     int headersize = sizeof(BITMAPINFOHEADER);
1339     LPBITMAPINFO lpDIBh = (BITMAPINFO *) malloc( headersize );
1340     if( !lpDIBh )
1341     {
1342         wxFAIL_MSG( "could not allocate data for DIB header" );
1343         free( data );
1344         return;
1345     }
1346 // Fill in the DIB header
1347     lpDIBh->bmiHeader.biSize = headersize;
1348     lpDIBh->bmiHeader.biWidth = width;
1349     lpDIBh->bmiHeader.biHeight = -height;
1350     lpDIBh->bmiHeader.biSizeImage = bytePerLine * height;
1351     lpDIBh->bmiHeader.biPlanes = 1;
1352     lpDIBh->bmiHeader.biBitCount = 24;
1353     lpDIBh->bmiHeader.biCompression = BI_RGB;
1354     lpDIBh->bmiHeader.biClrUsed = 0;
1355 // These seem not really needed for our purpose here.
1356     lpDIBh->bmiHeader.biClrImportant = 0;
1357     lpDIBh->bmiHeader.biXPelsPerMeter = 0;
1358     lpDIBh->bmiHeader.biYPelsPerMeter = 0;
1359 // memory for DIB data
1360     unsigned char *lpBits;
1361     lpBits = (unsigned char *) malloc( lpDIBh->bmiHeader.biSizeImage );
1362     if( !lpBits )
1363     {
1364         wxFAIL_MSG( "could not allocate data for DIB" );
1365         free( data );
1366         free( lpDIBh );
1367         return;
1368     }
1369
1370 // copy data from the device-dependent bitmap to the DIB
1371     HDC hdc = ::GetDC(NULL);
1372     HBITMAP hbitmap;
1373     hbitmap = (HBITMAP) bitmap.GetHBITMAP();
1374     ::GetDIBits( hdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
1375
1376 // copy DIB data into the wxImage object
1377     int i, j;
1378     unsigned char *ptdata = data;
1379     unsigned char *ptbits = lpBits;
1380     for( i=0; i<height; i++ )
1381     {
1382         for( j=0; j<width; j++ )
1383         {
1384             *(ptdata++) = *(ptbits+2);
1385             *(ptdata++) = *(ptbits+1);
1386             *(ptdata++) = *(ptbits  );
1387             ptbits += 3;
1388         }
1389         ptbits += padding;
1390     }
1391
1392 // similarly, set data according to the possible mask bitmap
1393     if( bitmap.GetMask() && bitmap.GetMask()->GetMaskBitmap() )
1394     {
1395         hbitmap = (HBITMAP) bitmap.GetMask()->GetMaskBitmap();
1396         // memory DC created, color set, data copied, and memory DC deleted
1397         HDC memdc = ::CreateCompatibleDC( hdc );
1398         ::SetTextColor( memdc, RGB( 0, 0, 0 ) );
1399         ::SetBkColor( memdc, RGB( 255, 255, 255 ) );
1400         ::GetDIBits( memdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
1401         ::DeleteDC( memdc );
1402 // background color set to RGB(16,16,16) in consistent with wxGTK
1403         unsigned char r=16, g=16, b=16;
1404         ptdata = data;
1405         ptbits = lpBits;
1406         for( i=0; i<height; i++ )
1407         {
1408             for( j=0; j<width; j++ )
1409             {
1410                 if( *ptbits != 0 )
1411                     ptdata += 3;
1412                 else
1413                 {
1414                     *(ptdata++)  = r;
1415                     *(ptdata++)  = g;
1416                     *(ptdata++)  = b;
1417                 }
1418                 ptbits += 3;
1419             }
1420             ptbits += padding;
1421         }
1422         SetMaskColour( r, g, b );
1423         SetMask( TRUE );
1424     }
1425     else
1426     {
1427         SetMask( FALSE );
1428     }
1429 // free allocated resources
1430     ::ReleaseDC(NULL, hdc);
1431     free(lpDIBh);
1432     free(lpBits);
1433 }
1434
1435 #endif
1436
1437 #ifdef __WXGTK__
1438
1439 #include "gtk/gtk.h"
1440 #include "gdk/gdk.h"
1441 #include "gdk/gdkx.h"
1442
1443 wxBitmap wxImage::ConvertToBitmap() const
1444 {
1445     wxBitmap bitmap;
1446
1447     wxCHECK_MSG( Ok(), bitmap, "invalid image" );
1448
1449     int width = GetWidth();
1450     int height = GetHeight();
1451
1452     bitmap.SetHeight( height );
1453     bitmap.SetWidth( width );
1454
1455     // Create picture
1456
1457     GdkImage *data_image =
1458       gdk_image_new( GDK_IMAGE_FASTEST, gdk_visual_get_system(), width, height );
1459
1460     bitmap.SetPixmap( gdk_pixmap_new( (GdkWindow*)&gdk_root_parent, width, height, -1 ) );
1461
1462     // Create mask
1463
1464     GdkImage *mask_image = (GdkImage*) NULL;
1465
1466     if (HasMask())
1467     {
1468         unsigned char *mask_data = (unsigned char*)malloc( ((width >> 3)+8) * height );
1469
1470         mask_image =  gdk_image_new_bitmap( gdk_visual_get_system(), mask_data, width, height );
1471
1472         wxMask *mask = new wxMask();
1473         mask->m_bitmap = gdk_pixmap_new( (GdkWindow*)&gdk_root_parent, width, height, 1 );
1474
1475         bitmap.SetMask( mask );
1476     }
1477
1478     // Retrieve depth
1479
1480     GdkVisual *visual = gdk_window_get_visual( bitmap.GetPixmap() );
1481     if (visual == NULL) visual = gdk_window_get_visual( (GdkWindow*) &gdk_root_parent );
1482     int bpp = visual->depth;
1483
1484     bitmap.SetDepth( bpp );
1485
1486     if ((bpp == 16) && (visual->red_mask != 0xf800)) bpp = 15;
1487     if (bpp < 8) bpp = 8;
1488
1489     // Render
1490
1491     enum byte_order { RGB, RBG, BRG, BGR, GRB, GBR };
1492     byte_order b_o = RGB;
1493
1494     if (bpp >= 24)
1495     {
1496         GdkVisual *visual = gdk_visual_get_system();
1497         if ((visual->red_mask > visual->green_mask) && (visual->green_mask > visual->blue_mask))      b_o = RGB;
1498         else if ((visual->red_mask > visual->blue_mask) && (visual->blue_mask > visual->green_mask))  b_o = RGB;
1499         else if ((visual->blue_mask > visual->red_mask) && (visual->red_mask > visual->green_mask))   b_o = BRG;
1500         else if ((visual->blue_mask > visual->green_mask) && (visual->green_mask > visual->red_mask)) b_o = BGR;
1501         else if ((visual->green_mask > visual->red_mask) && (visual->red_mask > visual->blue_mask))   b_o = GRB;
1502         else if ((visual->green_mask > visual->blue_mask) && (visual->blue_mask > visual->red_mask))  b_o = GBR;
1503     }
1504
1505     int r_mask = GetMaskRed();
1506     int g_mask = GetMaskGreen();
1507     int b_mask = GetMaskBlue();
1508
1509     unsigned char* data = GetData();
1510
1511     int index = 0;
1512     for (int y = 0; y < height; y++)
1513     {
1514         for (int x = 0; x < width; x++)
1515         {
1516             int r = data[index];
1517             index++;
1518             int g = data[index];
1519             index++;
1520             int b = data[index];
1521             index++;
1522
1523             if (HasMask())
1524             {
1525                 if ((r == r_mask) && (b == b_mask) && (g == g_mask))
1526                     gdk_image_put_pixel( mask_image, x, y, 1 );
1527                 else
1528                     gdk_image_put_pixel( mask_image, x, y, 0 );
1529             }
1530
1531             if (HasMask())
1532             {
1533                 if ((r == r_mask) && (b == b_mask) && (g == g_mask))
1534                     gdk_image_put_pixel( mask_image, x, y, 1 );
1535                 else
1536                     gdk_image_put_pixel( mask_image, x, y, 0 );
1537             }
1538
1539             switch (bpp)
1540             {
1541                 case 8:
1542                 {
1543                     int pixel = -1;
1544                     if (wxTheApp->m_colorCube)
1545                     {
1546                         pixel = wxTheApp->m_colorCube[ ((r & 0xf8) << 7) + ((g & 0xf8) << 2) + ((b & 0xf8) >> 3) ];
1547                     }
1548                     else
1549                     {
1550                         GdkColormap *cmap = gtk_widget_get_default_colormap();
1551                         GdkColor *colors = cmap->colors;
1552                         int max = 3 * (65536);
1553
1554                         for (int i = 0; i < cmap->size; i++)
1555                         {
1556                             int rdiff = (r << 8) - colors[i].red;
1557                             int gdiff = (g << 8) - colors[i].green;
1558                             int bdiff = (b << 8) - colors[i].blue;
1559                             int sum = ABS (rdiff) + ABS (gdiff) + ABS (bdiff);
1560                             if (sum < max) { pixel = i; max = sum; }
1561                         }
1562                     }
1563
1564                     gdk_image_put_pixel( data_image, x, y, pixel );
1565
1566                     break;
1567                 }
1568                 case 15:
1569                 {
1570                     guint32 pixel = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
1571                     gdk_image_put_pixel( data_image, x, y, pixel );
1572                     break;
1573                 }
1574                 case 16:
1575                 {
1576                     guint32 pixel = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
1577                     gdk_image_put_pixel( data_image, x, y, pixel );
1578                     break;
1579                 }
1580                 case 32:
1581                 case 24:
1582                 {
1583                     guint32 pixel = 0;
1584                     switch (b_o)
1585                     {
1586                         case RGB: pixel = (r << 16) | (g << 8) | b; break;
1587                         case RBG: pixel = (r << 16) | (b << 8) | g; break;
1588                         case BRG: pixel = (b << 16) | (r << 8) | g; break;
1589                         case BGR: pixel = (b << 16) | (g << 8) | r; break;
1590                         case GRB: pixel = (g << 16) | (r << 8) | b; break;
1591                         case GBR: pixel = (g << 16) | (b << 8) | r; break;
1592                     }
1593                     gdk_image_put_pixel( data_image, x, y, pixel );
1594                 }
1595                 default: break;
1596             }
1597         } // for
1598     }  // for
1599
1600     // Blit picture
1601
1602     GdkGC *data_gc = gdk_gc_new( bitmap.GetPixmap() );
1603
1604     gdk_draw_image( bitmap.GetPixmap(), data_gc, data_image, 0, 0, 0, 0, width, height );
1605
1606     gdk_image_destroy( data_image );
1607     gdk_gc_unref( data_gc );
1608
1609     // Blit mask
1610
1611     if (HasMask())
1612     {
1613         GdkGC *mask_gc = gdk_gc_new( bitmap.GetMask()->GetBitmap() );
1614
1615         gdk_draw_image( bitmap.GetMask()->GetBitmap(), mask_gc, mask_image, 0, 0, 0, 0, width, height );
1616
1617         gdk_image_destroy( mask_image );
1618         gdk_gc_unref( mask_gc );
1619     }
1620
1621     return bitmap;
1622 }
1623
1624 wxImage::wxImage( const wxBitmap &bitmap )
1625 {
1626     wxCHECK_RET( bitmap.Ok(), "invalid bitmap" );
1627
1628     GdkImage *gdk_image = gdk_image_get( bitmap.GetPixmap(),
1629                                          0, 0,
1630                                          bitmap.GetWidth(), bitmap.GetHeight() );
1631
1632     wxCHECK_RET( gdk_image, "couldn't create image" );
1633
1634     Create( bitmap.GetWidth(), bitmap.GetHeight() );
1635     char unsigned *data = GetData();
1636
1637     if (!data)
1638     {
1639         gdk_image_destroy( gdk_image );
1640         wxFAIL_MSG( "couldn't create image" );
1641         return;
1642     }
1643
1644     GdkImage *gdk_image_mask = (GdkImage*) NULL;
1645     if (bitmap.GetMask())
1646     {
1647         gdk_image_mask = gdk_image_get( bitmap.GetMask()->GetBitmap(),
1648                                         0, 0,
1649                                         bitmap.GetWidth(), bitmap.GetHeight() );
1650
1651         SetMaskColour( 16, 16, 16 );  // anything unlikely and dividable
1652     }
1653
1654     GdkVisual *visual = gdk_window_get_visual( bitmap.GetPixmap() );
1655     if (visual == NULL) visual = gdk_window_get_visual( (GdkWindow*) &gdk_root_parent );
1656     int bpp = visual->depth;
1657     if ((bpp == 16) && (visual->red_mask != 0xf800)) bpp = 15;
1658
1659     GdkColormap *cmap = gtk_widget_get_default_colormap();
1660
1661     long pos = 0;
1662     for (int j = 0; j < bitmap.GetHeight(); j++)
1663     {
1664         for (int i = 0; i < bitmap.GetWidth(); i++)
1665         {
1666             int pixel = gdk_image_get_pixel( gdk_image, i, j );
1667             if (bpp <= 8)
1668             {
1669                 data[pos] = cmap->colors[pixel].red >> 8;
1670                 data[pos+1] = cmap->colors[pixel].green >> 8;
1671                 data[pos+2] = cmap->colors[pixel].blue >> 8;
1672             } else if (bpp == 15)
1673             {
1674                 data[pos] = (pixel >> 7) & 0xf8;
1675                 data[pos+1] = (pixel >> 2) & 0xf8;
1676                 data[pos+2] = (pixel << 3) & 0xf8;
1677             } else if (bpp == 16)
1678             {
1679                 data[pos] = (pixel >> 8) & 0xf8;
1680                 data[pos+1] = (pixel >> 3) & 0xfc;
1681                 data[pos+2] = (pixel << 3) & 0xf8;
1682             } else
1683             {
1684                 data[pos] = (pixel >> 16) & 0xff;
1685                 data[pos+1] = (pixel >> 8) & 0xff;
1686                 data[pos+2] = pixel & 0xff;
1687             }
1688
1689             if (gdk_image_mask)
1690             {
1691                 int mask_pixel = gdk_image_get_pixel( gdk_image_mask, i, j );
1692                 if (mask_pixel == 0)
1693                 {
1694                     data[pos] = 16;
1695                     data[pos+1] = 16;
1696                     data[pos+2] = 16;
1697                }
1698             }
1699
1700             pos += 3;
1701         }
1702     }
1703
1704     gdk_image_destroy( gdk_image );
1705     if (gdk_image_mask) gdk_image_destroy( gdk_image_mask );
1706 }
1707
1708 #endif
1709
1710 #ifdef __WXMOTIF__
1711
1712 #include <Xm/Xm.h>
1713 #include "wx/utils.h"
1714 #include <math.h>
1715
1716 wxBitmap wxImage::ConvertToBitmap() const
1717 {
1718     wxBitmap bitmap;
1719
1720     wxCHECK_MSG( Ok(), bitmap, "invalid image" );
1721
1722     int width = GetWidth();
1723     int height = GetHeight();
1724
1725     bitmap.SetHeight( height );
1726     bitmap.SetWidth( width );
1727
1728     Display *dpy = (Display*) wxGetDisplay();
1729     Visual* vis = DefaultVisual( dpy, DefaultScreen( dpy ) );
1730     int bpp = DefaultDepth( dpy, DefaultScreen( dpy ) );
1731
1732     // Create image
1733
1734     XImage *data_image = XCreateImage( dpy, vis, bpp, ZPixmap, 0, 0, width, height, 32, 0 );
1735     data_image->data = new char[ data_image->bytes_per_line * data_image->height ];
1736
1737     bitmap.Create( width, height, bpp );
1738
1739 /*
1740     // Create mask
1741
1742     GdkImage *mask_image = (GdkImage*) NULL;
1743
1744     if (HasMask())
1745     {
1746         unsigned char *mask_data = (unsigned char*)malloc( ((width >> 3)+8) * height );
1747
1748         mask_image =  gdk_image_new_bitmap( gdk_visual_get_system(), mask_data, width, height );
1749
1750         wxMask *mask = new wxMask();
1751         mask->m_bitmap = gdk_pixmap_new( (GdkWindow*)&gdk_root_parent, width, height, 1 );
1752
1753         bitmap.SetMask( mask );
1754     }
1755 */
1756
1757     // Retrieve depth info
1758
1759     XVisualInfo vinfo_template;
1760     XVisualInfo *vi;
1761
1762     vinfo_template.visual = vis;
1763     vinfo_template.visualid = XVisualIDFromVisual( vis );
1764     vinfo_template.depth = bpp;
1765     int nitem = 0;
1766
1767     vi = XGetVisualInfo( dpy, VisualIDMask|VisualDepthMask, &vinfo_template, &nitem );
1768
1769     if (!vi)
1770     {
1771         printf("no visual.\n" );
1772         return wxNullBitmap;
1773     }
1774
1775     XFree( vi );
1776
1777     if ((bpp == 16) && (vi->red_mask != 0xf800)) bpp = 15;
1778     if (bpp < 8) bpp = 8;
1779
1780     // Render
1781
1782     enum byte_order { RGB, RBG, BRG, BGR, GRB, GBR };
1783     byte_order b_o = RGB;
1784
1785     if (bpp >= 24)
1786     {
1787         if ((vi->red_mask > vi->green_mask) && (vi->green_mask > vi->blue_mask))      b_o = RGB;
1788         else if ((vi->red_mask > vi->blue_mask) && (vi->blue_mask > vi->green_mask))  b_o = RGB;
1789         else if ((vi->blue_mask > vi->red_mask) && (vi->red_mask > vi->green_mask))   b_o = BRG;
1790         else if ((vi->blue_mask > vi->green_mask) && (vi->green_mask > vi->red_mask)) b_o = BGR;
1791         else if ((vi->green_mask > vi->red_mask) && (vi->red_mask > vi->blue_mask))   b_o = GRB;
1792         else if ((vi->green_mask > vi->blue_mask) && (vi->blue_mask > vi->red_mask))  b_o = GBR;
1793     }
1794
1795 /*
1796     int r_mask = GetMaskRed();
1797     int g_mask = GetMaskGreen();
1798     int b_mask = GetMaskBlue();
1799 */
1800
1801     XColor colors[256];
1802     if (bpp == 8)
1803     {
1804         Colormap cmap = (Colormap) wxTheApp->GetMainColormap( dpy );
1805
1806         for (int i = 0; i < 256; i++) colors[i].pixel = i;
1807         XQueryColors( dpy, cmap, colors, 256 );
1808     }
1809
1810     unsigned char* data = GetData();
1811
1812     int index = 0;
1813     for (int y = 0; y < height; y++)
1814     {
1815         for (int x = 0; x < width; x++)
1816         {
1817             int r = data[index];
1818             index++;
1819             int g = data[index];
1820             index++;
1821             int b = data[index];
1822             index++;
1823
1824 /*
1825             if (HasMask())
1826             {
1827                 if ((r == r_mask) && (b == b_mask) && (g == g_mask))
1828                     gdk_image_put_pixel( mask_image, x, y, 1 );
1829                 else
1830                     gdk_image_put_pixel( mask_image, x, y, 0 );
1831             }
1832 */
1833
1834             switch (bpp)
1835             {
1836                 case 8:
1837                 {
1838                     int pixel = -1;
1839 /*
1840                     if (wxTheApp->m_colorCube)
1841                     {
1842                         pixel = wxTheApp->m_colorCube
1843                            [ ((r & 0xf8) << 7) + ((g & 0xf8) << 2) + ((b & 0xf8) >> 3) ];
1844                     }
1845                     else
1846                     {
1847 */
1848                         int max = 3 * (65536);
1849                         for (int i = 0; i < 256; i++)
1850                         {
1851                             int rdiff = (r << 8) - colors[i].red;
1852                             int gdiff = (g << 8) - colors[i].green;
1853                             int bdiff = (b << 8) - colors[i].blue;
1854                             int sum = abs (rdiff) + abs (gdiff) + abs (bdiff);
1855                             if (sum < max) { pixel = i; max = sum; }
1856                         }
1857 /*
1858                     }
1859 */
1860                     XPutPixel( data_image, x, y, pixel );
1861                     break;
1862                 }
1863                 case 15:
1864                 {
1865                     int pixel = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
1866                     XPutPixel( data_image, x, y, pixel );
1867                     break;
1868                 }
1869                 case 16:
1870                 {
1871                     int pixel = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
1872                     XPutPixel( data_image, x, y, pixel );
1873                     break;
1874                 }
1875                 case 32:
1876                 case 24:
1877                 {
1878                     int pixel = 0;
1879                     switch (b_o)
1880                     {
1881                         case RGB: pixel = (r << 16) | (g << 8) | b; break;
1882                         case RBG: pixel = (r << 16) | (b << 8) | g; break;
1883                         case BRG: pixel = (b << 16) | (r << 8) | g; break;
1884                         case BGR: pixel = (b << 16) | (g << 8) | r; break;
1885                         case GRB: pixel = (g << 16) | (r << 8) | b; break;
1886                         case GBR: pixel = (g << 16) | (b << 8) | r; break;
1887                     }
1888                     XPutPixel( data_image, x, y, pixel );
1889                 }
1890                 default: break;
1891             }
1892         } // for
1893     }  // for
1894
1895     // Blit picture
1896
1897     XGCValues gcvalues;
1898     gcvalues.foreground = BlackPixel( dpy, DefaultScreen( dpy ) );
1899     GC gc = XCreateGC( dpy, RootWindow ( dpy, DefaultScreen(dpy) ), GCForeground, &gcvalues );
1900     XPutImage( dpy, (Drawable)bitmap.GetPixmap(), gc, data_image, 0, 0, 0, 0, width, height );
1901
1902     XDestroyImage( data_image );
1903     XFreeGC( dpy, gc );
1904
1905 /*
1906     // Blit mask
1907
1908     if (HasMask())
1909     {
1910         GdkGC *mask_gc = gdk_gc_new( bitmap.GetMask()->GetBitmap() );
1911
1912         gdk_draw_image( bitmap.GetMask()->GetBitmap(), mask_gc, mask_image, 0, 0, 0, 0, width, height );
1913
1914         gdk_image_destroy( mask_image );
1915         gdk_gc_unref( mask_gc );
1916     }
1917 */
1918
1919     return bitmap;
1920 }
1921
1922 wxImage::wxImage( const wxBitmap &bitmap )
1923 {
1924     wxCHECK_RET( bitmap.Ok(), "invalid bitmap" );
1925
1926     Display *dpy = (Display*) wxGetDisplay();
1927     Visual* vis = DefaultVisual( dpy, DefaultScreen( dpy ) );
1928     int bpp = DefaultDepth( dpy, DefaultScreen( dpy ) );
1929
1930     XImage *ximage = XGetImage( dpy,
1931                                 (Drawable)bitmap.GetPixmap(),
1932                                 0, 0,
1933                                 bitmap.GetWidth(), bitmap.GetHeight(),
1934                                 AllPlanes, ZPixmap );
1935
1936     wxCHECK_RET( ximage, "couldn't create image" );
1937
1938     Create( bitmap.GetWidth(), bitmap.GetHeight() );
1939     char unsigned *data = GetData();
1940
1941     if (!data)
1942     {
1943         XDestroyImage( ximage );
1944         wxFAIL_MSG( "couldn't create image" );
1945         return;
1946     }
1947
1948 /*
1949     GdkImage *gdk_image_mask = (GdkImage*) NULL;
1950     if (bitmap.GetMask())
1951     {
1952         gdk_image_mask = gdk_image_get( bitmap.GetMask()->GetBitmap(),
1953                                         0, 0,
1954                                         bitmap.GetWidth(), bitmap.GetHeight() );
1955
1956         SetMaskColour( 16, 16, 16 );  // anything unlikely and dividable
1957     }
1958 */
1959
1960     // Retrieve depth info
1961
1962     XVisualInfo vinfo_template;
1963     XVisualInfo *vi;
1964
1965     vinfo_template.visual = vis;
1966     vinfo_template.visualid = XVisualIDFromVisual( vis );
1967     vinfo_template.depth = bpp;
1968     int nitem = 0;
1969
1970     vi = XGetVisualInfo( dpy, VisualIDMask|VisualDepthMask, &vinfo_template, &nitem );
1971
1972     if (!vi)
1973     {
1974         printf("no visual.\n" );
1975         return;
1976     }
1977
1978     if ((bpp == 16) && (vi->red_mask != 0xf800)) bpp = 15;
1979
1980     XFree( vi );
1981
1982     XColor colors[256];
1983     if (bpp == 8)
1984     {
1985         Colormap cmap = (Colormap)wxTheApp->GetMainColormap( dpy );
1986
1987         for (int i = 0; i < 256; i++) colors[i].pixel = i;
1988         XQueryColors( dpy, cmap, colors, 256 );
1989     }
1990
1991     long pos = 0;
1992     for (int j = 0; j < bitmap.GetHeight(); j++)
1993     {
1994         for (int i = 0; i < bitmap.GetWidth(); i++)
1995         {
1996             int pixel = XGetPixel( ximage, i, j );
1997             if (bpp <= 8)
1998             {
1999                 data[pos] = colors[pixel].red >> 8;
2000                 data[pos+1] = colors[pixel].green >> 8;
2001                 data[pos+2] = colors[pixel].blue >> 8;
2002             } else if (bpp == 15)
2003             {
2004                 data[pos] = (pixel >> 7) & 0xf8;
2005                 data[pos+1] = (pixel >> 2) & 0xf8;
2006                 data[pos+2] = (pixel << 3) & 0xf8;
2007             } else if (bpp == 16)
2008             {
2009                 data[pos] = (pixel >> 8) & 0xf8;
2010                 data[pos+1] = (pixel >> 3) & 0xfc;
2011                 data[pos+2] = (pixel << 3) & 0xf8;
2012             } else
2013             {
2014                 data[pos] = (pixel >> 16) & 0xff;
2015                 data[pos+1] = (pixel >> 8) & 0xff;
2016                 data[pos+2] = pixel & 0xff;
2017             }
2018
2019 /*
2020             if (gdk_image_mask)
2021             {
2022                 int mask_pixel = gdk_image_get_pixel( gdk_image_mask, i, j );
2023                 if (mask_pixel == 0)
2024                 {
2025                     data[pos] = 16;
2026                     data[pos+1] = 16;
2027                     data[pos+2] = 16;
2028                }
2029             }
2030 */
2031
2032             pos += 3;
2033         }
2034     }
2035
2036     XDestroyImage( ximage );
2037 /*
2038     if (gdk_image_mask) gdk_image_destroy( gdk_image_mask );
2039 */
2040 }
2041 #endif