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