src/motif/bitmap.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        bitmap.cpp
   3 // Purpose:     wxBitmap
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     17/09/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13 #pragma implementation "bitmap.h"
  14 #endif
  15
  16 #ifdef __VMS
  17 #define XtParent XTPARENT
  18 #endif
  19
  20 #include "wx/setup.h"
  21 #include "wx/utils.h"
  22 #include "wx/palette.h"
  23 #include "wx/bitmap.h"
  24 #include "wx/icon.h"
  25 #include "wx/log.h"
  26 #include "wx/control.h"
  27 #include "wx/dcmemory.h"
  28 #include "wx/image.h"
  29 #include "wx/app.h"
  30
  31 #ifdef __VMS__
  32 #pragma message disable nosimpint
  33 #endif
  34 #include <Xm/Xm.h>
  35 #ifdef __VMS__
  36 #pragma message enable nosimpint
  37 #endif
  38
  39 #include "wx/motif/private.h"
  40
  41 #if wxHAVE_LIB_XPM
  42     #include <X11/xpm.h>
  43 #endif
  44 #include <math.h>
  45
  46
  47 IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
  48 IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
  49
  50 wxBitmapRefData::wxBitmapRefData()
  51 {
  52     m_ok = FALSE;
  53     m_width = 0;
  54     m_height = 0;
  55     m_depth = 0;
  56     m_quality = 0;
  57     m_numColors = 0;
  58     m_bitmapMask = NULL;
  59
  60     m_pixmap = (WXPixmap) 0;
  61     m_display = (WXDisplay*) 0;
  62
  63     m_freePixmap = TRUE; //TODO: necessary?
  64     m_freeColors = (unsigned long*) 0;
  65     m_freeColorsCount = 0;
  66
  67     // These 5 variables are for wxControl
  68     m_insensPixmap = (WXPixmap) 0;
  69     m_labelPixmap = (WXPixmap) 0;
  70     m_armPixmap = (WXPixmap) 0;
  71     m_image = (WXImage*) 0;
  72     m_insensImage = (WXImage*) 0;
  73 }
  74
  75 wxBitmapRefData::~wxBitmapRefData()
  76 {
  77     if (m_labelPixmap)
  78         XmDestroyPixmap (DefaultScreenOfDisplay ((Display*) m_display), (Pixmap) m_labelPixmap);
  79
  80     if (m_armPixmap)
  81         XmDestroyPixmap (DefaultScreenOfDisplay ((Display*) m_display), (Pixmap) m_armPixmap);
  82
  83     if (m_insensPixmap)
  84         XmDestroyPixmap (DefaultScreenOfDisplay ((Display*) m_display), (Pixmap) m_insensPixmap);
  85
  86     if (m_image)
  87     {
  88         XmUninstallImage ((XImage*) m_image);
  89         XtFree ((char *) (XImage*) m_image);
  90     }
  91
  92     if (m_insensImage)
  93     {
  94         XmUninstallImage ((XImage*) m_insensImage);
  95         delete[] ((XImage*) m_insensImage)->data;
  96         XtFree ((char *) (XImage*) m_insensImage);
  97     }
  98     if (m_pixmap && m_freePixmap)
  99         XFreePixmap ((Display*) m_display, (Pixmap) m_pixmap);
 100
 101     if (m_freeColors)
 102     {
 103         int screen = DefaultScreen((Display*) m_display);
 104         Colormap cmp = DefaultColormap((Display*) m_display,screen);
 105         long llp;
 106         for(llp = 0;llp < m_freeColorsCount;llp++)
 107             XFreeColors((Display*) m_display, cmp, &m_freeColors[llp], 1, 0L);
 108         delete m_freeColors;
 109     };
 110
 111     if (m_bitmapMask)
 112         delete m_bitmapMask;
 113     m_bitmapMask = NULL;
 114 }
 115
 116 wxList wxBitmap::sm_handlers;
 117
 118 #define M_BMPDATA ((wxBitmapRefData *)m_refData)
 119
 120 wxBitmap::wxBitmap()
 121 {
 122     m_refData = NULL;
 123
 124     if ( wxTheBitmapList )
 125         wxTheBitmapList->AddBitmap(this);
 126 }
 127
 128 wxBitmap::~wxBitmap()
 129 {
 130     if (wxTheBitmapList)
 131         wxTheBitmapList->DeleteObject(this);
 132 }
 133
 134 wxBitmap::wxBitmap(const char bits[], int width, int height, int depth)
 135 {
 136     m_refData = new wxBitmapRefData;
 137
 138     (void) Create((void*) bits, wxBITMAP_TYPE_XBM_DATA, width, height, depth);
 139
 140     if ( wxTheBitmapList )
 141         wxTheBitmapList->AddBitmap(this);
 142 }
 143
 144 wxBitmap::wxBitmap(int w, int h, int d)
 145 {
 146     (void)Create(w, h, d);
 147
 148     if ( wxTheBitmapList )
 149         wxTheBitmapList->AddBitmap(this);
 150 }
 151
 152 wxBitmap::wxBitmap(void *data, long type, int width, int height, int depth)
 153 {
 154     (void) Create(data, type, width, height, depth);
 155
 156     if ( wxTheBitmapList )
 157         wxTheBitmapList->AddBitmap(this);
 158 }
 159
 160 wxBitmap::wxBitmap(const wxString& filename, long type)
 161 {
 162     LoadFile(filename, (int)type);
 163
 164     if ( wxTheBitmapList )
 165         wxTheBitmapList->AddBitmap(this);
 166 }
 167
 168 // Create from XPM data
 169 static wxControl* sg_Control = NULL;
 170 wxBitmap::wxBitmap(char **data, wxControl* control)
 171 {
 172     // Pass the control to the Create function using a global
 173     sg_Control = control;
 174
 175     (void) Create((void *)data, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0);
 176
 177     sg_Control = (wxControl*) NULL;
 178 }
 179
 180 bool wxBitmap::CreateFromXpm(const char **bits)
 181 {
 182     wxCHECK_MSG( bits, FALSE, _T("NULL pointer in wxBitmap::CreateFromXpm") );
 183
 184     return Create(bits, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0);
 185 }
 186
 187 bool wxBitmap::Create(int w, int h, int d)
 188 {
 189     UnRef();
 190
 191     m_refData = new wxBitmapRefData;
 192
 193     if (d < 1)
 194         d = wxDisplayDepth();
 195
 196     M_BITMAPDATA->m_width = w;
 197     M_BITMAPDATA->m_height = h;
 198     M_BITMAPDATA->m_depth = d;
 199     M_BITMAPDATA->m_freePixmap = TRUE;
 200
 201     Display *dpy = (Display*) wxGetDisplay();
 202
 203     M_BITMAPDATA->m_display = dpy; /* MATTHEW: [4] Remember the display */
 204
 205     M_BITMAPDATA->m_pixmap = (WXPixmap) XCreatePixmap (dpy, RootWindow (dpy, DefaultScreen (dpy)),
 206         w, h, d);
 207
 208     M_BITMAPDATA->m_ok = (M_BITMAPDATA->m_pixmap != (WXPixmap) 0) ;
 209     return M_BITMAPDATA->m_ok;
 210 }
 211
 212 bool wxBitmap::LoadFile(const wxString& filename, long type)
 213 {
 214     UnRef();
 215
 216     m_refData = new wxBitmapRefData;
 217
 218     wxBitmapHandler *handler = FindHandler(type);
 219
 220     if ( handler == NULL ) {
 221         wxImage image;
 222         if (!image.LoadFile( filename, type )) return FALSE;
 223         if (image.Ok())
 224         {
 225             *this = image.ConvertToBitmap();
 226             return TRUE;
 227         }
 228         else return FALSE;
 229     }
 230
 231     return handler->LoadFile(this, filename, type, -1, -1);
 232 }
 233
 234 bool wxBitmap::Create(void *data, long type, int width, int height, int depth)
 235 {
 236     UnRef();
 237
 238     m_refData = new wxBitmapRefData;
 239
 240     wxBitmapHandler *handler = FindHandler(type);
 241
 242     if ( handler == NULL ) {
 243         wxLogWarning("no data bitmap handler for type %d defined.", type);
 244
 245         return FALSE;
 246     }
 247
 248     return handler->Create(this, data, type, width, height, depth);
 249 }
 250
 251 bool wxBitmap::SaveFile(const wxString& filename, int type, const wxPalette *palette)
 252 {
 253     wxBitmapHandler *handler = FindHandler(type);
 254
 255     if ( handler == NULL ) { // try wxImage
 256         wxImage image( *this );
 257         if (image.Ok()) return image.SaveFile( filename, type );
 258         else return FALSE;
 259     }
 260
 261     return handler->SaveFile(this, filename, type, palette);
 262 }
 263
 264 void wxBitmap::SetWidth(int w)
 265 {
 266     if (!M_BITMAPDATA)
 267         m_refData = new wxBitmapRefData;
 268
 269     M_BITMAPDATA->m_width = w;
 270 }
 271
 272 void wxBitmap::SetHeight(int h)
 273 {
 274     if (!M_BITMAPDATA)
 275         m_refData = new wxBitmapRefData;
 276
 277     M_BITMAPDATA->m_height = h;
 278 }
 279
 280 void wxBitmap::SetDepth(int d)
 281 {
 282     if (!M_BITMAPDATA)
 283         m_refData = new wxBitmapRefData;
 284
 285     M_BITMAPDATA->m_depth = d;
 286 }
 287
 288 void wxBitmap::SetQuality(int q)
 289 {
 290     if (!M_BITMAPDATA)
 291         m_refData = new wxBitmapRefData;
 292
 293     M_BITMAPDATA->m_quality = q;
 294 }
 295
 296 void wxBitmap::SetOk(bool isOk)
 297 {
 298     if (!M_BITMAPDATA)
 299         m_refData = new wxBitmapRefData;
 300
 301     M_BITMAPDATA->m_ok = isOk;
 302 }
 303
 304 void wxBitmap::SetPalette(const wxPalette& palette)
 305 {
 306     if (!M_BITMAPDATA)
 307         m_refData = new wxBitmapRefData;
 308
 309     M_BITMAPDATA->m_bitmapPalette = palette ;
 310 }
 311
 312 void wxBitmap::SetMask(wxMask *mask)
 313 {
 314     if (!M_BITMAPDATA)
 315         m_refData = new wxBitmapRefData;
 316
 317     M_BITMAPDATA->m_bitmapMask = mask ;
 318 }
 319
 320 wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const
 321 {
 322     wxCHECK_MSG( Ok() &&
 323                  (rect.x >= 0) && (rect.y >= 0) &&
 324                  (rect.x+rect.width <= M_BMPDATA->m_width) && (rect.y+rect.height <= M_BMPDATA->m_height),
 325                  wxNullBitmap, wxT("invalid bitmap or bitmap region") );
 326
 327     wxBitmap ret( rect.width, rect.height, 0 );
 328     wxASSERT_MSG( ret.Ok(), wxT("GetSubBitmap error") );
 329
 330    // The remaining still TODO
 331    return ret;
 332 }
 333
 334 void wxBitmap::AddHandler(wxBitmapHandler *handler)
 335 {
 336     sm_handlers.Append(handler);
 337 }
 338
 339 void wxBitmap::InsertHandler(wxBitmapHandler *handler)
 340 {
 341     sm_handlers.Insert(handler);
 342 }
 343
 344 bool wxBitmap::RemoveHandler(const wxString& name)
 345 {
 346     wxBitmapHandler *handler = FindHandler(name);
 347     if ( handler )
 348     {
 349         sm_handlers.DeleteObject(handler);
 350         return TRUE;
 351     }
 352     else
 353         return FALSE;
 354 }
 355
 356 wxBitmapHandler *wxBitmap::FindHandler(const wxString& name)
 357 {
 358     wxNode *node = sm_handlers.First();
 359     while ( node )
 360     {
 361         wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
 362         if ( handler->GetName() == name )
 363             return handler;
 364         node = node->Next();
 365     }
 366     return NULL;
 367 }
 368
 369 wxBitmapHandler *wxBitmap::FindHandler(const wxString& extension, long bitmapType)
 370 {
 371     wxNode *node = sm_handlers.First();
 372     while ( node )
 373     {
 374         wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
 375         if ( handler->GetExtension() == extension &&
 376             (bitmapType == -1 || handler->GetType() == bitmapType) )
 377             return handler;
 378         node = node->Next();
 379     }
 380     return NULL;
 381 }
 382
 383 wxBitmapHandler *wxBitmap::FindHandler(long bitmapType)
 384 {
 385     wxNode *node = sm_handlers.First();
 386     while ( node )
 387     {
 388         wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
 389         if (handler->GetType() == bitmapType)
 390             return handler;
 391         node = node->Next();
 392     }
 393     return NULL;
 394 }
 395
 396 /*
 397 * wxMask
 398 */
 399
 400 wxMask::wxMask()
 401 {
 402     m_pixmap = (WXPixmap) 0;
 403 }
 404
 405 // Construct a mask from a bitmap and a colour indicating
 406 // the transparent area
 407 wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour)
 408 {
 409     m_pixmap = (WXPixmap) 0;
 410
 411     Create(bitmap, colour);
 412 }
 413
 414 // Construct a mask from a bitmap and a palette index indicating
 415 // the transparent area
 416 wxMask::wxMask(const wxBitmap& bitmap, int paletteIndex)
 417 {
 418     m_pixmap = (WXPixmap) 0;
 419
 420     Create(bitmap, paletteIndex);
 421 }
 422
 423 // Construct a mask from a mono bitmap (copies the bitmap).
 424 wxMask::wxMask(const wxBitmap& bitmap)
 425 {
 426     m_pixmap = (WXPixmap) 0;
 427
 428     Create(bitmap);
 429 }
 430
 431 wxMask::~wxMask()
 432 {
 433     // TODO: this may be the wrong display
 434     if ( m_pixmap )
 435         XFreePixmap ((Display*) wxGetDisplay(), (Pixmap) m_pixmap);
 436 }
 437
 438 // Create a mask from a mono bitmap (copies the bitmap).
 439 bool wxMask::Create(const wxBitmap& WXUNUSED(bitmap))
 440 {
 441     // TODO
 442     return FALSE;
 443 }
 444
 445 // Create a mask from a bitmap and a palette index indicating
 446 // the transparent area
 447 bool wxMask::Create(const wxBitmap& WXUNUSED(bitmap), int WXUNUSED(paletteIndex))
 448 {
 449     // TODO
 450     return FALSE;
 451 }
 452
 453 // Create a mask from a bitmap and a colour indicating
 454 // the transparent area
 455 bool wxMask::Create(const wxBitmap& WXUNUSED(bitmap), const wxColour& WXUNUSED(colour))
 456 {
 457     // TODO
 458     return FALSE;
 459 }
 460
 461 /*
 462 * wxBitmapHandler
 463 */
 464
 465 IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject)
 466
 467 bool wxBitmapHandler::Create(wxBitmap *WXUNUSED(bitmap), void *WXUNUSED(data), long WXUNUSED(type),
 468                              int WXUNUSED(width), int WXUNUSED(height), int WXUNUSED(depth))
 469 {
 470     return FALSE;
 471 }
 472
 473 bool wxBitmapHandler::LoadFile(wxBitmap *WXUNUSED(bitmap), const wxString& WXUNUSED(name), long WXUNUSED(type),
 474                                int WXUNUSED(desiredWidth), int WXUNUSED(desiredHeight))
 475 {
 476     return FALSE;
 477 }
 478
 479 bool wxBitmapHandler::SaveFile(wxBitmap *WXUNUSED(bitmap), const wxString& WXUNUSED(name), int WXUNUSED(type),
 480                                const wxPalette *WXUNUSED(palette))
 481 {
 482     return FALSE;
 483 }
 484
 485 /*
 486 * Standard handlers
 487 */
 488
 489 class WXDLLEXPORT wxXBMFileHandler: public wxBitmapHandler
 490 {
 491     DECLARE_DYNAMIC_CLASS(wxXBMFileHandler)
 492 public:
 493     inline wxXBMFileHandler()
 494     {
 495         m_name = "XBM file";
 496         m_extension = "xbm";
 497         m_type = wxBITMAP_TYPE_XBM;
 498     };
 499
 500     virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
 501         int desiredWidth, int desiredHeight);
 502 };
 503 IMPLEMENT_DYNAMIC_CLASS(wxXBMFileHandler, wxBitmapHandler)
 504
 505 bool wxXBMFileHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long WXUNUSED(flags),
 506                                 int WXUNUSED(desiredWidth), int WXUNUSED(desiredHeight))
 507 {
 508     M_BITMAPHANDLERDATA->m_freePixmap = TRUE;
 509
 510     int hotX, hotY;
 511     unsigned int w, h;
 512     Pixmap pixmap;
 513
 514     Display *dpy = (Display*) wxGetDisplay();
 515     M_BITMAPDATA->m_display = (WXDisplay*) dpy;
 516
 517     int value = XReadBitmapFile (dpy, RootWindow (dpy, DefaultScreen (dpy)),
 518         (char*) (const char*) name, &w, &h, &pixmap, &hotX, &hotY);
 519     M_BITMAPHANDLERDATA->m_width = w;
 520     M_BITMAPHANDLERDATA->m_height = h;
 521     M_BITMAPHANDLERDATA->m_depth = 1;
 522     M_BITMAPHANDLERDATA->m_pixmap = (WXPixmap) pixmap;
 523
 524     if ((value == BitmapFileInvalid) ||
 525         (value == BitmapOpenFailed) ||
 526         (value == BitmapNoMemory))
 527     {
 528         M_BITMAPHANDLERDATA->m_ok = FALSE;
 529         M_BITMAPHANDLERDATA->m_pixmap = (WXPixmap) 0;
 530     }
 531     else
 532         M_BITMAPHANDLERDATA->m_ok = TRUE;
 533
 534     return M_BITMAPHANDLERDATA->m_ok ;
 535 }
 536
 537 class WXDLLEXPORT wxXBMDataHandler: public wxBitmapHandler
 538 {
 539     DECLARE_DYNAMIC_CLASS(wxXBMDataHandler)
 540 public:
 541     inline wxXBMDataHandler()
 542     {
 543         m_name = "XBM data";
 544         m_extension = "xbm";
 545         m_type = wxBITMAP_TYPE_XBM_DATA;
 546     };
 547
 548     virtual bool Create(wxBitmap *bitmap, void *data, long flags, int width, int height, int depth = 1);
 549 };
 550 IMPLEMENT_DYNAMIC_CLASS(wxXBMDataHandler, wxBitmapHandler)
 551
 552 bool wxXBMDataHandler::Create( wxBitmap *bitmap, void *data, long WXUNUSED(flags),
 553                               int width, int height, int WXUNUSED(depth))
 554 {
 555     M_BITMAPHANDLERDATA->m_width = width;
 556     M_BITMAPHANDLERDATA->m_height = height;
 557     M_BITMAPHANDLERDATA->m_depth = 1;
 558     M_BITMAPHANDLERDATA->m_freePixmap = TRUE;
 559
 560     Display *dpy = (Display*) wxGetDisplay();
 561     M_BITMAPHANDLERDATA->m_display = (WXDisplay*) dpy;
 562
 563     M_BITMAPHANDLERDATA->m_pixmap = (WXPixmap) XCreateBitmapFromData (dpy, RootWindow (dpy, DefaultScreen (dpy)), (char*) data, width, height);
 564     M_BITMAPHANDLERDATA->m_ok = (M_BITMAPHANDLERDATA->m_pixmap != (WXPixmap) 0) ;
 565
 566     // code for wxControl. TODO: can we avoid doing this until we need it?
 567     // E.g. have CreateButtonPixmaps which is called on demand.
 568     XImage* image = (XImage *) XtMalloc (sizeof (XImage));
 569     image->width = width;
 570     image->height = height;
 571     image->data = (char*) data;
 572     image->depth = 1;
 573     image->xoffset = 0;
 574     image->format = XYBitmap;
 575     image->byte_order = LSBFirst;
 576     image->bitmap_unit = 8;
 577     image->bitmap_bit_order = LSBFirst;
 578     image->bitmap_pad = 8;
 579     image->bytes_per_line = (width + 7) >> 3;
 580
 581     char tmp[128];
 582     sprintf (tmp, "Im%x", (unsigned int) image);
 583     XmInstallImage (image, tmp);
 584
 585     // Build our manually stipped pixmap.
 586
 587     int bpl = (width + 7) / 8;
 588     char *data1 = new char[height * bpl];
 589     char* bits = (char*) data;
 590     int i;
 591     for (i = 0; i < height; i++)
 592     {
 593         int mask = i % 2 ? 0x55 : 0xaa;
 594         int j;
 595         for (j = 0; j < bpl; j++)
 596             data1[i * bpl + j] = bits[i * bpl + j] & mask;
 597     }
 598     XImage* insensImage = (XImage *) XtMalloc (sizeof (XImage));
 599     insensImage->width = width;
 600     insensImage->height = height;
 601     insensImage->data = data1;
 602     insensImage->depth = 1;
 603     insensImage->xoffset = 0;
 604     insensImage->format = XYBitmap;
 605     insensImage->byte_order = LSBFirst;
 606     insensImage->bitmap_unit = 8;
 607     insensImage->bitmap_bit_order = LSBFirst;
 608     insensImage->bitmap_pad = 8;
 609     insensImage->bytes_per_line = bpl;
 610
 611     sprintf (tmp, "Not%x", (unsigned int)insensImage);
 612     XmInstallImage (insensImage, tmp);
 613
 614     M_BITMAPHANDLERDATA->m_image = (WXImage*) image;
 615     M_BITMAPHANDLERDATA->m_insensImage = (WXImage*) insensImage;
 616
 617     return TRUE;
 618 }
 619
 620 #if wxHAVE_LIB_XPM
 621 class WXDLLEXPORT wxXPMFileHandler: public wxBitmapHandler
 622 {
 623     DECLARE_DYNAMIC_CLASS(wxXPMFileHandler)
 624 public:
 625     inline wxXPMFileHandler()
 626     {
 627         m_name = "XPM file";
 628         m_extension = "xpm";
 629         m_type = wxBITMAP_TYPE_XPM;
 630     };
 631
 632     virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
 633         int desiredWidth, int desiredHeight);
 634     virtual bool SaveFile(wxBitmap *bitmap, const wxString& name, int type, const wxPalette *palette = NULL);
 635 };
 636
 637 IMPLEMENT_DYNAMIC_CLASS(wxXPMFileHandler, wxBitmapHandler)
 638
 639 bool wxXPMFileHandler::LoadFile( wxBitmap *bitmap, const wxString& name, long WXUNUSED(flags),
 640                                 int WXUNUSED(desiredWidth), int WXUNUSED(desiredHeight) )
 641 {
 642     Display *dpy = (Display*) wxGetDisplay();
 643     M_BITMAPHANDLERDATA->m_display = (WXDisplay*) dpy;
 644
 645     XpmAttributes xpmAttr;
 646     Pixmap pixmap;
 647     Pixmap mask = 0;
 648
 649     M_BITMAPHANDLERDATA->m_ok = FALSE;
 650     xpmAttr.valuemask = XpmReturnInfos | XpmCloseness;
 651     xpmAttr.closeness = 40000;
 652     int errorStatus = XpmReadFileToPixmap(dpy,
 653         RootWindow(dpy, DefaultScreen(dpy)), (char*) (const char*) name,
 654         &pixmap, &mask, &xpmAttr);
 655
 656     if (errorStatus == XpmSuccess)
 657     {
 658         M_BITMAPHANDLERDATA->m_pixmap = (WXPixmap) pixmap;
 659         if ( mask )
 660         {
 661             M_BITMAPHANDLERDATA->m_bitmapMask = new wxMask;
 662             M_BITMAPHANDLERDATA->m_bitmapMask->SetPixmap((WXPixmap) mask);
 663         }
 664
 665         unsigned int depthRet;
 666         int xRet, yRet;
 667         unsigned int widthRet, heightRet, borderWidthRet;
 668         Window rootWindowRet;
 669         XGetGeometry(dpy, pixmap, &rootWindowRet, &xRet, &yRet,
 670             &widthRet, &heightRet, &borderWidthRet, &depthRet);
 671
 672         M_BITMAPHANDLERDATA->m_width = xpmAttr.width;
 673         M_BITMAPHANDLERDATA->m_height = xpmAttr.height;
 674
 675         /*
 676         if ( xpmAttr.npixels > 2 )
 677         {
 678         M_BITMAPHANDLERDATA->m_depth = 8;       // TODO: next time not just a guess :-) ...
 679         } else
 680         {
 681         M_BITMAPHANDLERDATA->m_depth = 1;       // mono
 682         }
 683         */
 684
 685         M_BITMAPHANDLERDATA->m_depth = depthRet;
 686
 687         M_BITMAPHANDLERDATA->m_numColors = xpmAttr.npixels;
 688
 689         XpmFreeAttributes(&xpmAttr);
 690
 691         M_BITMAPHANDLERDATA->m_ok = TRUE;
 692         return TRUE;
 693     } else
 694     {
 695         //      XpmDebugError(errorStatus, name);
 696         M_BITMAPHANDLERDATA->m_ok = FALSE;
 697         return FALSE;
 698     }
 699 }
 700
 701 bool wxXPMFileHandler::SaveFile( wxBitmap *bitmap, const wxString& name, int WXUNUSED(type),
 702                                 const wxPalette *WXUNUSED(palette))
 703 {
 704     if (M_BITMAPHANDLERDATA->m_ok && M_BITMAPHANDLERDATA->m_pixmap)
 705     {
 706         Display *dpy =  (Display*) M_BITMAPHANDLERDATA->m_display;
 707         int errorStatus = XpmWriteFileFromPixmap(dpy, (char*) (const char*) name,
 708             (Pixmap) M_BITMAPHANDLERDATA->m_pixmap,
 709             (M_BITMAPHANDLERDATA->m_bitmapMask ? (Pixmap) M_BITMAPHANDLERDATA->m_bitmapMask->GetPixmap() : (Pixmap) 0),
 710             (XpmAttributes *) NULL);
 711         if (errorStatus == XpmSuccess)
 712             return TRUE;
 713         else
 714             return FALSE;
 715     }
 716     else
 717         return FALSE;
 718 }
 719
 720 class WXDLLEXPORT wxXPMDataHandler: public wxBitmapHandler
 721 {
 722     DECLARE_DYNAMIC_CLASS(wxXPMDataHandler)
 723 public:
 724     inline wxXPMDataHandler()
 725     {
 726         m_name = "XPM data";
 727         m_extension = "xpm";
 728         m_type = wxBITMAP_TYPE_XPM_DATA;
 729     };
 730
 731     virtual bool Create(wxBitmap *bitmap, void *data, long flags, int width, int height, int depth = 1);
 732 };
 733 IMPLEMENT_DYNAMIC_CLASS(wxXPMDataHandler, wxBitmapHandler)
 734
 735 bool wxXPMDataHandler::Create( wxBitmap *bitmap, void *data, long WXUNUSED(flags),
 736                               int width, int height, int WXUNUSED(depth))
 737 {
 738     M_BITMAPHANDLERDATA->m_width = width;
 739     M_BITMAPHANDLERDATA->m_height = height;
 740     M_BITMAPHANDLERDATA->m_depth = 1;
 741     M_BITMAPHANDLERDATA->m_freePixmap = TRUE;
 742
 743     Display *dpy = (Display*) wxGetDisplay();
 744     M_BITMAPHANDLERDATA->m_display = (WXDisplay*) dpy;
 745
 746     XpmAttributes xpmAttr;
 747
 748     xpmAttr.valuemask = XpmReturnInfos;    /* nothing yet, but get infos back */
 749
 750     XpmColorSymbol symbolicColors[4];
 751     if (sg_Control && sg_Control->GetMainWidget())
 752     {
 753         symbolicColors[0].name = "foreground";
 754         symbolicColors[0].value = NULL;
 755         symbolicColors[1].name = "background";
 756         symbolicColors[1].value = NULL;
 757         XtVaGetValues((Widget) sg_Control->GetMainWidget(),
 758             XmNforeground,  &symbolicColors[0].pixel,
 759             XmNbackground,  &symbolicColors[1].pixel,NULL);
 760         xpmAttr.numsymbols = 2;
 761         xpmAttr.colorsymbols = symbolicColors;
 762         xpmAttr.valuemask |= XpmColorSymbols;    // add flag
 763     }
 764
 765     Pixmap pixmap;
 766     Pixmap mask = 0;
 767     int ErrorStatus = XpmCreatePixmapFromData(dpy, RootWindow(dpy, DefaultScreen(dpy)),
 768         (char**) data, &pixmap, &mask, &xpmAttr);
 769     if (ErrorStatus == XpmSuccess)
 770     {
 771         // Set attributes
 772         M_BITMAPHANDLERDATA->m_width = xpmAttr.width;
 773         M_BITMAPHANDLERDATA->m_height = xpmAttr.height;
 774
 775         unsigned int depthRet;
 776         int xRet, yRet;
 777         unsigned int widthRet, heightRet, borderWidthRet;
 778         Window rootWindowRet;
 779         XGetGeometry(dpy, pixmap, &rootWindowRet, &xRet, &yRet,
 780             &widthRet, &heightRet, &borderWidthRet, &depthRet);
 781
 782             /*
 783             if ( xpmAttr.npixels > 2 )
 784             {
 785             M_BITMAPHANDLERDATA->m_depth = 8;    // next time not just a guess :-) ...
 786             } else
 787             {
 788             M_BITMAPHANDLERDATA->m_depth = 1;    // mono
 789             }
 790         */
 791
 792         M_BITMAPHANDLERDATA->m_depth = depthRet;
 793
 794         M_BITMAPHANDLERDATA->m_numColors = xpmAttr.npixels;
 795         XpmFreeAttributes(&xpmAttr);
 796         M_BITMAPHANDLERDATA->m_ok = TRUE;
 797         M_BITMAPHANDLERDATA->m_pixmap = (WXPixmap) pixmap;
 798         if ( mask )
 799         {
 800             M_BITMAPHANDLERDATA->m_bitmapMask = new wxMask;
 801             M_BITMAPHANDLERDATA->m_bitmapMask->SetPixmap((WXPixmap) mask);
 802         }
 803     }
 804     else
 805     {
 806         //      XpmDebugError(ErrorStatus, NULL);
 807         M_BITMAPHANDLERDATA->m_ok = FALSE;
 808     }
 809     return M_BITMAPHANDLERDATA->m_ok ;
 810 }
 811
 812 #endif // wxHAVE_LIB_XPM
 813
 814 void wxBitmap::CleanUpHandlers()
 815 {
 816     wxNode *node = sm_handlers.First();
 817     while ( node )
 818     {
 819         wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
 820         wxNode *next = node->Next();
 821         delete handler;
 822         delete node;
 823         node = next;
 824     }
 825 }
 826
 827 void wxBitmap::InitStandardHandlers()
 828 {
 829     // Initialize all standard bitmap or derived class handlers here.
 830     AddHandler(new wxXBMFileHandler);
 831     AddHandler(new wxXBMDataHandler);
 832
 833     // XPM is considered standard for Motif, although it can be omitted if
 834     // libXpm is not installed
 835 #if wxHAVE_LIB_XPM
 836     AddHandler(new wxXPMFileHandler);
 837     AddHandler(new wxXPMDataHandler);
 838 #endif // wxHAVE_LIB_XPM
 839 }
 840
 841 WXPixmap wxBitmap::GetLabelPixmap (WXWidget w)
 842 {
 843     if (M_BITMAPDATA->m_image == (WXPixmap) 0)
 844         return M_BITMAPDATA->m_pixmap;
 845
 846     Display *dpy = (Display*) M_BITMAPDATA->m_display;
 847
 848 #ifdef FOO
 849     /*
 850     If we do:
 851     if (labelPixmap) return labelPixmap;
 852     things can be wrong, because colors can have been changed.
 853
 854       If we do:
 855       if (labelPixmap)
 856       XmDestroyPixmap(DefaultScreenOfDisplay(dpy),labelPixmap) ;
 857       we got BadDrawable if the pixmap is referenced by multiples widgets
 858
 859         this is a catch22!!
 860
 861       So, before doing thing really clean, I just do nothing; if the pixmap is
 862       referenced by many widgets, Motif performs caching functions.
 863       And if pixmap is referenced with multiples colors, we just have some
 864       memory leaks... I hope we can deal with them...
 865     */
 866     // Must be destroyed, because colours can have been changed!
 867     if (M_BITMAPDATA->m_labelPixmap)
 868         XmDestroyPixmap (DefaultScreenOfDisplay (dpy), M_BITMAPDATA->m_labelPixmap);
 869 #endif
 870
 871     char tmp[128];
 872     sprintf (tmp, "Im%x", (unsigned int) M_BITMAPDATA->m_image);
 873
 874     Pixel fg, bg;
 875     Widget widget = (Widget) w;
 876
 877     while (XmIsGadget ( widget ))
 878         widget = XtParent (widget);
 879     XtVaGetValues (widget, XmNbackground, &bg, XmNforeground, &fg, NULL);
 880
 881     M_BITMAPDATA->m_labelPixmap = (WXPixmap) XmGetPixmap (DefaultScreenOfDisplay (dpy), tmp, fg, bg);
 882
 883     return M_BITMAPDATA->m_labelPixmap;
 884 }
 885
 886 WXPixmap wxBitmap::GetArmPixmap (WXWidget w)
 887 {
 888     if (M_BITMAPDATA->m_image == (WXPixmap) 0)
 889         return M_BITMAPDATA->m_pixmap;
 890
 891     Display *dpy = (Display*) M_BITMAPDATA->m_display;
 892 #ifdef FOO
 893     // See GetLabelPixmap () comment
 894
 895     // Must be destroyed, because colours can have been changed!
 896     if (M_BITMAPDATA->m_armPixmap)
 897         XmDestroyPixmap (DefaultScreenOfDisplay (dpy), M_BITMAPDATA->m_armPixmap);
 898 #endif
 899
 900     char tmp[128];
 901     sprintf (tmp, "Im%x", (unsigned int) M_BITMAPDATA->m_image);
 902
 903     Pixel fg, bg;
 904     Widget widget = (Widget) w;
 905
 906     XtVaGetValues (widget, XmNarmColor, &bg, NULL);
 907     while (XmIsGadget (widget))
 908         widget = XtParent (widget);
 909     XtVaGetValues (widget, XmNforeground, &fg, NULL);
 910
 911     M_BITMAPDATA->m_armPixmap = (WXPixmap) XmGetPixmap (DefaultScreenOfDisplay (dpy), tmp, fg, bg);
 912
 913     return M_BITMAPDATA->m_armPixmap;
 914 }
 915
 916 WXPixmap wxBitmap::GetInsensPixmap (WXWidget w)
 917 {
 918     Display *dpy = (Display*) M_BITMAPDATA->m_display;
 919
 920     if (M_BITMAPDATA->m_insensPixmap)
 921         return M_BITMAPDATA->m_insensPixmap;
 922
 923     if (!w)
 924     {
 925         M_BITMAPDATA->m_insensPixmap = (WXPixmap) XCreateInsensitivePixmap(dpy, (Pixmap) M_BITMAPDATA->m_pixmap);
 926         if (M_BITMAPDATA->m_insensPixmap)
 927             return M_BITMAPDATA->m_insensPixmap;
 928         else
 929             return M_BITMAPDATA->m_pixmap;
 930     }
 931
 932     if (M_BITMAPDATA->m_insensImage == (WXPixmap) 0)
 933         return M_BITMAPDATA->m_pixmap;
 934
 935 #ifdef FOO
 936     See GetLabelPixmap () comment
 937         // Must be destroyed, because colours can have been changed!
 938         if (M_BITMAPDATA->m_insensPixmap)
 939             XmDestroyPixmap (DefaultScreenOfDisplay (dpy), (Pixmap) M_BITMAPDATA->m_insensPixmap);
 940 #endif
 941
 942     char tmp[128];
 943     sprintf (tmp, "Not%x", (unsigned int) M_BITMAPDATA->m_insensImage);
 944
 945     Pixel fg, bg;
 946     Widget widget = (Widget) w;
 947
 948     while (XmIsGadget (widget))
 949         widget = XtParent (widget);
 950     XtVaGetValues (widget, XmNbackground, &bg, XmNforeground, &fg, NULL);
 951
 952     M_BITMAPDATA->m_insensPixmap = (WXPixmap) XmGetPixmap (DefaultScreenOfDisplay (dpy), tmp, fg, bg);
 953
 954     return M_BITMAPDATA->m_insensPixmap;
 955 }
 956
 957 // We may need this sometime...
 958
 959 /****************************************************************************
 960
 961   NAME
 962   XCreateInsensitivePixmap - create a grayed-out copy of a pixmap
 963
 964   SYNOPSIS
 965   Pixmap XCreateInsensitivePixmap( Display *display, Pixmap pixmap )
 966
 967   DESCRIPTION
 968   This function creates a grayed-out copy of the argument pixmap, suitable
 969   for use as a XmLabel's XmNlabelInsensitivePixmap resource.
 970
 971   RETURN VALUES
 972   The return value is the new Pixmap id or zero on error.  Errors include
 973   a NULL display argument or an invalid Pixmap argument.
 974
 975   ERRORS
 976   If one of the XLib functions fail, it will produce a X error.  The
 977   default X error handler prints a diagnostic and calls exit().
 978
 979   SEE ALSO
 980   XCopyArea(3), XCreateBitmapFromData(3), XCreateGC(3), XCreatePixmap(3),
 981   XFillRectangle(3), exit(2)
 982
 983   AUTHOR
 984   John R Veregge - john@puente.jpl.nasa.gov
 985   Advanced Engineering and Prototyping Group (AEG)
 986   Information Systems Technology Section (395)
 987   Jet Propulsion Lab - Calif Institute of Technology
 988
 989 *****************************************************************************/
 990
 991 Pixmap
 992 XCreateInsensitivePixmap( Display *display, Pixmap pixmap )
 993
 994 {
 995     static char stipple_data[] =
 996         {
 997             0x55, 0x55, 0xAA, 0xAA, 0x55, 0x55, 0xAA, 0xAA,
 998             0x55, 0x55, 0xAA, 0xAA, 0x55, 0x55, 0xAA, 0xAA,
 999             0x55, 0x55, 0xAA, 0xAA, 0x55, 0x55, 0xAA, 0xAA,
1000             0x55, 0x55, 0xAA, 0xAA, 0x55, 0x55, 0xAA, 0xAA
1001         };
1002     GC        gc;
1003     Pixmap    ipixmap, stipple;
1004     unsigned    width, height, depth;
1005
1006     Window    window;    /* These return values */
1007     unsigned    border;    /* from XGetGeometry() */
1008     int        x, y;    /* are not needed.     */
1009
1010     ipixmap = 0;
1011
1012     if ( NULL == display || 0 == pixmap )
1013         return ipixmap;
1014
1015     if ( 0 == XGetGeometry( display, pixmap, &window, &x, &y,
1016                 &width, &height, &border, &depth )
1017        )
1018         return ipixmap; /* BadDrawable: probably an invalid pixmap */
1019
1020     /* Get the stipple pixmap to be used to 'gray-out' the argument pixmap.
1021      */
1022     stipple = XCreateBitmapFromData( display, pixmap, stipple_data, 16, 16 );
1023     if ( 0 != stipple )
1024     {
1025         gc = XCreateGC( display, pixmap, (XtGCMask)0, (XGCValues*)NULL );
1026         if ( NULL != gc )
1027         {
1028             /* Create an identical copy of the argument pixmap.
1029              */
1030             ipixmap = XCreatePixmap( display, pixmap, width, height, depth );
1031             if ( 0 != ipixmap )
1032             {
1033                 /* Copy the argument pixmap into the new pixmap.
1034                  */
1035                 XCopyArea( display, pixmap, ipixmap,
1036                         gc, 0, 0, width, height, 0, 0 );
1037
1038                 /* Refill the new pixmap using the stipple algorithm/pixmap.
1039                  */
1040                 XSetStipple( display, gc, stipple );
1041                 XSetFillStyle( display, gc, FillStippled );
1042                 XFillRectangle( display, ipixmap, gc, 0, 0, width, height );
1043             }
1044             XFreeGC( display, gc );
1045         }
1046         XFreePixmap( display, stipple );
1047     }
1048     return ipixmap;
1049 }
1050
1051 // Creates a bitmap with transparent areas drawn in
1052 // the given colour.
1053 wxBitmap wxCreateMaskedBitmap(const wxBitmap& bitmap, wxColour& colour)
1054 {
1055     wxBitmap newBitmap(bitmap.GetWidth(),
1056         bitmap.GetHeight(),
1057         bitmap.GetDepth());
1058     wxMemoryDC destDC;
1059     wxMemoryDC srcDC;
1060     srcDC.SelectObject(bitmap);
1061     destDC.SelectObject(newBitmap);
1062
1063     wxBrush brush(colour, wxSOLID);
1064     destDC.SetOptimization(FALSE);
1065     destDC.SetBackground(brush);
1066     destDC.Clear();
1067     destDC.Blit(0, 0, bitmap.GetWidth(), bitmap.GetHeight(), & srcDC, 0, 0, wxCOPY, TRUE);
1068
1069     return newBitmap;
1070 }
1071
1072
1073
1074
1075 //-----------------------------------------------------------------------------
1076 // wxImage conversion routines
1077 //-----------------------------------------------------------------------------
1078
1079 /*
1080
1081 Date: Wed, 05 Jan 2000 11:45:40 +0100
1082 From: Frits Boel <boel@niob.knaw.nl>
1083 To: julian.smart@ukonline.co.uk
1084 Subject: Patch for Motif ConvertToBitmap
1085
1086 Hi Julian,
1087
1088 I've been working on a wxWin application for image processing. From the
1089 beginning, I was surprised by the (lack of) speed of ConvertToBitmap,
1090 till I looked in the source code of image.cpp. I saw that converting a
1091 wxImage to a bitmap with 8-bit pixels is done with comparing every pixel
1092 to the 256 colors of the palet. A very time-consuming piece of code!
1093
1094 Because I wanted a faster application, I've made a 'patch' for this. In
1095 short: every pixel of the image is compared to a sorted list with
1096 colors. If the color is found in the list, the palette entry is
1097 returned; if the color is not found, the color palette is searched and
1098 then the palette entry is returned and the color added to the sorted
1099 list.
1100
1101 Maybe there is another method for this, namely changing the palette
1102 itself (if the colors are known, as is the case with tiffs with a
1103 colormap). I did not look at this, maybe someone else did?
1104
1105 The code of the patch is attached, have a look on it, and maybe you will
1106 ship it with the next release of wxMotif?
1107
1108 Regards,
1109
1110 Frits Boel
1111 Software engineer at Hubrecht Laboratory, The Netherlands.
1112
1113 */
1114
1115 class wxSearchColor
1116 {
1117 public:
1118   wxSearchColor( void );
1119   wxSearchColor( int size, XColor *colors );
1120   ~wxSearchColor( void );
1121
1122   int SearchColor( int r, int g, int b );
1123 private:
1124   int AddColor( unsigned int value, int pos );
1125
1126   int          size;
1127   XColor       *colors;
1128   unsigned int *color;
1129   int          *entry;
1130
1131   int bottom;
1132   int top;
1133 };
1134
1135 wxSearchColor::wxSearchColor( void )
1136 {
1137   size   = 0;
1138   colors = (XColor*) NULL;
1139   color  = (unsigned int *) NULL;
1140   entry  = (int*) NULL;
1141
1142   bottom = 0;
1143   top    = 0;
1144 }
1145
1146 wxSearchColor::wxSearchColor( int size_, XColor *colors_ )
1147 {
1148     int i;
1149     size   = size_;
1150     colors = colors_;
1151     color  = new unsigned int[size];
1152     entry  = new int         [size];
1153
1154     for (i = 0; i < size; i++ ) {
1155         entry[i] = -1;
1156     }
1157
1158     bottom = top = ( size >> 1 );
1159 }
1160
1161 wxSearchColor::~wxSearchColor( void )
1162 {
1163   if ( color ) delete color;
1164   if ( entry ) delete entry;
1165 }
1166
1167 int wxSearchColor::SearchColor( int r, int g, int b )
1168 {
1169   unsigned int value = ( ( ( r * 256 ) + g ) * 256 ) + b;
1170   int          begin = bottom;
1171   int          end   = top;
1172   int          middle = 0;
1173
1174   while ( begin <= end ) {
1175
1176     middle = ( begin + end ) >> 1;
1177
1178     if ( value == color[middle] ) {
1179       return( entry[middle] );
1180     } else if ( value < color[middle] ) {
1181       end = middle - 1;
1182     } else {
1183       begin = middle + 1;
1184     }
1185
1186   }
1187
1188   return AddColor( value, middle );
1189 }
1190
1191 int wxSearchColor::AddColor( unsigned int value, int pos )
1192 {
1193   int i;
1194   int pixel = -1;
1195   int max = 3 * (65536);
1196   for ( i = 0; i < 256; i++ ) {
1197     int rdiff = ((value >> 8) & 0xFF00 ) - colors[i].red;
1198     int gdiff = ((value     ) & 0xFF00 ) - colors[i].green;
1199     int bdiff = ((value << 8) & 0xFF00 ) - colors[i].blue;
1200     int sum = abs (rdiff) + abs (gdiff) + abs (bdiff);
1201     if (sum < max) { pixel = i; max = sum; }
1202   }
1203
1204   if ( entry[pos] < 0 ) {
1205     color[pos] = value;
1206     entry[pos] = pixel;
1207   } else if ( value < color[pos] ) {
1208
1209     if ( bottom > 0 ) {
1210       for ( i = bottom; i < pos; i++ ) {
1211         color[i-1] = color[i];
1212         entry[i-1] = entry[i];
1213       }
1214       bottom--;
1215       color[pos-1] = value;
1216       entry[pos-1] = pixel;
1217     } else if ( top < size-1 ) {
1218       for ( i = top; i >= pos; i-- ) {
1219         color[i+1] = color[i];
1220         entry[i+1] = entry[i];
1221       }
1222       top++;
1223       color[pos] = value;
1224       entry[pos] = pixel;
1225     }
1226
1227   } else {
1228
1229     if ( top < size-1 ) {
1230       for ( i = top; i > pos; i-- ) {
1231         color[i+1] = color[i];
1232         entry[i+1] = entry[i];
1233       }
1234       top++;
1235       color[pos+1] = value;
1236       entry[pos+1] = pixel;
1237     } else if ( bottom > 0 ) {
1238       for ( i = bottom; i < pos; i++ ) {
1239         color[i-1] = color[i];
1240         entry[i-1] = entry[i];
1241       }
1242       bottom--;
1243       color[pos] = value;
1244       entry[pos] = pixel;
1245     }
1246
1247   }
1248
1249   return( pixel );
1250 }
1251
1252
1253 bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
1254 {
1255     wxCHECK_MSG( image.Ok(), FALSE, wxT("invalid image") )
1256     wxCHECK_MSG( depth == -1, FALSE, wxT("invalid bitmap depth") )
1257
1258     m_refData = new wxBitmapRefData();
1259
1260     if (wxTheBitmapList) wxTheBitmapList->AddBitmap(this);
1261
1262     int width = image.GetWidth();
1263     int height = image.GetHeight();
1264
1265     SetHeight( height );
1266     SetWidth( width );
1267
1268     Display *dpy = (Display*) wxGetDisplay();
1269     Visual* vis = DefaultVisual( dpy, DefaultScreen( dpy ) );
1270     int bpp = DefaultDepth( dpy, DefaultScreen( dpy ) );
1271
1272     // Create image
1273
1274     XImage *data_image = XCreateImage( dpy, vis, bpp, ZPixmap, 0, 0, width, height, 32, 0 );
1275     data_image->data = (char*) malloc( data_image->bytes_per_line * data_image->height );
1276
1277     Create( width, height, bpp );
1278
1279     // Create mask
1280
1281     XImage *mask_image = (XImage*) NULL;
1282     if (image.HasMask())
1283     {
1284         mask_image = XCreateImage( dpy, vis, 1, ZPixmap, 0, 0, width, height, 32, 0 );
1285         mask_image->data = (char*) malloc( mask_image->bytes_per_line * mask_image->height );
1286     }
1287
1288     // Retrieve depth info
1289
1290     XVisualInfo vinfo_template;
1291     XVisualInfo *vi;
1292
1293     vinfo_template.visual = vis;
1294     vinfo_template.visualid = XVisualIDFromVisual( vis );
1295     vinfo_template.depth = bpp;
1296     int nitem = 0;
1297
1298     vi = XGetVisualInfo( dpy, VisualIDMask|VisualDepthMask, &vinfo_template, &nitem );
1299
1300     wxCHECK_MSG( vi, FALSE, wxT("no visual") );
1301
1302     XFree( vi );
1303
1304     if ((bpp == 16) && (vi->red_mask != 0xf800)) bpp = 15;
1305     if (bpp < 8) bpp = 8;
1306
1307     // Render
1308
1309     enum byte_order { RGB, RBG, BRG, BGR, GRB, GBR };
1310     byte_order b_o = RGB;
1311
1312     if (bpp >= 24)
1313     {
1314         if ((vi->red_mask > vi->green_mask) && (vi->green_mask > vi->blue_mask))      b_o = RGB;
1315         else if ((vi->red_mask > vi->blue_mask) && (vi->blue_mask > vi->green_mask))  b_o = RGB;
1316         else if ((vi->blue_mask > vi->red_mask) && (vi->red_mask > vi->green_mask))   b_o = BRG;
1317         else if ((vi->blue_mask > vi->green_mask) && (vi->green_mask > vi->red_mask)) b_o = BGR;
1318         else if ((vi->green_mask > vi->red_mask) && (vi->red_mask > vi->blue_mask))   b_o = GRB;
1319         else if ((vi->green_mask > vi->blue_mask) && (vi->blue_mask > vi->red_mask))  b_o = GBR;
1320     }
1321
1322     int r_mask = image.GetMaskRed();
1323     int g_mask = image.GetMaskGreen();
1324     int b_mask = image.GetMaskBlue();
1325
1326     XColor colors[256];
1327     if (bpp == 8)
1328     {
1329         Colormap cmap = (Colormap) wxTheApp->GetMainColormap( dpy );
1330
1331         for (int i = 0; i < 256; i++) colors[i].pixel = i;
1332         XQueryColors( dpy, cmap, colors, 256 );
1333     }
1334
1335     wxSearchColor scolor( 256, colors );
1336     unsigned char* data = image.GetData();
1337
1338     bool hasMask = image.HasMask();
1339
1340     int index = 0;
1341     for (int y = 0; y < height; y++)
1342     {
1343         for (int x = 0; x < width; x++)
1344         {
1345             int r = data[index];
1346             index++;
1347             int g = data[index];
1348             index++;
1349             int b = data[index];
1350             index++;
1351
1352             if (hasMask)
1353             {
1354               if ((r == r_mask) && (b == b_mask) && (g == g_mask))
1355                 XPutPixel( mask_image, x, y, 0 );
1356               else
1357                 XPutPixel( mask_image, x, y, 1 );
1358             }
1359
1360             switch (bpp)
1361             {
1362             case 8:
1363                 {
1364 #if 0 // Old, slower code
1365                     int pixel = -1;
1366                     /*
1367                     if (wxTheApp->m_colorCube)
1368                     {
1369                     pixel = wxTheApp->m_colorCube
1370                     [ ((r & 0xf8) << 7) + ((g & 0xf8) << 2) + ((b & 0xf8) >> 3) ];
1371                     }
1372                     else
1373                     {
1374                     */
1375                     int max = 3 * (65536);
1376                     for (int i = 0; i < 256; i++)
1377                     {
1378                         int rdiff = (r << 8) - colors[i].red;
1379                         int gdiff = (g << 8) - colors[i].green;
1380                         int bdiff = (b << 8) - colors[i].blue;
1381                         int sum = abs (rdiff) + abs (gdiff) + abs (bdiff);
1382                         if (sum < max) { pixel = i; max = sum; }
1383                     }
1384                     /*
1385                     }
1386                     */
1387 #endif
1388
1389                     // And this is all to get the 'right' color...
1390                     int pixel = scolor.SearchColor( r, g, b );
1391                     XPutPixel( data_image, x, y, pixel );
1392                     break;
1393                 }
1394             case 15:
1395                 {
1396                     int pixel = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
1397                     XPutPixel( data_image, x, y, pixel );
1398                     break;
1399                 }
1400             case 16:
1401                 {
1402                     int pixel = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
1403                     XPutPixel( data_image, x, y, pixel );
1404                     break;
1405                 }
1406             case 32:
1407             case 24:
1408                 {
1409                     int pixel = 0;
1410                     switch (b_o)
1411                     {
1412                     case RGB: pixel = (r << 16) | (g << 8) | b; break;
1413                     case RBG: pixel = (r << 16) | (b << 8) | g; break;
1414                     case BRG: pixel = (b << 16) | (r << 8) | g; break;
1415                     case BGR: pixel = (b << 16) | (g << 8) | r; break;
1416                     case GRB: pixel = (g << 16) | (r << 8) | b; break;
1417                     case GBR: pixel = (g << 16) | (b << 8) | r; break;
1418                     }
1419                     XPutPixel( data_image, x, y, pixel );
1420                 }
1421             default: break;
1422             }
1423         } // for
1424     }  // for
1425
1426     // Blit picture
1427
1428     XGCValues gcvalues;
1429     gcvalues.foreground = BlackPixel( dpy, DefaultScreen( dpy ) );
1430     GC gc = XCreateGC( dpy, RootWindow ( dpy, DefaultScreen(dpy) ), GCForeground, &gcvalues );
1431     XPutImage( dpy, (Drawable)GetPixmap(), gc, data_image, 0, 0, 0, 0, width, height );
1432
1433     XDestroyImage( data_image );
1434     XFreeGC( dpy, gc );
1435
1436     // Blit mask
1437     if (image.HasMask())
1438     {
1439         wxBitmap maskBitmap(width, height, 1);
1440
1441         GC gcMask = XCreateGC( dpy, (Pixmap) maskBitmap.GetPixmap(), (XtGCMask) 0, (XGCValues*)NULL );
1442         XPutImage( dpy, (Drawable)maskBitmap.GetPixmap(), gcMask, mask_image, 0, 0, 0, 0, width, height );
1443
1444         XDestroyImage( mask_image );
1445         XFreeGC( dpy, gcMask );
1446
1447         wxMask* mask = new wxMask;
1448         mask->SetPixmap(maskBitmap.GetPixmap());
1449
1450         SetMask(mask);
1451
1452         maskBitmap.SetPixmapNull();
1453     }
1454
1455
1456     return TRUE;
1457 }
1458
1459 wxImage wxBitmap::ConvertToImage() const
1460 {
1461     wxImage image;
1462
1463     wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
1464
1465     Display *dpy = (Display*) wxGetDisplay();
1466     Visual* vis = DefaultVisual( dpy, DefaultScreen( dpy ) );
1467     int bpp = DefaultDepth( dpy, DefaultScreen( dpy ) );
1468
1469     XImage *ximage = XGetImage( dpy,
1470         (Drawable)GetPixmap(),
1471         0, 0,
1472         GetWidth(), GetHeight(),
1473         AllPlanes, ZPixmap );
1474
1475     wxCHECK_MSG( ximage, wxNullImage, wxT("couldn't create image") );
1476
1477     image.Create( GetWidth(), GetHeight() );
1478     char unsigned *data = image.GetData();
1479
1480     if (!data)
1481     {
1482         XDestroyImage( ximage );
1483         wxFAIL_MSG( wxT("couldn't create image") );
1484         return wxNullImage;
1485     }
1486
1487     /*
1488     GdkImage *gdk_image_mask = (GdkImage*) NULL;
1489     if (GetMask())
1490     {
1491     gdk_image_mask = gdk_image_get( GetMask()->GetBitmap(),
1492     0, 0,
1493     GetWidth(), GetHeight() );
1494
1495       image.SetMaskColour( 16, 16, 16 );  // anything unlikely and dividable
1496       }
1497     */
1498
1499     // Retrieve depth info
1500
1501     XVisualInfo vinfo_template;
1502     XVisualInfo *vi;
1503
1504     vinfo_template.visual = vis;
1505     vinfo_template.visualid = XVisualIDFromVisual( vis );
1506     vinfo_template.depth = bpp;
1507     int nitem = 0;
1508
1509     vi = XGetVisualInfo( dpy, VisualIDMask|VisualDepthMask, &vinfo_template, &nitem );
1510
1511     wxCHECK_MSG( vi, wxNullImage, wxT("no visual") );
1512
1513     if ((bpp == 16) && (vi->red_mask != 0xf800)) bpp = 15;
1514
1515     XFree( vi );
1516
1517     XColor colors[256];
1518     if (bpp == 8)
1519     {
1520         Colormap cmap = (Colormap)wxTheApp->GetMainColormap( dpy );
1521
1522         for (int i = 0; i < 256; i++) colors[i].pixel = i;
1523         XQueryColors( dpy, cmap, colors, 256 );
1524     }
1525
1526     long pos = 0;
1527     for (int j = 0; j < GetHeight(); j++)
1528     {
1529         for (int i = 0; i < GetWidth(); i++)
1530         {
1531             int pixel = XGetPixel( ximage, i, j );
1532             if (bpp <= 8)
1533             {
1534                 data[pos] = colors[pixel].red >> 8;
1535                 data[pos+1] = colors[pixel].green >> 8;
1536                 data[pos+2] = colors[pixel].blue >> 8;
1537             } else if (bpp == 15)
1538             {
1539                 data[pos] = (pixel >> 7) & 0xf8;
1540                 data[pos+1] = (pixel >> 2) & 0xf8;
1541                 data[pos+2] = (pixel << 3) & 0xf8;
1542             } else if (bpp == 16)
1543             {
1544                 data[pos] = (pixel >> 8) & 0xf8;
1545                 data[pos+1] = (pixel >> 3) & 0xfc;
1546                 data[pos+2] = (pixel << 3) & 0xf8;
1547             } else
1548             {
1549                 data[pos] = (pixel >> 16) & 0xff;
1550                 data[pos+1] = (pixel >> 8) & 0xff;
1551                 data[pos+2] = pixel & 0xff;
1552             }
1553
1554             /*
1555             if (gdk_image_mask)
1556             {
1557             int mask_pixel = gdk_image_get_pixel( gdk_image_mask, i, j );
1558             if (mask_pixel == 0)
1559             {
1560             data[pos] = 16;
1561             data[pos+1] = 16;
1562             data[pos+2] = 16;
1563             }
1564             }
1565             */
1566
1567             pos += 3;
1568         }
1569     }
1570
1571     XDestroyImage( ximage );
1572     /*
1573     if (gdk_image_mask) gdk_image_destroy( gdk_image_mask );
1574     */
1575
1576     return image;
1577 }