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 #include "wx/filefn.h"
  27 #include "wx/wfstream.h"
  28 #include "wx/intl.h"
  29 #include "wx/module.h"
  30
  31 // For memcpy
  32 #include <string.h>
  33
  34 #ifdef __SALFORDC__
  35     #undef FAR
  36 #endif
  37
  38 #ifdef __WXMSW__
  39     #include "wx/msw/private.h"
  40 #endif
  41
  42 //-----------------------------------------------------------------------------
  43 // wxImage
  44 //-----------------------------------------------------------------------------
  45
  46 class wxImageRefData: public wxObjectRefData
  47 {
  48 public:
  49     wxImageRefData();
  50     ~wxImageRefData();
  51
  52     int             m_width;
  53     int             m_height;
  54     unsigned char  *m_data;
  55     bool            m_hasMask;
  56     unsigned char   m_maskRed,m_maskGreen,m_maskBlue;
  57     bool            m_ok;
  58 };
  59
  60 wxImageRefData::wxImageRefData()
  61 {
  62     m_width = 0;
  63     m_height = 0;
  64     m_data = (unsigned char*) NULL;
  65     m_ok = FALSE;
  66     m_maskRed = 0;
  67     m_maskGreen = 0;
  68     m_maskBlue = 0;
  69     m_hasMask = FALSE;
  70 }
  71
  72 wxImageRefData::~wxImageRefData()
  73 {
  74     if (m_data)
  75         free( m_data );
  76 }
  77
  78 wxList wxImage::sm_handlers;
  79
  80 //-----------------------------------------------------------------------------
  81
  82 #define M_IMGDATA ((wxImageRefData *)m_refData)
  83
  84     IMPLEMENT_DYNAMIC_CLASS(wxImage, wxObject)
  85
  86 wxImage::wxImage()
  87 {
  88 }
  89
  90 wxImage::wxImage( int width, int height )
  91 {
  92     Create( width, height );
  93 }
  94
  95 wxImage::wxImage( const wxString& name, long type )
  96 {
  97     LoadFile( name, type );
  98 }
  99
 100 wxImage::wxImage( const wxString& name, const wxString& mimetype )
 101 {
 102     LoadFile( name, mimetype );
 103 }
 104
 105 #if wxUSE_STREAMS
 106 wxImage::wxImage( wxInputStream& stream, long type )
 107 {
 108     LoadFile( stream, type );
 109 }
 110
 111 wxImage::wxImage( wxInputStream& stream, const wxString& mimetype )
 112 {
 113     LoadFile( stream, mimetype );
 114 }
 115 #endif // wxUSE_STREAMS
 116
 117 wxImage::wxImage( const wxImage& image )
 118 {
 119     Ref(image);
 120 }
 121
 122 wxImage::wxImage( const wxImage* image )
 123 {
 124     if (image) Ref(*image);
 125 }
 126
 127 void wxImage::Create( int width, int height )
 128 {
 129     m_refData = new wxImageRefData();
 130
 131     M_IMGDATA->m_data = (unsigned char *) malloc( width*height*3 );
 132     if (M_IMGDATA->m_data)
 133     {
 134         for (int l = 0; l < width*height*3; l++) M_IMGDATA->m_data[l] = 0;
 135
 136         M_IMGDATA->m_width = width;
 137         M_IMGDATA->m_height = height;
 138         M_IMGDATA->m_ok = TRUE;
 139     }
 140     else
 141     {
 142         UnRef();
 143     }
 144 }
 145
 146 void wxImage::Destroy()
 147 {
 148     UnRef();
 149 }
 150
 151 wxImage wxImage::Scale( int width, int height ) const
 152 {
 153     wxImage image;
 154
 155     wxCHECK_MSG( Ok(), image, wxT("invalid image") );
 156
 157     wxCHECK_MSG( (width > 0) && (height > 0), image, wxT("invalid image size") );
 158
 159     image.Create( width, height );
 160
 161     char unsigned *data = image.GetData();
 162
 163     wxCHECK_MSG( data, image, wxT("unable to create image") );
 164
 165     if (M_IMGDATA->m_hasMask)
 166         image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
 167
 168     long old_height = M_IMGDATA->m_height;
 169     long old_width  = M_IMGDATA->m_width;
 170
 171     char unsigned *source_data = M_IMGDATA->m_data;
 172     char unsigned *target_data = data;
 173
 174     for (long j = 0; j < height; j++)
 175     {
 176         long y_offset = (j * old_height / height) * old_width;
 177
 178         for (long i = 0; i < width; i++)
 179         {
 180             memcpy( target_data,
 181                 source_data + 3*(y_offset + ((i * old_width )/ width)),
 182                 3 );
 183             target_data += 3;
 184         }
 185     }
 186
 187     return image;
 188 }
 189
 190 wxImage wxImage::GetSubImage( const wxRect &rect ) const
 191 {
 192     wxImage image;
 193
 194     wxCHECK_MSG( Ok(), image, wxT("invalid image") );
 195
 196     wxCHECK_MSG( (rect.GetLeft()>=0) && (rect.GetTop()>=0) && (rect.GetRight()<=GetWidth()) && (rect.GetBottom()<=GetHeight()),
 197                  image, wxT("invalid subimage size") );
 198
 199     int subwidth=rect.GetWidth();
 200     const int subheight=rect.GetHeight();
 201
 202     image.Create( subwidth, subheight );
 203
 204     char unsigned *subdata = image.GetData(), *data=GetData();
 205
 206     wxCHECK_MSG( subdata, image, wxT("unable to create image") );
 207
 208     if (M_IMGDATA->m_hasMask)
 209         image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
 210
 211     const int subleft=3*rect.GetLeft();
 212     const int width=3*GetWidth();
 213     subwidth*=3;
 214
 215     data+=rect.GetTop()*width+subleft;
 216
 217     for (long j = 0; j < subheight; ++j)
 218     {
 219         memcpy( subdata, data, subwidth);
 220         subdata+=subwidth;
 221         data+=width;
 222     }
 223
 224     return image;
 225 }
 226
 227 void wxImage::Replace( unsigned char r1, unsigned char g1, unsigned char b1,
 228                        unsigned char r2, unsigned char g2, unsigned char b2 )
 229 {
 230     wxCHECK_RET( Ok(), wxT("invalid image") );
 231
 232     char unsigned *data = GetData();
 233
 234     const int w = GetWidth();
 235     const int h = GetHeight();
 236
 237     for (int j = 0; j < h; j++)
 238         for (int i = 0; i < w; i++)
 239         {
 240             if ((data[0] == r1) && (data[1] == g1) && (data[2] == b1))
 241             {
 242                 data[0] = r2;
 243                 data[1] = g2;
 244                 data[2] = b2;
 245             }
 246             data += 3;
 247         }
 248 }
 249
 250 void wxImage::SetRGB( int x, int y, unsigned char r, unsigned char g, unsigned char b )
 251 {
 252     wxCHECK_RET( Ok(), wxT("invalid image") );
 253
 254     int w = M_IMGDATA->m_width;
 255     int h = M_IMGDATA->m_height;
 256
 257     wxCHECK_RET( (x>=0) && (y>=0) && (x<w) && (y<h), wxT("invalid image index") );
 258
 259     long pos = (y * w + x) * 3;
 260
 261     M_IMGDATA->m_data[ pos   ] = r;
 262     M_IMGDATA->m_data[ pos+1 ] = g;
 263     M_IMGDATA->m_data[ pos+2 ] = b;
 264 }
 265
 266 unsigned char wxImage::GetRed( int x, int y )
 267 {
 268     wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
 269
 270     int w = M_IMGDATA->m_width;
 271     int h = M_IMGDATA->m_height;
 272
 273     wxCHECK_MSG( (x>=0) && (y>=0) && (x<w) && (y<h), 0, wxT("invalid image index") );
 274
 275     long pos = (y * w + x) * 3;
 276
 277     return M_IMGDATA->m_data[pos];
 278 }
 279
 280 unsigned char wxImage::GetGreen( int x, int y )
 281 {
 282     wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
 283
 284     int w = M_IMGDATA->m_width;
 285     int h = M_IMGDATA->m_height;
 286
 287     wxCHECK_MSG( (x>=0) && (y>=0) && (x<w) && (y<h), 0, wxT("invalid image index") );
 288
 289     long pos = (y * w + x) * 3;
 290
 291     return M_IMGDATA->m_data[pos+1];
 292 }
 293
 294 unsigned char wxImage::GetBlue( int x, int y )
 295 {
 296     wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
 297
 298     int w = M_IMGDATA->m_width;
 299     int h = M_IMGDATA->m_height;
 300
 301     wxCHECK_MSG( (x>=0) && (y>=0) && (x<w) && (y<h), 0, wxT("invalid image index") );
 302
 303     long pos = (y * w + x) * 3;
 304
 305     return M_IMGDATA->m_data[pos+2];
 306 }
 307
 308 bool wxImage::Ok() const
 309 {
 310     return (M_IMGDATA && M_IMGDATA->m_ok);
 311 }
 312
 313 char unsigned *wxImage::GetData() const
 314 {
 315     wxCHECK_MSG( Ok(), (char unsigned *)NULL, wxT("invalid image") );
 316
 317     return M_IMGDATA->m_data;
 318 }
 319
 320 void wxImage::SetData( char unsigned *data )
 321 {
 322     wxCHECK_RET( Ok(), wxT("invalid image") );
 323
 324     wxImageRefData *newRefData = new wxImageRefData();
 325
 326     newRefData->m_width = M_IMGDATA->m_width;
 327     newRefData->m_height = M_IMGDATA->m_height;
 328     newRefData->m_data = data;
 329     newRefData->m_ok = TRUE;
 330     newRefData->m_maskRed = M_IMGDATA->m_maskRed;
 331     newRefData->m_maskGreen = M_IMGDATA->m_maskGreen;
 332     newRefData->m_maskBlue = M_IMGDATA->m_maskBlue;
 333     newRefData->m_hasMask = M_IMGDATA->m_hasMask;
 334
 335     UnRef();
 336
 337     m_refData = newRefData;
 338 }
 339
 340 void wxImage::SetMaskColour( unsigned char r, unsigned char g, unsigned char b )
 341 {
 342     wxCHECK_RET( Ok(), wxT("invalid image") );
 343
 344     M_IMGDATA->m_maskRed = r;
 345     M_IMGDATA->m_maskGreen = g;
 346     M_IMGDATA->m_maskBlue = b;
 347     M_IMGDATA->m_hasMask = TRUE;
 348 }
 349
 350 unsigned char wxImage::GetMaskRed() const
 351 {
 352     wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
 353
 354     return M_IMGDATA->m_maskRed;
 355 }
 356
 357 unsigned char wxImage::GetMaskGreen() const
 358 {
 359     wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
 360
 361     return M_IMGDATA->m_maskGreen;
 362 }
 363
 364 unsigned char wxImage::GetMaskBlue() const
 365 {
 366     wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
 367
 368     return M_IMGDATA->m_maskBlue;
 369 }
 370
 371 void wxImage::SetMask( bool mask )
 372 {
 373     wxCHECK_RET( Ok(), wxT("invalid image") );
 374
 375     M_IMGDATA->m_hasMask = mask;
 376 }
 377
 378 bool wxImage::HasMask() const
 379 {
 380     wxCHECK_MSG( Ok(), FALSE, wxT("invalid image") );
 381
 382     return M_IMGDATA->m_hasMask;
 383 }
 384
 385 int wxImage::GetWidth() const
 386 {
 387     wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
 388
 389     return M_IMGDATA->m_width;
 390 }
 391
 392 int wxImage::GetHeight() const
 393 {
 394     wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
 395
 396     return M_IMGDATA->m_height;
 397 }
 398
 399 bool wxImage::LoadFile( const wxString& filename, long type )
 400 {
 401 #if wxUSE_STREAMS
 402     if (wxFileExists(filename))
 403     {
 404         wxFileInputStream stream(filename);
 405         wxBufferedInputStream bstream( stream );
 406         return LoadFile(bstream, type);
 407     }
 408     else
 409     {
 410         wxLogError( _("Can't load image from file '%s': file does not exist."), filename.c_str() );
 411
 412         return FALSE;
 413     }
 414 #else // !wxUSE_STREAMS
 415     return FALSE;
 416 #endif // wxUSE_STREAMS
 417 }
 418
 419 bool wxImage::LoadFile( const wxString& filename, const wxString& mimetype )
 420 {
 421 #if wxUSE_STREAMS
 422     if (wxFileExists(filename))
 423     {
 424         wxFileInputStream stream(filename);
 425         wxBufferedInputStream bstream( stream );
 426         return LoadFile(bstream, mimetype);
 427     }
 428     else
 429     {
 430         wxLogError( _("Can't load image from file '%s': file does not exist."), filename.c_str() );
 431
 432         return FALSE;
 433     }
 434 #else // !wxUSE_STREAMS
 435     return FALSE;
 436 #endif // wxUSE_STREAMS
 437 }
 438
 439 bool wxImage::SaveFile( const wxString& filename, int type )
 440 {
 441 #if wxUSE_STREAMS
 442     wxFileOutputStream stream(filename);
 443
 444     if ( stream.LastError() == wxStream_NOERROR )
 445     {
 446         wxBufferedOutputStream bstream( stream );
 447         return SaveFile(bstream, type);
 448     }
 449     else
 450 #endif // wxUSE_STREAMS
 451         return FALSE;
 452 }
 453
 454 bool wxImage::SaveFile( const wxString& filename, const wxString& mimetype )
 455 {
 456 #if wxUSE_STREAMS
 457     wxFileOutputStream stream(filename);
 458
 459     if ( stream.LastError() == wxStream_NOERROR )
 460     {
 461         wxBufferedOutputStream bstream( stream );
 462         return SaveFile(bstream, mimetype);
 463     }
 464     else
 465 #endif // wxUSE_STREAMS
 466         return FALSE;
 467 }
 468
 469 bool wxImage::CanRead( const wxString &name )
 470 {
 471 #if wxUSE_STREAMS
 472   wxFileInputStream stream(name);
 473   return CanRead(stream);
 474 #else
 475   return FALSE;
 476 #endif
 477 }
 478
 479 #if wxUSE_STREAMS
 480
 481 bool wxImage::CanRead( wxInputStream &stream )
 482 {
 483   wxList &list=GetHandlers();
 484
 485   for ( wxList::Node *node = list.GetFirst(); node; node = node->GetNext() )
 486     {
 487       wxImageHandler *handler=(wxImageHandler*)node->GetData();
 488       if (handler->CanRead( stream ))
 489         return TRUE;
 490     }
 491
 492   return FALSE;
 493 }
 494
 495 bool wxImage::LoadFile( wxInputStream& stream, long type )
 496 {
 497     UnRef();
 498
 499     m_refData = new wxImageRefData;
 500
 501     wxImageHandler *handler;
 502
 503     if (type==wxBITMAP_TYPE_ANY)
 504     {
 505         wxList &list=GetHandlers();
 506
 507         for ( wxList::Node *node = list.GetFirst(); node; node = node->GetNext() )
 508         {
 509              handler=(wxImageHandler*)node->GetData();
 510              if (handler->CanRead( stream ))
 511                  return handler->LoadFile( this, stream );
 512
 513         }
 514
 515         wxLogWarning( _("No handler found for image type.") );
 516         return FALSE;
 517     }
 518
 519     handler = FindHandler(type);
 520
 521     if (handler == NULL)
 522     {
 523         wxLogWarning( _("No image handler for type %d defined."), type );
 524
 525         return FALSE;
 526     }
 527
 528     return handler->LoadFile( this, stream );
 529 }
 530
 531 bool wxImage::LoadFile( wxInputStream& stream, const wxString& mimetype )
 532 {
 533     UnRef();
 534
 535     m_refData = new wxImageRefData;
 536
 537     wxImageHandler *handler = FindHandlerMime(mimetype);
 538
 539     if (handler == NULL)
 540     {
 541         wxLogWarning( _("No image handler for type %s defined."), mimetype.GetData() );
 542
 543         return FALSE;
 544     }
 545
 546     return handler->LoadFile( this, stream );
 547 }
 548
 549 bool wxImage::SaveFile( wxOutputStream& stream, int type )
 550 {
 551     wxCHECK_MSG( Ok(), FALSE, wxT("invalid image") );
 552
 553     wxImageHandler *handler = FindHandler(type);
 554
 555     if (handler == NULL)
 556     {
 557         wxLogWarning( _("No image handler for type %d defined."), type );
 558
 559         return FALSE;
 560     }
 561
 562     return handler->SaveFile( this, stream );
 563 }
 564
 565 bool wxImage::SaveFile( wxOutputStream& stream, const wxString& mimetype )
 566 {
 567     wxCHECK_MSG( Ok(), FALSE, wxT("invalid image") );
 568
 569     wxImageHandler *handler = FindHandlerMime(mimetype);
 570
 571     if (handler == NULL)
 572     {
 573         wxLogWarning( _("No image handler for type %s defined."), mimetype.GetData() );
 574
 575         return FALSE;
 576     }
 577
 578     return handler->SaveFile( this, stream );
 579 }
 580 #endif // wxUSE_STREAMS
 581
 582 void wxImage::AddHandler( wxImageHandler *handler )
 583 {
 584     // make sure that the memory will be freed at the program end
 585     sm_handlers.DeleteContents(TRUE);
 586
 587     sm_handlers.Append( handler );
 588 }
 589
 590 void wxImage::InsertHandler( wxImageHandler *handler )
 591 {
 592     // make sure that the memory will be freed at the program end
 593     sm_handlers.DeleteContents(TRUE);
 594
 595     sm_handlers.Insert( handler );
 596 }
 597
 598 bool wxImage::RemoveHandler( const wxString& name )
 599 {
 600     wxImageHandler *handler = FindHandler(name);
 601     if (handler)
 602     {
 603         sm_handlers.DeleteObject(handler);
 604         return TRUE;
 605     }
 606     else
 607         return FALSE;
 608 }
 609
 610 wxImageHandler *wxImage::FindHandler( const wxString& name )
 611 {
 612     wxNode *node = sm_handlers.First();
 613     while (node)
 614     {
 615         wxImageHandler *handler = (wxImageHandler*)node->Data();
 616         if (handler->GetName().Cmp(name) == 0) return handler;
 617
 618         node = node->Next();
 619     }
 620     return (wxImageHandler *)NULL;
 621 }
 622
 623 wxImageHandler *wxImage::FindHandler( const wxString& extension, long bitmapType )
 624 {
 625     wxNode *node = sm_handlers.First();
 626     while (node)
 627     {
 628         wxImageHandler *handler = (wxImageHandler*)node->Data();
 629         if ( (handler->GetExtension().Cmp(extension) == 0) &&
 630             (bitmapType == -1 || handler->GetType() == bitmapType) )
 631             return handler;
 632         node = node->Next();
 633     }
 634     return (wxImageHandler*)NULL;
 635 }
 636
 637 wxImageHandler *wxImage::FindHandler( long bitmapType )
 638 {
 639     wxNode *node = sm_handlers.First();
 640     while (node)
 641     {
 642         wxImageHandler *handler = (wxImageHandler *)node->Data();
 643         if (handler->GetType() == bitmapType) return handler;
 644         node = node->Next();
 645     }
 646     return NULL;
 647 }
 648
 649 wxImageHandler *wxImage::FindHandlerMime( const wxString& mimetype )
 650 {
 651     wxNode *node = sm_handlers.First();
 652     while (node)
 653     {
 654         wxImageHandler *handler = (wxImageHandler *)node->Data();
 655         if (handler->GetMimeType().IsSameAs(mimetype, FALSE)) return handler;
 656         node = node->Next();
 657     }
 658     return NULL;
 659 }
 660
 661 void wxImage::InitStandardHandlers()
 662 {
 663   AddHandler( new wxBMPHandler );
 664 }
 665
 666 void wxImage::CleanUpHandlers()
 667 {
 668     wxNode *node = sm_handlers.First();
 669     while (node)
 670     {
 671         wxImageHandler *handler = (wxImageHandler *)node->Data();
 672         wxNode *next = node->Next();
 673         delete handler;
 674         delete node;
 675         node = next;
 676     }
 677 }
 678
 679 //-----------------------------------------------------------------------------
 680 // wxImageHandler
 681 //-----------------------------------------------------------------------------
 682
 683 IMPLEMENT_ABSTRACT_CLASS(wxImageHandler,wxObject)
 684
 685 #if wxUSE_STREAMS
 686 bool wxImageHandler::LoadFile( wxImage *WXUNUSED(image), wxInputStream& WXUNUSED(stream), bool WXUNUSED(verbose), int WXUNUSED(index) )
 687 {
 688     return FALSE;
 689 }
 690
 691 bool wxImageHandler::SaveFile( wxImage *WXUNUSED(image), wxOutputStream& WXUNUSED(stream), bool WXUNUSED(verbose) )
 692 {
 693     return FALSE;
 694 }
 695
 696 int wxImageHandler::GetImageCount( wxInputStream& WXUNUSED(stream) )
 697 {
 698     return 1;
 699 }
 700
 701 bool wxImageHandler::CanRead( const wxString& name )
 702 {
 703     if (wxFileExists(name))
 704     {
 705         wxFileInputStream stream(name);
 706         return CanRead(stream);
 707     }
 708
 709     else {
 710         wxLogError( _("Can't check image format of file '%s': file does not exist."), name.c_str() );
 711
 712         return FALSE;
 713     }
 714 //    return FALSE;
 715 }
 716
 717 #endif // wxUSE_STREAMS
 718
 719 //-----------------------------------------------------------------------------
 720 // MSW conversion routines
 721 //-----------------------------------------------------------------------------
 722
 723 #ifdef __WXMSW__
 724
 725 wxBitmap wxImage::ConvertToBitmap() const
 726 {
 727     if ( !Ok() )
 728         return wxNullBitmap;
 729
 730     // sizeLimit is the MS upper limit for the DIB size
 731 #ifdef  WIN32
 732     int sizeLimit = 1024*768*3;
 733 #else
 734     int sizeLimit = 0x7fff ;
 735 #endif
 736
 737     // width and height of the device-dependent bitmap
 738     int width = GetWidth();
 739     int bmpHeight = GetHeight();
 740
 741     // calc the number of bytes per scanline and padding
 742     int bytePerLine = width*3;
 743     int sizeDWORD = sizeof( DWORD );
 744     int lineBoundary = bytePerLine % sizeDWORD;
 745     int padding = 0;
 746     if( lineBoundary > 0 )
 747     {
 748         padding = sizeDWORD - lineBoundary;
 749         bytePerLine += padding;
 750     }
 751     // calc the number of DIBs and heights of DIBs
 752     int numDIB = 1;
 753     int hRemain = 0;
 754     int height = sizeLimit/bytePerLine;
 755     if( height >= bmpHeight )
 756         height = bmpHeight;
 757     else
 758     {
 759         numDIB =  bmpHeight / height;
 760         hRemain = bmpHeight % height;
 761         if( hRemain >0 )  numDIB++;
 762     }
 763
 764     // set bitmap parameters
 765     wxBitmap bitmap;
 766     wxCHECK_MSG( Ok(), bitmap, wxT("invalid image") );
 767     bitmap.SetWidth( width );
 768     bitmap.SetHeight( bmpHeight );
 769     bitmap.SetDepth( wxDisplayDepth() );
 770
 771     // create a DIB header
 772     int headersize = sizeof(BITMAPINFOHEADER);
 773     BITMAPINFO *lpDIBh = (BITMAPINFO *) malloc( headersize );
 774     wxCHECK_MSG( lpDIBh, bitmap, wxT("could not allocate memory for DIB header") );
 775     // Fill in the DIB header
 776     lpDIBh->bmiHeader.biSize = headersize;
 777     lpDIBh->bmiHeader.biWidth = (DWORD)width;
 778     lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
 779     lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
 780     //   the general formula for biSizeImage:
 781     //      ( ( ( ((DWORD)width*24) +31 ) & ~31 ) >> 3 ) * height;
 782     lpDIBh->bmiHeader.biPlanes = 1;
 783     lpDIBh->bmiHeader.biBitCount = 24;
 784     lpDIBh->bmiHeader.biCompression = BI_RGB;
 785     lpDIBh->bmiHeader.biClrUsed = 0;
 786     // These seem not really needed for our purpose here.
 787     lpDIBh->bmiHeader.biClrImportant = 0;
 788     lpDIBh->bmiHeader.biXPelsPerMeter = 0;
 789     lpDIBh->bmiHeader.biYPelsPerMeter = 0;
 790     // memory for DIB data
 791     unsigned char *lpBits;
 792     lpBits = (unsigned char *)malloc( lpDIBh->bmiHeader.biSizeImage );
 793     if( !lpBits )
 794     {
 795         wxFAIL_MSG( wxT("could not allocate memory for DIB") );
 796         free( lpDIBh );
 797         return bitmap;
 798     }
 799
 800     // create and set the device-dependent bitmap
 801     HDC hdc = ::GetDC(NULL);
 802     HDC memdc = ::CreateCompatibleDC( hdc );
 803     HBITMAP hbitmap;
 804     hbitmap = ::CreateCompatibleBitmap( hdc, width, bmpHeight );
 805     ::SelectObject( memdc, hbitmap);
 806
 807     // copy image data into DIB data and then into DDB (in a loop)
 808     unsigned char *data = GetData();
 809     int i, j, n;
 810     int origin = 0;
 811     unsigned char *ptdata = data;
 812     unsigned char *ptbits;
 813
 814     for( n=0; n<numDIB; n++ )
 815     {
 816         if( numDIB > 1 && n == numDIB-1 && hRemain > 0 )
 817         {
 818             // redefine height and size of the (possibly) last smaller DIB
 819             // memory is not reallocated
 820             height = hRemain;
 821             lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
 822             lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
 823         }
 824         ptbits = lpBits;
 825
 826         for( j=0; j<height; j++ )
 827         {
 828             for( i=0; i<width; i++ )
 829             {
 830                 *(ptbits++) = *(ptdata+2);
 831                 *(ptbits++) = *(ptdata+1);
 832                 *(ptbits++) = *(ptdata  );
 833                 ptdata += 3;
 834             }
 835             for( i=0; i< padding; i++ )   *(ptbits++) = 0;
 836         }
 837         ::StretchDIBits( memdc, 0, origin, width, height,\
 838             0, 0, width, height, lpBits, lpDIBh, DIB_RGB_COLORS, SRCCOPY);
 839         origin += height;
 840         // if numDIB = 1,  lines below can also be used
 841         //    hbitmap = CreateDIBitmap( hdc, &(lpDIBh->bmiHeader), CBM_INIT, lpBits, lpDIBh, DIB_RGB_COLORS );
 842         // The above line is equivalent to the following two lines.
 843         //    hbitmap = ::CreateCompatibleBitmap( hdc, width, height );
 844         //    ::SetDIBits( hdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS);
 845         // or the following lines
 846         //    hbitmap = ::CreateCompatibleBitmap( hdc, width, height );
 847         //    HDC memdc = ::CreateCompatibleDC( hdc );
 848         //    ::SelectObject( memdc, hbitmap);
 849         //    ::SetDIBitsToDevice( memdc, 0, 0, width, height,
 850         //            0, 0, 0, height, (void *)lpBits, lpDIBh, DIB_RGB_COLORS);
 851         //    ::SelectObject( memdc, 0 );
 852         //    ::DeleteDC( memdc );
 853     }
 854     bitmap.SetHBITMAP( (WXHBITMAP) hbitmap );
 855
 856     // similarly, created an mono-bitmap for the possible mask
 857     if( HasMask() )
 858     {
 859         hbitmap = ::CreateBitmap( (WORD)width, (WORD)bmpHeight, 1, 1, NULL );
 860         ::SelectObject( memdc, hbitmap);
 861         if( numDIB == 1 )   height = bmpHeight;
 862         else                height = sizeLimit/bytePerLine;
 863         lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
 864         lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
 865         origin = 0;
 866         unsigned char r = GetMaskRed();
 867         unsigned char g = GetMaskGreen();
 868         unsigned char b = GetMaskBlue();
 869         unsigned char zero = 0, one = 255;
 870         ptdata = data;
 871         for( n=0; n<numDIB; n++ )
 872         {
 873             if( numDIB > 1 && n == numDIB - 1 && hRemain > 0 )
 874             {
 875                 // redefine height and size of the (possibly) last smaller DIB
 876                 // memory is not reallocated
 877                 height = hRemain;
 878                 lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
 879                 lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
 880             }
 881             ptbits = lpBits;
 882             for( int j=0; j<height; j++ )
 883             {
 884                 for(i=0; i<width; i++ )
 885                 {
 886                     if( (*(ptdata++)!=r) | (*(ptdata++)!=g) | (*(ptdata++)!=b) )
 887                     {
 888                         *(ptbits++) = one;
 889                         *(ptbits++) = one;
 890                         *(ptbits++) = one;
 891                     }
 892                     else
 893                     {
 894                         *(ptbits++) = zero;
 895                         *(ptbits++) = zero;
 896                         *(ptbits++) = zero;
 897                     }
 898                 }
 899                 for( i=0; i< padding; i++ )   *(ptbits++) = zero;
 900             }
 901             ::StretchDIBits( memdc, 0, origin, width, height,\
 902                 0, 0, width, height, lpBits, lpDIBh, DIB_RGB_COLORS, SRCCOPY);
 903             origin += height;
 904         }
 905         // create a wxMask object
 906         wxMask *mask = new wxMask();
 907         mask->SetMaskBitmap( (WXHBITMAP) hbitmap );
 908         bitmap.SetMask( mask );
 909         // It will be deleted when the wxBitmap object is deleted (as of 01/1999)
 910         /* The following can also be used but is slow to run
 911         wxColour colour( GetMaskRed(), GetMaskGreen(), GetMaskBlue());
 912         wxMask *mask = new wxMask( bitmap, colour );
 913         bitmap.SetMask( mask );
 914         */
 915     }
 916
 917     // free allocated resources
 918     ::SelectObject( memdc, 0 );
 919     ::DeleteDC( memdc );
 920     ::ReleaseDC(NULL, hdc);
 921     free(lpDIBh);
 922     free(lpBits);
 923
 924 #if WXWIN_COMPATIBILITY_2
 925     // check the wxBitmap object
 926     bitmap.GetBitmapData()->SetOk();
 927 #endif // WXWIN_COMPATIBILITY_2
 928
 929     return bitmap;
 930 }
 931
 932 wxImage::wxImage( const wxBitmap &bitmap )
 933 {
 934     // check the bitmap
 935     if( !bitmap.Ok() )
 936     {
 937         wxFAIL_MSG( wxT("invalid bitmap") );
 938         return;
 939     }
 940
 941     // create an wxImage object
 942     int width = bitmap.GetWidth();
 943     int height = bitmap.GetHeight();
 944     Create( width, height );
 945     unsigned char *data = GetData();
 946     if( !data )
 947     {
 948         wxFAIL_MSG( wxT("could not allocate data for image") );
 949         return;
 950     }
 951
 952     // calc the number of bytes per scanline and padding in the DIB
 953     int bytePerLine = width*3;
 954     int sizeDWORD = sizeof( DWORD );
 955     int lineBoundary =  bytePerLine % sizeDWORD;
 956     int padding = 0;
 957     if( lineBoundary > 0 )
 958     {
 959         padding = sizeDWORD - lineBoundary;
 960         bytePerLine += padding;
 961     }
 962
 963     // create a DIB header
 964     int headersize = sizeof(BITMAPINFOHEADER);
 965     BITMAPINFO *lpDIBh = (BITMAPINFO *) malloc( headersize );
 966     if( !lpDIBh )
 967     {
 968         wxFAIL_MSG( wxT("could not allocate data for DIB header") );
 969         free( data );
 970         return;
 971     }
 972     // Fill in the DIB header
 973     lpDIBh->bmiHeader.biSize = headersize;
 974     lpDIBh->bmiHeader.biWidth = width;
 975     lpDIBh->bmiHeader.biHeight = -height;
 976     lpDIBh->bmiHeader.biSizeImage = bytePerLine * height;
 977     lpDIBh->bmiHeader.biPlanes = 1;
 978     lpDIBh->bmiHeader.biBitCount = 24;
 979     lpDIBh->bmiHeader.biCompression = BI_RGB;
 980     lpDIBh->bmiHeader.biClrUsed = 0;
 981     // These seem not really needed for our purpose here.
 982     lpDIBh->bmiHeader.biClrImportant = 0;
 983     lpDIBh->bmiHeader.biXPelsPerMeter = 0;
 984     lpDIBh->bmiHeader.biYPelsPerMeter = 0;
 985     // memory for DIB data
 986     unsigned char *lpBits;
 987     lpBits = (unsigned char *) malloc( lpDIBh->bmiHeader.biSizeImage );
 988     if( !lpBits )
 989     {
 990         wxFAIL_MSG( wxT("could not allocate data for DIB") );
 991         free( data );
 992         free( lpDIBh );
 993         return;
 994     }
 995
 996     // copy data from the device-dependent bitmap to the DIB
 997     HDC hdc = ::GetDC(NULL);
 998     HBITMAP hbitmap;
 999     hbitmap = (HBITMAP) bitmap.GetHBITMAP();
1000     ::GetDIBits( hdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
1001
1002     // copy DIB data into the wxImage object
1003     int i, j;
1004     unsigned char *ptdata = data;
1005     unsigned char *ptbits = lpBits;
1006     for( i=0; i<height; i++ )
1007     {
1008         for( j=0; j<width; j++ )
1009         {
1010             *(ptdata++) = *(ptbits+2);
1011             *(ptdata++) = *(ptbits+1);
1012             *(ptdata++) = *(ptbits  );
1013             ptbits += 3;
1014         }
1015         ptbits += padding;
1016     }
1017
1018     // similarly, set data according to the possible mask bitmap
1019     if( bitmap.GetMask() && bitmap.GetMask()->GetMaskBitmap() )
1020     {
1021         hbitmap = (HBITMAP) bitmap.GetMask()->GetMaskBitmap();
1022         // memory DC created, color set, data copied, and memory DC deleted
1023         HDC memdc = ::CreateCompatibleDC( hdc );
1024         ::SetTextColor( memdc, RGB( 0, 0, 0 ) );
1025         ::SetBkColor( memdc, RGB( 255, 255, 255 ) );
1026         ::GetDIBits( memdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
1027         ::DeleteDC( memdc );
1028         // background color set to RGB(16,16,16) in consistent with wxGTK
1029         unsigned char r=16, g=16, b=16;
1030         ptdata = data;
1031         ptbits = lpBits;
1032         for( i=0; i<height; i++ )
1033         {
1034             for( j=0; j<width; j++ )
1035             {
1036                 if( *ptbits != 0 )
1037                     ptdata += 3;
1038                 else
1039                 {
1040                     *(ptdata++)  = r;
1041                     *(ptdata++)  = g;
1042                     *(ptdata++)  = b;
1043                 }
1044                 ptbits += 3;
1045             }
1046             ptbits += padding;
1047         }
1048         SetMaskColour( r, g, b );
1049         SetMask( TRUE );
1050     }
1051     else
1052     {
1053         SetMask( FALSE );
1054     }
1055     // free allocated resources
1056     ::ReleaseDC(NULL, hdc);
1057     free(lpDIBh);
1058     free(lpBits);
1059 }
1060
1061 #endif
1062
1063 #ifdef __WXMAC__
1064
1065 #include <PictUtils.h>
1066
1067 extern CTabHandle wxMacCreateColorTable( int numColors ) ;
1068 extern void wxMacDestroyColorTable( CTabHandle colors ) ;
1069 extern void wxMacSetColorTableEntry( CTabHandle newColors , int index , int red , int green ,  int blue ) ;
1070 extern GWorldPtr wxMacCreateGWorld( int height , int width , int depth ) ;
1071 extern void wxMacDestroyGWorld( GWorldPtr gw ) ;
1072
1073 wxBitmap wxImage::ConvertToBitmap() const
1074 {
1075     // width and height of the device-dependent bitmap
1076     int width = GetWidth();
1077     int height = GetHeight();
1078
1079     // Create picture
1080
1081     wxBitmap bitmap( width , height , wxDisplayDepth() ) ;
1082
1083     // Create mask
1084
1085     if (HasMask())
1086     {
1087         /*
1088         unsigned char *mask_data = (unsigned char*)malloc( ((width >> 3)+8) * height );
1089
1090         mask_image =  gdk_image_new_bitmap( gdk_visual_get_system(), mask_data, width, height );
1091
1092         wxMask *mask = new wxMask();
1093         mask->m_bitmap = gdk_pixmap_new( (GdkWindow*)&gdk_root_parent, width, height, 1 );
1094
1095         bitmap.SetMask( mask );
1096        */
1097     }
1098
1099     // Render
1100
1101     int r_mask = GetMaskRed();
1102     int g_mask = GetMaskGreen();
1103     int b_mask = GetMaskBlue();
1104
1105                 CGrafPtr        origPort ;
1106                 GDHandle        origDevice ;
1107
1108                 GetGWorld( &origPort , &origDevice ) ;
1109                 SetGWorld( bitmap.GetHBITMAP() , NULL ) ;
1110
1111     register unsigned char* data = GetData();
1112
1113     int index = 0;
1114     for (int y = 0; y < height; y++)
1115     {
1116 #if 0
1117         unsigned char lastr = 0 ;
1118         unsigned char lastg = 0 ;
1119         unsigned char lastb = 0 ;
1120         RGBColor lastcolor ;
1121
1122                 MoveTo( 0 , y ) ;
1123         for (int x = 0; x < width; x++)
1124         {
1125                 unsigned char r = data[index++];
1126                 unsigned char g = data[index++];
1127                 unsigned char b = data[index++];
1128
1129                         if ( r != lastr || g != lastg || b != lastb )
1130                         {
1131                         lastcolor.red = ( lastr  << 8 ) + lastr ;
1132                         lastcolor.green = ( lastg << 8 ) + lastg ;
1133                         lastcolor.blue = ( lastb << 8 ) + lastb ;
1134                                 RGBForeColor( &lastcolor ) ;
1135                                 LineTo( x , y ) ;
1136                                 lastr = r ;
1137                                 lastg = g ;
1138                                 lastb = b ;
1139                         }
1140         } // for width
1141                 lastcolor.red = ( lastr  << 8 ) + lastr ;
1142                 lastcolor.green = ( lastg << 8 ) + lastg ;
1143                 lastcolor.blue = ( lastb << 8 ) + lastb ;
1144                 RGBForeColor( &lastcolor ) ;
1145         LineTo( width - 1 , y ) ;
1146 #else
1147         for (int x = 0; x < width; x++)
1148         {
1149                 unsigned char r = data[index++];
1150                 unsigned char g = data[index++];
1151                 unsigned char b = data[index++];
1152                 RGBColor color ;
1153                 color.red = ( r  << 8 ) + r ;
1154                 color.green = ( g << 8 ) + g ;
1155                 color.blue = ( b << 8 ) + b ;
1156                 SetCPixel( x , y , &color ) ;
1157         }
1158 #endif
1159     }  // for height
1160
1161         SetGWorld( origPort , origDevice ) ;
1162
1163     return bitmap;
1164
1165 }
1166
1167 wxImage::wxImage( const wxBitmap &bitmap )
1168 {
1169     // check the bitmap
1170     if( !bitmap.Ok() )
1171     {
1172         wxFAIL_MSG( "invalid bitmap" );
1173         return;
1174     }
1175
1176     // create an wxImage object
1177     int width = bitmap.GetWidth();
1178     int height = bitmap.GetHeight();
1179     Create( width, height );
1180     /*
1181     unsigned char *data = GetData();
1182     if( !data )
1183     {
1184         wxFAIL_MSG( "could not allocate data for image" );
1185         return;
1186     }
1187
1188     // calc the number of bytes per scanline and padding in the DIB
1189     int bytePerLine = width*3;
1190     int sizeDWORD = sizeof( DWORD );
1191     div_t lineBoundary = div( bytePerLine, sizeDWORD );
1192     int padding = 0;
1193     if( lineBoundary.rem > 0 )
1194     {
1195         padding = sizeDWORD - lineBoundary.rem;
1196         bytePerLine += padding;
1197     }
1198
1199     // create a DIB header
1200     int headersize = sizeof(BITMAPINFOHEADER);
1201     LPBITMAPINFO lpDIBh = (BITMAPINFO *) malloc( headersize );
1202     if( !lpDIBh )
1203     {
1204         wxFAIL_MSG( "could not allocate data for DIB header" );
1205         free( data );
1206         return;
1207     }
1208     // Fill in the DIB header
1209     lpDIBh->bmiHeader.biSize = headersize;
1210     lpDIBh->bmiHeader.biWidth = width;
1211     lpDIBh->bmiHeader.biHeight = -height;
1212     lpDIBh->bmiHeader.biSizeImage = bytePerLine * height;
1213     lpDIBh->bmiHeader.biPlanes = 1;
1214     lpDIBh->bmiHeader.biBitCount = 24;
1215     lpDIBh->bmiHeader.biCompression = BI_RGB;
1216     lpDIBh->bmiHeader.biClrUsed = 0;
1217     // These seem not really needed for our purpose here.
1218     lpDIBh->bmiHeader.biClrImportant = 0;
1219     lpDIBh->bmiHeader.biXPelsPerMeter = 0;
1220     lpDIBh->bmiHeader.biYPelsPerMeter = 0;
1221     // memory for DIB data
1222     unsigned char *lpBits;
1223     lpBits = (unsigned char *) malloc( lpDIBh->bmiHeader.biSizeImage );
1224     if( !lpBits )
1225     {
1226         wxFAIL_MSG( "could not allocate data for DIB" );
1227         free( data );
1228         free( lpDIBh );
1229         return;
1230     }
1231
1232     // copy data from the device-dependent bitmap to the DIB
1233     HDC hdc = ::GetDC(NULL);
1234     HBITMAP hbitmap;
1235     hbitmap = (HBITMAP) bitmap.GetHBITMAP();
1236     ::GetDIBits( hdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
1237
1238     // copy DIB data into the wxImage object
1239     int i, j;
1240     unsigned char *ptdata = data;
1241     unsigned char *ptbits = lpBits;
1242     for( i=0; i<height; i++ )
1243     {
1244         for( j=0; j<width; j++ )
1245         {
1246             *(ptdata++) = *(ptbits+2);
1247             *(ptdata++) = *(ptbits+1);
1248             *(ptdata++) = *(ptbits  );
1249             ptbits += 3;
1250         }
1251         ptbits += padding;
1252     }
1253
1254     // similarly, set data according to the possible mask bitmap
1255     if( bitmap.GetMask() && bitmap.GetMask()->GetMaskBitmap() )
1256     {
1257         hbitmap = (HBITMAP) bitmap.GetMask()->GetMaskBitmap();
1258         // memory DC created, color set, data copied, and memory DC deleted
1259         HDC memdc = ::CreateCompatibleDC( hdc );
1260         ::SetTextColor( memdc, RGB( 0, 0, 0 ) );
1261         ::SetBkColor( memdc, RGB( 255, 255, 255 ) );
1262         ::GetDIBits( memdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
1263         ::DeleteDC( memdc );
1264         // background color set to RGB(16,16,16) in consistent with wxGTK
1265         unsigned char r=16, g=16, b=16;
1266         ptdata = data;
1267         ptbits = lpBits;
1268         for( i=0; i<height; i++ )
1269         {
1270             for( j=0; j<width; j++ )
1271             {
1272                 if( *ptbits != 0 )
1273                     ptdata += 3;
1274                 else
1275                 {
1276                     *(ptdata++)  = r;
1277                     *(ptdata++)  = g;
1278                     *(ptdata++)  = b;
1279                 }
1280                 ptbits += 3;
1281             }
1282             ptbits += padding;
1283         }
1284         SetMaskColour( r, g, b );
1285         SetMask( TRUE );
1286     }
1287     else
1288     {
1289         SetMask( FALSE );
1290     }
1291     // free allocated resources
1292     ::ReleaseDC(NULL, hdc);
1293     free(lpDIBh);
1294     free(lpBits);
1295     */
1296 }
1297
1298 #endif
1299
1300 //-----------------------------------------------------------------------------
1301 // GTK conversion routines
1302 //-----------------------------------------------------------------------------
1303
1304 #ifdef __WXGTK__
1305
1306 #include <gtk/gtk.h>
1307 #include <gdk/gdk.h>
1308 #include <gdk/gdkx.h>
1309
1310 #if (GTK_MINOR_VERSION > 0)
1311 #include <gdk/gdkrgb.h>
1312 #endif
1313
1314 wxBitmap wxImage::ConvertToBitmap() const
1315 {
1316     wxBitmap bitmap;
1317
1318     wxCHECK_MSG( Ok(), bitmap, wxT("invalid image") );
1319
1320     int width = GetWidth();
1321     int height = GetHeight();
1322
1323     bitmap.SetHeight( height );
1324     bitmap.SetWidth( width );
1325
1326     bitmap.SetPixmap( gdk_pixmap_new( (GdkWindow*)&gdk_root_parent, width, height, -1 ) );
1327
1328      // Retrieve depth
1329
1330     GdkVisual *visual = gdk_window_get_visual( bitmap.GetPixmap() );
1331     if (visual == NULL) visual = gdk_visual_get_system();
1332     int bpp = visual->depth;
1333
1334     bitmap.SetDepth( bpp );
1335
1336     if ((bpp == 16) && (visual->red_mask != 0xf800)) bpp = 15;
1337     if (bpp < 8) bpp = 8;
1338
1339 #if (GTK_MINOR_VERSION > 0)
1340
1341     if (!HasMask() && (bpp > 8))
1342     {
1343         static bool s_hasInitialized = FALSE;
1344
1345         if (!s_hasInitialized)
1346         {
1347             gdk_rgb_init();
1348             s_hasInitialized = TRUE;
1349         }
1350
1351         GdkGC *gc = gdk_gc_new( bitmap.GetPixmap() );
1352
1353         gdk_draw_rgb_image( bitmap.GetPixmap(),
1354                             gc,
1355                             0, 0,
1356                             width, height,
1357                             GDK_RGB_DITHER_NONE,
1358                             GetData(),
1359                             width*3 );
1360
1361         gdk_gc_unref( gc );
1362
1363         return bitmap;
1364     }
1365
1366 #endif
1367
1368     // Create picture image
1369
1370     GdkImage *data_image =
1371         gdk_image_new( GDK_IMAGE_FASTEST, gdk_visual_get_system(), width, height );
1372
1373     // Create mask image
1374
1375     GdkImage *mask_image = (GdkImage*) NULL;
1376
1377     if (HasMask())
1378     {
1379         unsigned char *mask_data = (unsigned char*)malloc( ((width >> 3)+8) * height );
1380
1381         mask_image =  gdk_image_new_bitmap( gdk_visual_get_system(), mask_data, width, height );
1382
1383         wxMask *mask = new wxMask();
1384         mask->m_bitmap = gdk_pixmap_new( (GdkWindow*)&gdk_root_parent, width, height, 1 );
1385
1386         bitmap.SetMask( mask );
1387     }
1388
1389     // Render
1390
1391     enum byte_order { RGB, RBG, BRG, BGR, GRB, GBR };
1392     byte_order b_o = RGB;
1393
1394     if (bpp >= 24)
1395     {
1396         GdkVisual *visual = gdk_visual_get_system();
1397         if ((visual->red_mask > visual->green_mask) && (visual->green_mask > visual->blue_mask))      b_o = RGB;
1398         else if ((visual->red_mask > visual->blue_mask) && (visual->blue_mask > visual->green_mask))  b_o = RGB;
1399         else if ((visual->blue_mask > visual->red_mask) && (visual->red_mask > visual->green_mask))   b_o = BRG;
1400         else if ((visual->blue_mask > visual->green_mask) && (visual->green_mask > visual->red_mask)) b_o = BGR;
1401         else if ((visual->green_mask > visual->red_mask) && (visual->red_mask > visual->blue_mask))   b_o = GRB;
1402         else if ((visual->green_mask > visual->blue_mask) && (visual->blue_mask > visual->red_mask))  b_o = GBR;
1403     }
1404
1405     int r_mask = GetMaskRed();
1406     int g_mask = GetMaskGreen();
1407     int b_mask = GetMaskBlue();
1408
1409     unsigned char* data = GetData();
1410
1411     int index = 0;
1412     for (int y = 0; y < height; y++)
1413     {
1414         for (int x = 0; x < width; x++)
1415         {
1416             int r = data[index];
1417             index++;
1418             int g = data[index];
1419             index++;
1420             int b = data[index];
1421             index++;
1422
1423             if (HasMask())
1424             {
1425                 if ((r == r_mask) && (b == b_mask) && (g == g_mask))
1426                     gdk_image_put_pixel( mask_image, x, y, 1 );
1427                 else
1428                     gdk_image_put_pixel( mask_image, x, y, 0 );
1429             }
1430
1431             if (HasMask())
1432             {
1433                 if ((r == r_mask) && (b == b_mask) && (g == g_mask))
1434                     gdk_image_put_pixel( mask_image, x, y, 1 );
1435                 else
1436                     gdk_image_put_pixel( mask_image, x, y, 0 );
1437             }
1438
1439             switch (bpp)
1440             {
1441             case 8:
1442                 {
1443                     int pixel = -1;
1444                     if (wxTheApp->m_colorCube)
1445                     {
1446                         pixel = wxTheApp->m_colorCube[ ((r & 0xf8) << 7) + ((g & 0xf8) << 2) + ((b & 0xf8) >> 3) ];
1447                     }
1448                     else
1449                     {
1450                         GdkColormap *cmap = gtk_widget_get_default_colormap();
1451                         GdkColor *colors = cmap->colors;
1452                         int max = 3 * (65536);
1453
1454                         for (int i = 0; i < cmap->size; i++)
1455                         {
1456                             int rdiff = (r << 8) - colors[i].red;
1457                             int gdiff = (g << 8) - colors[i].green;
1458                             int bdiff = (b << 8) - colors[i].blue;
1459                             int sum = ABS (rdiff) + ABS (gdiff) + ABS (bdiff);
1460                             if (sum < max) { pixel = i; max = sum; }
1461                         }
1462                     }
1463
1464                     gdk_image_put_pixel( data_image, x, y, pixel );
1465
1466                     break;
1467                 }
1468             case 15:
1469                 {
1470                     guint32 pixel = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
1471                     gdk_image_put_pixel( data_image, x, y, pixel );
1472                     break;
1473                 }
1474             case 16:
1475                 {
1476                     guint32 pixel = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
1477                     gdk_image_put_pixel( data_image, x, y, pixel );
1478                     break;
1479                 }
1480             case 32:
1481             case 24:
1482                 {
1483                     guint32 pixel = 0;
1484                     switch (b_o)
1485                     {
1486                     case RGB: pixel = (r << 16) | (g << 8) | b; break;
1487                     case RBG: pixel = (r << 16) | (b << 8) | g; break;
1488                     case BRG: pixel = (b << 16) | (r << 8) | g; break;
1489                     case BGR: pixel = (b << 16) | (g << 8) | r; break;
1490                     case GRB: pixel = (g << 16) | (r << 8) | b; break;
1491                     case GBR: pixel = (g << 16) | (b << 8) | r; break;
1492                     }
1493                     gdk_image_put_pixel( data_image, x, y, pixel );
1494                 }
1495             default: break;
1496             }
1497         } // for
1498     }  // for
1499
1500     // Blit picture
1501
1502     GdkGC *data_gc = gdk_gc_new( bitmap.GetPixmap() );
1503
1504     gdk_draw_image( bitmap.GetPixmap(), data_gc, data_image, 0, 0, 0, 0, width, height );
1505
1506     gdk_image_destroy( data_image );
1507     gdk_gc_unref( data_gc );
1508
1509     // Blit mask
1510
1511     if (HasMask())
1512     {
1513         GdkGC *mask_gc = gdk_gc_new( bitmap.GetMask()->GetBitmap() );
1514
1515         gdk_draw_image( bitmap.GetMask()->GetBitmap(), mask_gc, mask_image, 0, 0, 0, 0, width, height );
1516
1517         gdk_image_destroy( mask_image );
1518         gdk_gc_unref( mask_gc );
1519     }
1520
1521     return bitmap;
1522 }
1523
1524 wxImage::wxImage( const wxBitmap &bitmap )
1525 {
1526     wxCHECK_RET( bitmap.Ok(), wxT("invalid bitmap") );
1527
1528     GdkImage *gdk_image = (GdkImage*) NULL;
1529     if (bitmap.GetPixmap())
1530     {
1531         gdk_image = gdk_image_get( bitmap.GetPixmap(),
1532             0, 0,
1533             bitmap.GetWidth(), bitmap.GetHeight() );
1534     } else
1535     if (bitmap.GetBitmap())
1536     {
1537         gdk_image = gdk_image_get( bitmap.GetBitmap(),
1538             0, 0,
1539             bitmap.GetWidth(), bitmap.GetHeight() );
1540     } else
1541     {
1542         wxFAIL_MSG( wxT("Ill-formed bitmap") );
1543     }
1544
1545     wxCHECK_RET( gdk_image, wxT("couldn't create image") );
1546
1547     Create( bitmap.GetWidth(), bitmap.GetHeight() );
1548     char unsigned *data = GetData();
1549
1550     if (!data)
1551     {
1552         gdk_image_destroy( gdk_image );
1553         wxFAIL_MSG( wxT("couldn't create image") );
1554         return;
1555     }
1556
1557     GdkImage *gdk_image_mask = (GdkImage*) NULL;
1558     if (bitmap.GetMask())
1559     {
1560         gdk_image_mask = gdk_image_get( bitmap.GetMask()->GetBitmap(),
1561             0, 0,
1562             bitmap.GetWidth(), bitmap.GetHeight() );
1563
1564         SetMaskColour( 16, 16, 16 );  // anything unlikely and dividable
1565     }
1566
1567     int bpp = -1;
1568     if (bitmap.GetPixmap())
1569     {
1570         GdkVisual *visual = gdk_window_get_visual( bitmap.GetPixmap() );
1571
1572         if (visual == NULL) visual = gdk_window_get_visual( (GdkWindow*) &gdk_root_parent );
1573         bpp = visual->depth;
1574         if ((bpp == 16) && (visual->red_mask != 0xf800)) bpp = 15;
1575     }
1576     if (bitmap.GetBitmap())
1577     {
1578         bpp = 1;
1579     }
1580
1581     GdkColormap *cmap = gtk_widget_get_default_colormap();
1582
1583     long pos = 0;
1584     for (int j = 0; j < bitmap.GetHeight(); j++)
1585     {
1586         for (int i = 0; i < bitmap.GetWidth(); i++)
1587         {
1588             wxInt32 pixel = gdk_image_get_pixel( gdk_image, i, j );
1589             if (bpp == 1)
1590             {
1591                 if (pixel == 0)
1592                 {
1593                     data[pos] = 0;
1594                     data[pos+1] = 0;
1595                     data[pos+2] = 0;
1596                 }
1597                 else
1598                 {
1599                     data[pos] = 255;
1600                     data[pos+1] = 255;
1601                     data[pos+2] = 255;
1602                 }
1603             } else if (bpp <= 8)
1604             {
1605                 data[pos] = cmap->colors[pixel].red >> 8;
1606                 data[pos+1] = cmap->colors[pixel].green >> 8;
1607                 data[pos+2] = cmap->colors[pixel].blue >> 8;
1608             } else if (bpp == 15)
1609             {
1610 #if (wxBYTE_ORDER == wxBIG_ENDIAN)
1611                 // ?
1612 #endif
1613                 data[pos] = (pixel >> 7) & 0xf8;
1614                 data[pos+1] = (pixel >> 2) & 0xf8;
1615                 data[pos+2] = (pixel << 3) & 0xf8;
1616             } else if (bpp == 16)
1617             {
1618 #if (wxBYTE_ORDER == wxBIG_ENDIAN)
1619                 // ?
1620 #endif
1621                 data[pos] = (pixel >> 8) & 0xf8;
1622                 data[pos+1] = (pixel >> 3) & 0xfc;
1623                 data[pos+2] = (pixel << 3) & 0xf8;
1624             } else
1625             {
1626 #if (wxBYTE_ORDER == wxBIG_ENDIAN)
1627                 data[pos] = (pixel) & 0xff;             // Red
1628                 data[pos+1] = (pixel >> 8) & 0xff;      // Green
1629                 data[pos+2] = (pixel >> 16) & 0xff;     // Blue
1630 #else
1631                 data[pos] = (pixel >> 16) & 0xff;
1632                 data[pos+1] = (pixel >> 8) & 0xff;
1633                 data[pos+2] = pixel & 0xff;
1634 #endif
1635             }
1636
1637             if (gdk_image_mask)
1638             {
1639                 int mask_pixel = gdk_image_get_pixel( gdk_image_mask, i, j );
1640                 if (mask_pixel == 0)
1641                 {
1642                     data[pos] = 16;
1643                     data[pos+1] = 16;
1644                     data[pos+2] = 16;
1645                 }
1646             }
1647
1648             pos += 3;
1649         }
1650     }
1651
1652     gdk_image_destroy( gdk_image );
1653     if (gdk_image_mask) gdk_image_destroy( gdk_image_mask );
1654 }
1655
1656 #endif
1657
1658 //-----------------------------------------------------------------------------
1659 // Motif conversion routines
1660 //-----------------------------------------------------------------------------
1661
1662 #ifdef __WXMOTIF__
1663 #ifdef __VMS__
1664 #pragma message disable nosimpint
1665 #endif
1666 #include <Xm/Xm.h>
1667 #ifdef __VMS__
1668 #pragma message enable nosimpint
1669 #endif
1670 #include "wx/utils.h"
1671 #include <math.h>
1672
1673 /*
1674
1675 Date: Wed, 05 Jan 2000 11:45:40 +0100
1676 From: Frits Boel <boel@niob.knaw.nl>
1677 To: julian.smart@ukonline.co.uk
1678 Subject: Patch for Motif ConvertToBitmap
1679
1680 Hi Julian,
1681
1682 I've been working on a wxWin application for image processing. From the
1683 beginning, I was surprised by the (lack of) speed of ConvertToBitmap,
1684 till I looked in the source code of image.cpp. I saw that converting a
1685 wxImage to a bitmap with 8-bit pixels is done with comparing every pixel
1686 to the 256 colors of the palet. A very time-consuming piece of code!
1687
1688 Because I wanted a faster application, I've made a 'patch' for this. In
1689 short: every pixel of the image is compared to a sorted list with
1690 colors. If the color is found in the list, the palette entry is
1691 returned; if the color is not found, the color palette is searched and
1692 then the palette entry is returned and the color added to the sorted
1693 list.
1694
1695 Maybe there is another method for this, namely changing the palette
1696 itself (if the colors are known, as is the case with tiffs with a
1697 colormap). I did not look at this, maybe someone else did?
1698
1699 The code of the patch is attached, have a look on it, and maybe you will
1700 ship it with the next release of wxMotif?
1701
1702 Regards,
1703
1704 Frits Boel
1705 Software engineer at Hubrecht Laboratory, The Netherlands.
1706
1707 */
1708
1709 class wxSearchColor
1710 {
1711 public:
1712   wxSearchColor( void );
1713   wxSearchColor( int size, XColor *colors );
1714   ~wxSearchColor( void );
1715
1716   int SearchColor( int r, int g, int b );
1717 private:
1718   int AddColor( unsigned int value, int pos );
1719
1720   int          size;
1721   XColor       *colors;
1722   unsigned int *color;
1723   int          *entry;
1724
1725   int bottom;
1726   int top;
1727 };
1728
1729 wxSearchColor::wxSearchColor( void )
1730 {
1731   this->size   = 0;
1732   this->colors = (XColor*) NULL;
1733   this->color  = (unsigned int *) NULL;
1734   this->entry  = (int*) NULL;
1735
1736   this->bottom = 0;
1737   this->top    = 0;
1738 }
1739
1740 wxSearchColor::wxSearchColor( int size, XColor *colors )
1741 {
1742     int i;
1743   this->size   = size;
1744   this->colors = colors;
1745   this->color  = new unsigned int[size];
1746   this->entry  = new int         [size];
1747
1748   for (i = 0; i < this->size; i++ ) {
1749     this->entry[i] = -1;
1750   }
1751
1752   this->bottom = this->top = ( size >> 1 );
1753 }
1754
1755 wxSearchColor::~wxSearchColor( void )
1756 {
1757   if ( this->color ) delete this->color;
1758   if ( this->entry ) delete this->entry;
1759 }
1760
1761 int wxSearchColor::SearchColor( int r, int g, int b )
1762 {
1763   unsigned int value = ( ( ( r * 256 ) + g ) * 256 ) + b;
1764   int          begin = this->bottom;
1765   int          end   = this->top;
1766   int          middle;
1767
1768   while ( begin <= end ) {
1769
1770     middle = ( begin + end ) >> 1;
1771
1772     if ( value == this->color[middle] ) {
1773       return( this->entry[middle] );
1774     } else if ( value < this->color[middle] ) {
1775       end = middle - 1;
1776     } else {
1777       begin = middle + 1;
1778     }
1779
1780   }
1781
1782   return AddColor( value, middle );
1783 }
1784
1785 int wxSearchColor::AddColor( unsigned int value, int pos )
1786 {
1787   int i;
1788   int pixel = -1;
1789   int max = 3 * (65536);
1790   for ( i = 0; i < 256; i++ ) {
1791     int rdiff = ((value >> 8) & 0xFF00 ) - colors[i].red;
1792     int gdiff = ((value     ) & 0xFF00 ) - colors[i].green;
1793     int bdiff = ((value << 8) & 0xFF00 ) - colors[i].blue;
1794     int sum = abs (rdiff) + abs (gdiff) + abs (bdiff);
1795     if (sum < max) { pixel = i; max = sum; }
1796   }
1797
1798   if ( this->entry[pos] < 0 ) {
1799     this->color[pos] = value;
1800     this->entry[pos] = pixel;
1801   } else if ( value < this->color[pos] ) {
1802
1803     if ( this->bottom > 0 ) {
1804       for ( i = this->bottom; i < pos; i++ ) {
1805         this->color[i-1] = this->color[i];
1806         this->entry[i-1] = this->entry[i];
1807       }
1808       this->bottom--;
1809       this->color[pos-1] = value;
1810       this->entry[pos-1] = pixel;
1811     } else if ( this->top < this->size-1 ) {
1812       for ( i = this->top; i >= pos; i-- ) {
1813         this->color[i+1] = this->color[i];
1814         this->entry[i+1] = this->entry[i];
1815       }
1816       this->top++;
1817       this->color[pos] = value;
1818       this->entry[pos] = pixel;
1819     }
1820
1821   } else {
1822
1823     if ( this->top < this->size-1 ) {
1824       for ( i = this->top; i > pos; i-- ) {
1825         this->color[i+1] = this->color[i];
1826         this->entry[i+1] = this->entry[i];
1827       }
1828       this->top++;
1829       this->color[pos+1] = value;
1830       this->entry[pos+1] = pixel;
1831     } else if ( this->bottom > 0 ) {
1832       for ( i = this->bottom; i < pos; i++ ) {
1833         this->color[i-1] = this->color[i];
1834         this->entry[i-1] = this->entry[i];
1835       }
1836       this->bottom--;
1837       this->color[pos] = value;
1838       this->entry[pos] = pixel;
1839     }
1840
1841   }
1842
1843   return( pixel );
1844 }
1845
1846 wxBitmap wxImage::ConvertToBitmap() const
1847 {
1848     wxBitmap bitmap;
1849
1850     wxCHECK_MSG( Ok(), bitmap, wxT("invalid image") );
1851
1852     int width = GetWidth();
1853     int height = GetHeight();
1854
1855     bitmap.SetHeight( height );
1856     bitmap.SetWidth( width );
1857
1858     Display *dpy = (Display*) wxGetDisplay();
1859     Visual* vis = DefaultVisual( dpy, DefaultScreen( dpy ) );
1860     int bpp = DefaultDepth( dpy, DefaultScreen( dpy ) );
1861
1862     // Create image
1863
1864     XImage *data_image = XCreateImage( dpy, vis, bpp, ZPixmap, 0, 0, width, height, 32, 0 );
1865     data_image->data = (char*) malloc( data_image->bytes_per_line * data_image->height );
1866
1867     bitmap.Create( width, height, bpp );
1868
1869     /*
1870     // Create mask
1871
1872       GdkImage *mask_image = (GdkImage*) NULL;
1873
1874         if (HasMask())
1875         {
1876         unsigned char *mask_data = (unsigned char*)malloc( ((width >> 3)+8) * height );
1877
1878           mask_image =  gdk_image_new_bitmap( gdk_visual_get_system(), mask_data, width, height );
1879
1880             wxMask *mask = new wxMask();
1881             mask->m_bitmap = gdk_pixmap_new( (GdkWindow*)&gdk_root_parent, width, height, 1 );
1882
1883               bitmap.SetMask( mask );
1884               }
1885     */
1886
1887     // Retrieve depth info
1888
1889     XVisualInfo vinfo_template;
1890     XVisualInfo *vi;
1891
1892     vinfo_template.visual = vis;
1893     vinfo_template.visualid = XVisualIDFromVisual( vis );
1894     vinfo_template.depth = bpp;
1895     int nitem = 0;
1896
1897     vi = XGetVisualInfo( dpy, VisualIDMask|VisualDepthMask, &vinfo_template, &nitem );
1898
1899     wxCHECK_MSG( vi, wxNullBitmap, wxT("no visual") );
1900
1901     XFree( vi );
1902
1903     if ((bpp == 16) && (vi->red_mask != 0xf800)) bpp = 15;
1904     if (bpp < 8) bpp = 8;
1905
1906     // Render
1907
1908     enum byte_order { RGB, RBG, BRG, BGR, GRB, GBR };
1909     byte_order b_o = RGB;
1910
1911     if (bpp >= 24)
1912     {
1913         if ((vi->red_mask > vi->green_mask) && (vi->green_mask > vi->blue_mask))      b_o = RGB;
1914         else if ((vi->red_mask > vi->blue_mask) && (vi->blue_mask > vi->green_mask))  b_o = RGB;
1915         else if ((vi->blue_mask > vi->red_mask) && (vi->red_mask > vi->green_mask))   b_o = BRG;
1916         else if ((vi->blue_mask > vi->green_mask) && (vi->green_mask > vi->red_mask)) b_o = BGR;
1917         else if ((vi->green_mask > vi->red_mask) && (vi->red_mask > vi->blue_mask))   b_o = GRB;
1918         else if ((vi->green_mask > vi->blue_mask) && (vi->blue_mask > vi->red_mask))  b_o = GBR;
1919     }
1920
1921     /*
1922     int r_mask = GetMaskRed();
1923     int g_mask = GetMaskGreen();
1924     int b_mask = GetMaskBlue();
1925     */
1926
1927     XColor colors[256];
1928     if (bpp == 8)
1929     {
1930         Colormap cmap = (Colormap) wxTheApp->GetMainColormap( dpy );
1931
1932         for (int i = 0; i < 256; i++) colors[i].pixel = i;
1933         XQueryColors( dpy, cmap, colors, 256 );
1934     }
1935
1936     wxSearchColor scolor( 256, colors );
1937     unsigned char* data = GetData();
1938
1939     int index = 0;
1940     for (int y = 0; y < height; y++)
1941     {
1942         for (int x = 0; x < width; x++)
1943         {
1944             int r = data[index];
1945             index++;
1946             int g = data[index];
1947             index++;
1948             int b = data[index];
1949             index++;
1950
1951             /*
1952             if (HasMask())
1953             {
1954             if ((r == r_mask) && (b == b_mask) && (g == g_mask))
1955             gdk_image_put_pixel( mask_image, x, y, 1 );
1956             else
1957             gdk_image_put_pixel( mask_image, x, y, 0 );
1958             }
1959             */
1960
1961             switch (bpp)
1962             {
1963             case 8:
1964                 {
1965 #if 0 // Old, slower code
1966                     int pixel = -1;
1967                     /*
1968                     if (wxTheApp->m_colorCube)
1969                     {
1970                     pixel = wxTheApp->m_colorCube
1971                     [ ((r & 0xf8) << 7) + ((g & 0xf8) << 2) + ((b & 0xf8) >> 3) ];
1972                     }
1973                     else
1974                     {
1975                     */
1976                     int max = 3 * (65536);
1977                     for (int i = 0; i < 256; i++)
1978                     {
1979                         int rdiff = (r << 8) - colors[i].red;
1980                         int gdiff = (g << 8) - colors[i].green;
1981                         int bdiff = (b << 8) - colors[i].blue;
1982                         int sum = abs (rdiff) + abs (gdiff) + abs (bdiff);
1983                         if (sum < max) { pixel = i; max = sum; }
1984                     }
1985                     /*
1986                     }
1987                     */
1988 #endif
1989
1990                         // And this is all to get the 'right' color...
1991                         int pixel = scolor.SearchColor( r, g, b );
1992                     XPutPixel( data_image, x, y, pixel );
1993                     break;
1994                 }
1995             case 15:
1996                 {
1997                     int pixel = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
1998                     XPutPixel( data_image, x, y, pixel );
1999                     break;
2000                 }
2001             case 16:
2002                 {
2003                     int pixel = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
2004                     XPutPixel( data_image, x, y, pixel );
2005                     break;
2006                 }
2007             case 32:
2008             case 24:
2009                 {
2010                     int pixel = 0;
2011                     switch (b_o)
2012                     {
2013                     case RGB: pixel = (r << 16) | (g << 8) | b; break;
2014                     case RBG: pixel = (r << 16) | (b << 8) | g; break;
2015                     case BRG: pixel = (b << 16) | (r << 8) | g; break;
2016                     case BGR: pixel = (b << 16) | (g << 8) | r; break;
2017                     case GRB: pixel = (g << 16) | (r << 8) | b; break;
2018                     case GBR: pixel = (g << 16) | (b << 8) | r; break;
2019                     }
2020                     XPutPixel( data_image, x, y, pixel );
2021                 }
2022             default: break;
2023             }
2024         } // for
2025     }  // for
2026
2027     // Blit picture
2028
2029     XGCValues gcvalues;
2030     gcvalues.foreground = BlackPixel( dpy, DefaultScreen( dpy ) );
2031     GC gc = XCreateGC( dpy, RootWindow ( dpy, DefaultScreen(dpy) ), GCForeground, &gcvalues );
2032     XPutImage( dpy, (Drawable)bitmap.GetPixmap(), gc, data_image, 0, 0, 0, 0, width, height );
2033
2034     XDestroyImage( data_image );
2035     XFreeGC( dpy, gc );
2036
2037     /*
2038     // Blit mask
2039
2040       if (HasMask())
2041       {
2042       GdkGC *mask_gc = gdk_gc_new( bitmap.GetMask()->GetBitmap() );
2043
2044         gdk_draw_image( bitmap.GetMask()->GetBitmap(), mask_gc, mask_image, 0, 0, 0, 0, width, height );
2045
2046           gdk_image_destroy( mask_image );
2047           gdk_gc_unref( mask_gc );
2048           }
2049     */
2050
2051     return bitmap;
2052 }
2053
2054 wxImage::wxImage( const wxBitmap &bitmap )
2055 {
2056     wxCHECK_RET( bitmap.Ok(), wxT("invalid bitmap") );
2057
2058     Display *dpy = (Display*) wxGetDisplay();
2059     Visual* vis = DefaultVisual( dpy, DefaultScreen( dpy ) );
2060     int bpp = DefaultDepth( dpy, DefaultScreen( dpy ) );
2061
2062     XImage *ximage = XGetImage( dpy,
2063         (Drawable)bitmap.GetPixmap(),
2064         0, 0,
2065         bitmap.GetWidth(), bitmap.GetHeight(),
2066         AllPlanes, ZPixmap );
2067
2068     wxCHECK_RET( ximage, wxT("couldn't create image") );
2069
2070     Create( bitmap.GetWidth(), bitmap.GetHeight() );
2071     char unsigned *data = GetData();
2072
2073     if (!data)
2074     {
2075         XDestroyImage( ximage );
2076         wxFAIL_MSG( wxT("couldn't create image") );
2077         return;
2078     }
2079
2080     /*
2081     GdkImage *gdk_image_mask = (GdkImage*) NULL;
2082     if (bitmap.GetMask())
2083     {
2084     gdk_image_mask = gdk_image_get( bitmap.GetMask()->GetBitmap(),
2085     0, 0,
2086     bitmap.GetWidth(), bitmap.GetHeight() );
2087
2088       SetMaskColour( 16, 16, 16 );  // anything unlikely and dividable
2089       }
2090     */
2091
2092     // Retrieve depth info
2093
2094     XVisualInfo vinfo_template;
2095     XVisualInfo *vi;
2096
2097     vinfo_template.visual = vis;
2098     vinfo_template.visualid = XVisualIDFromVisual( vis );
2099     vinfo_template.depth = bpp;
2100     int nitem = 0;
2101
2102     vi = XGetVisualInfo( dpy, VisualIDMask|VisualDepthMask, &vinfo_template, &nitem );
2103
2104     wxCHECK_RET( vi, wxT("no visual") );
2105
2106     if ((bpp == 16) && (vi->red_mask != 0xf800)) bpp = 15;
2107
2108     XFree( vi );
2109
2110     XColor colors[256];
2111     if (bpp == 8)
2112     {
2113         Colormap cmap = (Colormap)wxTheApp->GetMainColormap( dpy );
2114
2115         for (int i = 0; i < 256; i++) colors[i].pixel = i;
2116         XQueryColors( dpy, cmap, colors, 256 );
2117     }
2118
2119     long pos = 0;
2120     for (int j = 0; j < bitmap.GetHeight(); j++)
2121     {
2122         for (int i = 0; i < bitmap.GetWidth(); i++)
2123         {
2124             int pixel = XGetPixel( ximage, i, j );
2125             if (bpp <= 8)
2126             {
2127                 data[pos] = colors[pixel].red >> 8;
2128                 data[pos+1] = colors[pixel].green >> 8;
2129                 data[pos+2] = colors[pixel].blue >> 8;
2130             } else if (bpp == 15)
2131             {
2132                 data[pos] = (pixel >> 7) & 0xf8;
2133                 data[pos+1] = (pixel >> 2) & 0xf8;
2134                 data[pos+2] = (pixel << 3) & 0xf8;
2135             } else if (bpp == 16)
2136             {
2137                 data[pos] = (pixel >> 8) & 0xf8;
2138                 data[pos+1] = (pixel >> 3) & 0xfc;
2139                 data[pos+2] = (pixel << 3) & 0xf8;
2140             } else
2141             {
2142                 data[pos] = (pixel >> 16) & 0xff;
2143                 data[pos+1] = (pixel >> 8) & 0xff;
2144                 data[pos+2] = pixel & 0xff;
2145             }
2146
2147             /*
2148             if (gdk_image_mask)
2149             {
2150             int mask_pixel = gdk_image_get_pixel( gdk_image_mask, i, j );
2151             if (mask_pixel == 0)
2152             {
2153             data[pos] = 16;
2154             data[pos+1] = 16;
2155             data[pos+2] = 16;
2156             }
2157             }
2158             */
2159
2160             pos += 3;
2161         }
2162     }
2163
2164     XDestroyImage( ximage );
2165     /*
2166     if (gdk_image_mask) gdk_image_destroy( gdk_image_mask );
2167     */
2168 }
2169 #endif
2170
2171 #ifdef __WXPM__
2172 // OS/2 Presentation manager conversion routings
2173
2174 wxBitmap wxImage::ConvertToBitmap() const
2175 {
2176     if ( !Ok() )
2177         return wxNullBitmap;
2178     wxBitmap bitmap; // remove
2179 // TODO:
2180 /*
2181     int sizeLimit = 1024*768*3;
2182
2183     // width and height of the device-dependent bitmap
2184     int width = GetWidth();
2185     int bmpHeight = GetHeight();
2186
2187     // calc the number of bytes per scanline and padding
2188     int bytePerLine = width*3;
2189     int sizeDWORD = sizeof( DWORD );
2190     int lineBoundary = bytePerLine % sizeDWORD;
2191     int padding = 0;
2192     if( lineBoundary > 0 )
2193     {
2194         padding = sizeDWORD - lineBoundary;
2195         bytePerLine += padding;
2196     }
2197     // calc the number of DIBs and heights of DIBs
2198     int numDIB = 1;
2199     int hRemain = 0;
2200     int height = sizeLimit/bytePerLine;
2201     if( height >= bmpHeight )
2202         height = bmpHeight;
2203     else
2204     {
2205         numDIB =  bmpHeight / height;
2206         hRemain = bmpHeight % height;
2207         if( hRemain >0 )  numDIB++;
2208     }
2209
2210     // set bitmap parameters
2211     wxBitmap bitmap;
2212     wxCHECK_MSG( Ok(), bitmap, wxT("invalid image") );
2213     bitmap.SetWidth( width );
2214     bitmap.SetHeight( bmpHeight );
2215     bitmap.SetDepth( wxDisplayDepth() );
2216
2217     // create a DIB header
2218     int headersize = sizeof(BITMAPINFOHEADER);
2219     LPBITMAPINFO lpDIBh = (BITMAPINFO *) malloc( headersize );
2220     wxCHECK_MSG( lpDIBh, bitmap, wxT("could not allocate memory for DIB header") );
2221     // Fill in the DIB header
2222     lpDIBh->bmiHeader.biSize = headersize;
2223     lpDIBh->bmiHeader.biWidth = (DWORD)width;
2224     lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
2225     lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
2226     //   the general formula for biSizeImage:
2227     //      ( ( ( ((DWORD)width*24) +31 ) & ~31 ) >> 3 ) * height;
2228     lpDIBh->bmiHeader.biPlanes = 1;
2229     lpDIBh->bmiHeader.biBitCount = 24;
2230     lpDIBh->bmiHeader.biCompression = BI_RGB;
2231     lpDIBh->bmiHeader.biClrUsed = 0;
2232     // These seem not really needed for our purpose here.
2233     lpDIBh->bmiHeader.biClrImportant = 0;
2234     lpDIBh->bmiHeader.biXPelsPerMeter = 0;
2235     lpDIBh->bmiHeader.biYPelsPerMeter = 0;
2236     // memory for DIB data
2237     unsigned char *lpBits;
2238     lpBits = (unsigned char *)malloc( lpDIBh->bmiHeader.biSizeImage );
2239     if( !lpBits )
2240     {
2241         wxFAIL_MSG( wxT("could not allocate memory for DIB") );
2242         free( lpDIBh );
2243         return bitmap;
2244     }
2245
2246     // create and set the device-dependent bitmap
2247     HDC hdc = ::GetDC(NULL);
2248     HDC memdc = ::CreateCompatibleDC( hdc );
2249     HBITMAP hbitmap;
2250     hbitmap = ::CreateCompatibleBitmap( hdc, width, bmpHeight );
2251     ::SelectObject( memdc, hbitmap);
2252
2253     // copy image data into DIB data and then into DDB (in a loop)
2254     unsigned char *data = GetData();
2255     int i, j, n;
2256     int origin = 0;
2257     unsigned char *ptdata = data;
2258     unsigned char *ptbits;
2259
2260     for( n=0; n<numDIB; n++ )
2261     {
2262         if( numDIB > 1 && n == numDIB-1 && hRemain > 0 )
2263         {
2264             // redefine height and size of the (possibly) last smaller DIB
2265             // memory is not reallocated
2266             height = hRemain;
2267             lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
2268             lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
2269         }
2270         ptbits = lpBits;
2271
2272         for( j=0; j<height; j++ )
2273         {
2274             for( i=0; i<width; i++ )
2275             {
2276                 *(ptbits++) = *(ptdata+2);
2277                 *(ptbits++) = *(ptdata+1);
2278                 *(ptbits++) = *(ptdata  );
2279                 ptdata += 3;
2280             }
2281             for( i=0; i< padding; i++ )   *(ptbits++) = 0;
2282         }
2283         ::StretchDIBits( memdc, 0, origin, width, height,\
2284             0, 0, width, height, lpBits, lpDIBh, DIB_RGB_COLORS, SRCCOPY);
2285         origin += height;
2286         // if numDIB = 1,  lines below can also be used
2287         //    hbitmap = CreateDIBitmap( hdc, &(lpDIBh->bmiHeader), CBM_INIT, lpBits, lpDIBh, DIB_RGB_COLORS );
2288         // The above line is equivalent to the following two lines.
2289         //    hbitmap = ::CreateCompatibleBitmap( hdc, width, height );
2290         //    ::SetDIBits( hdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS);
2291         // or the following lines
2292         //    hbitmap = ::CreateCompatibleBitmap( hdc, width, height );
2293         //    HDC memdc = ::CreateCompatibleDC( hdc );
2294         //    ::SelectObject( memdc, hbitmap);
2295         //    ::SetDIBitsToDevice( memdc, 0, 0, width, height,
2296         //            0, 0, 0, height, (void *)lpBits, lpDIBh, DIB_RGB_COLORS);
2297         //    ::SelectObject( memdc, 0 );
2298         //    ::DeleteDC( memdc );
2299     }
2300     bitmap.SetHBITMAP( (WXHBITMAP) hbitmap );
2301
2302     // similarly, created an mono-bitmap for the possible mask
2303     if( HasMask() )
2304     {
2305         hbitmap = ::CreateBitmap( (WORD)width, (WORD)bmpHeight, 1, 1, NULL );
2306         ::SelectObject( memdc, hbitmap);
2307         if( numDIB == 1 )   height = bmpHeight;
2308         else                height = sizeLimit/bytePerLine;
2309         lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
2310         lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
2311         origin = 0;
2312         unsigned char r = GetMaskRed();
2313         unsigned char g = GetMaskGreen();
2314         unsigned char b = GetMaskBlue();
2315         unsigned char zero = 0, one = 255;
2316         ptdata = data;
2317         for( n=0; n<numDIB; n++ )
2318         {
2319             if( numDIB > 1 && n == numDIB - 1 && hRemain > 0 )
2320             {
2321                 // redefine height and size of the (possibly) last smaller DIB
2322                 // memory is not reallocated
2323                 height = hRemain;
2324                 lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
2325                 lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
2326             }
2327             ptbits = lpBits;
2328             for( int j=0; j<height; j++ )
2329             {
2330                 for(i=0; i<width; i++ )
2331                 {
2332                     if( (*(ptdata++)!=r) | (*(ptdata++)!=g) | (*(ptdata++)!=b) )
2333                     {
2334                         *(ptbits++) = one;
2335                         *(ptbits++) = one;
2336                         *(ptbits++) = one;
2337                     }
2338                     else
2339                     {
2340                         *(ptbits++) = zero;
2341                         *(ptbits++) = zero;
2342                         *(ptbits++) = zero;
2343                     }
2344                 }
2345                 for( i=0; i< padding; i++ )   *(ptbits++) = zero;
2346             }
2347             ::StretchDIBits( memdc, 0, origin, width, height,\
2348                 0, 0, width, height, lpBits, lpDIBh, DIB_RGB_COLORS, SRCCOPY);
2349             origin += height;
2350         }
2351         // create a wxMask object
2352         wxMask *mask = new wxMask();
2353         mask->SetMaskBitmap( (WXHBITMAP) hbitmap );
2354         bitmap.SetMask( mask );
2355     }
2356
2357     // free allocated resources
2358     ::SelectObject( memdc, 0 );
2359     ::DeleteDC( memdc );
2360     ::ReleaseDC(NULL, hdc);
2361     free(lpDIBh);
2362     free(lpBits);
2363
2364     // check the wxBitmap object
2365     if( bitmap.GetHBITMAP() )
2366         bitmap.SetOk( TRUE );
2367     else
2368         bitmap.SetOk( FALSE );
2369 */
2370     return bitmap;
2371 }
2372
2373 wxImage::wxImage( const wxBitmap &bitmap )
2374 {
2375     // check the bitmap
2376     if( !bitmap.Ok() )
2377     {
2378         wxFAIL_MSG( wxT("invalid bitmap") );
2379         return;
2380     }
2381
2382     // create an wxImage object
2383     int width = bitmap.GetWidth();
2384     int height = bitmap.GetHeight();
2385     Create( width, height );
2386     unsigned char *data = GetData();
2387     if( !data )
2388     {
2389         wxFAIL_MSG( wxT("could not allocate data for image") );
2390         return;
2391     }
2392
2393     // calc the number of bytes per scanline and padding in the DIB
2394     int bytePerLine = width*3;
2395     int sizeDWORD = sizeof( DWORD );
2396     int lineBoundary =  bytePerLine % sizeDWORD;
2397     int padding = 0;
2398     if( lineBoundary > 0 )
2399     {
2400         padding = sizeDWORD - lineBoundary;
2401         bytePerLine += padding;
2402     }
2403 // TODO:
2404 /*
2405     // create a DIB header
2406     int headersize = sizeof(BITMAPINFOHEADER);
2407     LPBITMAPINFO lpDIBh = (BITMAPINFO *) malloc( headersize );
2408     if( !lpDIBh )
2409     {
2410         wxFAIL_MSG( wxT("could not allocate data for DIB header") );
2411         free( data );
2412         return;
2413     }
2414     // Fill in the DIB header
2415     lpDIBh->bmiHeader.biSize = headersize;
2416     lpDIBh->bmiHeader.biWidth = width;
2417     lpDIBh->bmiHeader.biHeight = -height;
2418     lpDIBh->bmiHeader.biSizeImage = bytePerLine * height;
2419     lpDIBh->bmiHeader.biPlanes = 1;
2420     lpDIBh->bmiHeader.biBitCount = 24;
2421     lpDIBh->bmiHeader.biCompression = BI_RGB;
2422     lpDIBh->bmiHeader.biClrUsed = 0;
2423     // These seem not really needed for our purpose here.
2424     lpDIBh->bmiHeader.biClrImportant = 0;
2425     lpDIBh->bmiHeader.biXPelsPerMeter = 0;
2426     lpDIBh->bmiHeader.biYPelsPerMeter = 0;
2427     // memory for DIB data
2428     unsigned char *lpBits;
2429     lpBits = (unsigned char *) malloc( lpDIBh->bmiHeader.biSizeImage );
2430     if( !lpBits )
2431     {
2432         wxFAIL_MSG( wxT("could not allocate data for DIB") );
2433         free( data );
2434         free( lpDIBh );
2435         return;
2436     }
2437
2438     // copy data from the device-dependent bitmap to the DIB
2439     HDC hdc = ::GetDC(NULL);
2440     HBITMAP hbitmap;
2441     hbitmap = (HBITMAP) bitmap.GetHBITMAP();
2442     ::GetDIBits( hdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
2443
2444     // copy DIB data into the wxImage object
2445     int i, j;
2446     unsigned char *ptdata = data;
2447     unsigned char *ptbits = lpBits;
2448     for( i=0; i<height; i++ )
2449     {
2450         for( j=0; j<width; j++ )
2451         {
2452             *(ptdata++) = *(ptbits+2);
2453             *(ptdata++) = *(ptbits+1);
2454             *(ptdata++) = *(ptbits  );
2455             ptbits += 3;
2456         }
2457         ptbits += padding;
2458     }
2459
2460     // similarly, set data according to the possible mask bitmap
2461     if( bitmap.GetMask() && bitmap.GetMask()->GetMaskBitmap() )
2462     {
2463         hbitmap = (HBITMAP) bitmap.GetMask()->GetMaskBitmap();
2464         // memory DC created, color set, data copied, and memory DC deleted
2465         HDC memdc = ::CreateCompatibleDC( hdc );
2466         ::SetTextColor( memdc, RGB( 0, 0, 0 ) );
2467         ::SetBkColor( memdc, RGB( 255, 255, 255 ) );
2468         ::GetDIBits( memdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
2469         ::DeleteDC( memdc );
2470         // background color set to RGB(16,16,16) in consistent with wxGTK
2471         unsigned char r=16, g=16, b=16;
2472         ptdata = data;
2473         ptbits = lpBits;
2474         for( i=0; i<height; i++ )
2475         {
2476             for( j=0; j<width; j++ )
2477             {
2478                 if( *ptbits != 0 )
2479                     ptdata += 3;
2480                 else
2481                 {
2482                     *(ptdata++)  = r;
2483                     *(ptdata++)  = g;
2484                     *(ptdata++)  = b;
2485                 }
2486                 ptbits += 3;
2487             }
2488             ptbits += padding;
2489         }
2490         SetMaskColour( r, g, b );
2491         SetMask( TRUE );
2492     }
2493     else
2494     {
2495         SetMask( FALSE );
2496     }
2497     // free allocated resources
2498     ::ReleaseDC(NULL, hdc);
2499     free(lpDIBh);
2500     free(lpBits);
2501 */
2502 }
2503
2504 #endif
2505
2506 // A module to allow wxImage initialization/cleanup
2507 // without calling these functions from app.cpp or from
2508 // the user's application.
2509
2510 class wxImageModule: public wxModule
2511 {
2512 DECLARE_DYNAMIC_CLASS(wxImageModule)
2513 public:
2514     wxImageModule() {}
2515     bool OnInit() { wxImage::InitStandardHandlers(); return TRUE; };
2516     void OnExit() { wxImage::CleanUpHandlers(); };
2517 };
2518
2519 IMPLEMENT_DYNAMIC_CLASS(wxImageModule, wxModule)
2520
2521
2522 //-----------------------------------------------------------------------------
2523
2524 // GRG, Dic/99
2525 // Counts and returns the number of different colours. Optionally stops
2526 // when it exceeds 'stopafter' different colours. This is useful, for
2527 // example, to see if the image can be saved as 8-bit (256 colour or
2528 // less, in this case it would be invoked as CountColours(256)). Default
2529 // value for stopafter is -1 (don't care).
2530 //
2531 unsigned long wxImage::CountColours( unsigned long stopafter )
2532 {
2533     wxHashTable h;
2534     wxNode *node;
2535     wxHNode *hnode;
2536     unsigned char r, g, b, *p;
2537     unsigned long size, nentries, key;
2538
2539     p = GetData();
2540     size = GetWidth() * GetHeight();
2541     nentries = 0;
2542
2543     for (unsigned long j = 0; (j < size) && (nentries <= stopafter) ; j++)
2544     {
2545         r = *(p++);
2546         g = *(p++);
2547         b = *(p++);
2548         key = (r << 16) | (g << 8) | b;
2549
2550         hnode = (wxHNode *) h.Get(key);
2551
2552         if (!hnode)
2553         {
2554             h.Put(key, (wxObject *)(new wxHNode));
2555             nentries++;
2556         }
2557     }
2558
2559     // delete all HNodes
2560     h.BeginFind();
2561     while ((node = h.Next()) != NULL)
2562         delete (wxHNode *)node->GetData();
2563
2564     return nentries;
2565 }
2566
2567
2568 // GRG, Dic/99
2569 // Computes the histogram of the image and fills a hash table, indexed
2570 // with integer keys built as 0xRRGGBB, containing wxHNode objects. Each
2571 // wxHNode contains an 'index' (useful to build a palette with the image
2572 // colours) and a 'value', which is the number of pixels in the image with
2573 // that colour.
2574 //
2575 unsigned long wxImage::ComputeHistogram( wxHashTable &h )
2576 {
2577     unsigned char r, g, b, *p;
2578     unsigned long size, nentries, key;
2579     wxHNode *hnode;
2580
2581     p = GetData();
2582     size = GetWidth() * GetHeight();
2583     nentries = 0;
2584
2585     for (unsigned long j = 0; j < size; j++)
2586     {
2587         r = *(p++);
2588         g = *(p++);
2589         b = *(p++);
2590         key = (r << 16) | (g << 8) | b;
2591
2592         hnode = (wxHNode *) h.Get(key);
2593
2594         if (hnode)
2595             hnode->value++;
2596         else
2597         {
2598             hnode = new wxHNode();
2599             hnode->index = nentries++;
2600             hnode->value = 1;
2601
2602             h.Put(key, (wxObject *)hnode);
2603         }
2604     }
2605
2606     return nentries;
2607 }
2608
2609