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