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 #include "wx/setup.h"
  17 #include "wx/utils.h"
  18 #include "wx/palette.h"
  19 #include "wx/bitmap.h"
  20 #include "wx/icon.h"
  21 #include "wx/log.h"
  22 #include "wx/control.h"
  23 #include "wx/dcmemory.h"
  24
  25 #include <Xm/Xm.h>
  26
  27 #include "wx/motif/private.h"
  28
  29 // TODO: correct symbol, path?
  30 #if wxUSE_XPM
  31 #include <X11/xpm.h>
  32 #endif
  33
  34 #if !USE_SHARED_LIBRARIES
  35 IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
  36 IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
  37 #endif
  38
  39 wxBitmapRefData::wxBitmapRefData()
  40 {
  41     m_ok = FALSE;
  42     m_width = 0;
  43     m_height = 0;
  44     m_depth = 0;
  45     m_quality = 0;
  46     m_numColors = 0;
  47     m_bitmapMask = NULL;
  48
  49     m_pixmap = (WXPixmap) 0;
  50     m_display = (WXDisplay*) 0;
  51
  52     m_freePixmap = TRUE; //TODO: necessary?
  53     m_freeColors = (unsigned long*) 0;
  54     m_freeColorsCount = 0;
  55
  56     // These 5 variables are for wxControl
  57     m_insensPixmap = (WXPixmap) 0;
  58     m_labelPixmap = (WXPixmap) 0;
  59     m_armPixmap = (WXPixmap) 0;
  60     m_image = (WXImage*) 0;
  61     m_insensImage = (WXImage*) 0;
  62 }
  63
  64 wxBitmapRefData::~wxBitmapRefData()
  65 {
  66     if (m_labelPixmap)
  67         XmDestroyPixmap (DefaultScreenOfDisplay ((Display*) m_display), (Pixmap) m_labelPixmap);
  68
  69     if (m_armPixmap)
  70         XmDestroyPixmap (DefaultScreenOfDisplay ((Display*) m_display), (Pixmap) m_armPixmap);
  71
  72     if (m_insensPixmap)
  73         XmDestroyPixmap (DefaultScreenOfDisplay ((Display*) m_display), (Pixmap) m_insensPixmap);
  74
  75     if (m_image)
  76     {
  77         XmUninstallImage ((XImage*) m_image);
  78         XtFree ((char *) (XImage*) m_image);
  79     }
  80
  81     if (m_insensImage)
  82     {
  83         XmUninstallImage ((XImage*) m_insensImage);
  84         delete[] ((XImage*) m_insensImage)->data;
  85         XtFree ((char *) (XImage*) m_insensImage);
  86     }
  87     if (m_pixmap && m_freePixmap)
  88         XFreePixmap ((Display*) m_display, (Pixmap) m_pixmap);
  89
  90     if (m_freeColors)
  91     {
  92        int screen = DefaultScreen((Display*) m_display);
  93        Colormap cmp = DefaultColormap((Display*) m_display,screen);
  94        long llp;
  95        for(llp = 0;llp < m_freeColorsCount;llp++)
  96           XFreeColors((Display*) m_display, cmp, &m_freeColors[llp], 1, 0L);
  97        delete m_freeColors;
  98     };
  99
 100     if (m_bitmapMask)
 101         delete m_bitmapMask;
 102     m_bitmapMask = NULL;
 103 }
 104
 105 wxList wxBitmap::sm_handlers;
 106
 107 wxBitmap::wxBitmap()
 108 {
 109     m_refData = NULL;
 110
 111     if ( wxTheBitmapList )
 112         wxTheBitmapList->AddBitmap(this);
 113 }
 114
 115 wxBitmap::~wxBitmap()
 116 {
 117     if (wxTheBitmapList)
 118         wxTheBitmapList->DeleteObject(this);
 119 }
 120
 121 wxBitmap::wxBitmap(const char bits[], int width, int height, int depth)
 122 {
 123     m_refData = new wxBitmapRefData;
 124
 125     (void) Create((void*) bits, wxBITMAP_TYPE_XBM_DATA, width, height, depth);
 126
 127     if ( wxTheBitmapList )
 128         wxTheBitmapList->AddBitmap(this);
 129 }
 130
 131 wxBitmap::wxBitmap(int w, int h, int d)
 132 {
 133     (void)Create(w, h, d);
 134
 135     if ( wxTheBitmapList )
 136         wxTheBitmapList->AddBitmap(this);
 137 }
 138
 139 wxBitmap::wxBitmap(void *data, long type, int width, int height, int depth)
 140 {
 141     (void) Create(data, type, width, height, depth);
 142
 143     if ( wxTheBitmapList )
 144         wxTheBitmapList->AddBitmap(this);
 145 }
 146
 147 wxBitmap::wxBitmap(const wxString& filename, long type)
 148 {
 149     LoadFile(filename, (int)type);
 150
 151     if ( wxTheBitmapList )
 152         wxTheBitmapList->AddBitmap(this);
 153 }
 154
 155 // Create from XPM data
 156 static wxControl* sg_Control = NULL;
 157 wxBitmap::wxBitmap(char **data, wxControl* control)
 158 {
 159     // Pass the control to the Create function using a global
 160     sg_Control = control;
 161
 162     (void) Create((void *)data, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0);
 163
 164     sg_Control = (wxControl*) NULL;
 165 }
 166
 167 bool wxBitmap::Create(int w, int h, int d)
 168 {
 169     UnRef();
 170
 171     m_refData = new wxBitmapRefData;
 172
 173     if (d < 1)
 174       d = wxDisplayDepth();
 175
 176     M_BITMAPDATA->m_width = w;
 177     M_BITMAPDATA->m_height = h;
 178     M_BITMAPDATA->m_depth = d;
 179     M_BITMAPDATA->m_freePixmap = TRUE;
 180
 181     Display *dpy = (Display*) wxGetDisplay();
 182
 183     M_BITMAPDATA->m_display = dpy; /* MATTHEW: [4] Remember the display */
 184
 185     M_BITMAPDATA->m_pixmap = (WXPixmap) XCreatePixmap (dpy, RootWindow (dpy, DefaultScreen (dpy)),
 186                                 w, h, d);
 187
 188     M_BITMAPDATA->m_ok = (M_BITMAPDATA->m_pixmap != (WXPixmap) 0) ;
 189     return M_BITMAPDATA->m_ok;
 190 }
 191
 192 bool wxBitmap::LoadFile(const wxString& filename, long type)
 193 {
 194     UnRef();
 195
 196     m_refData = new wxBitmapRefData;
 197
 198     wxBitmapHandler *handler = FindHandler(type);
 199
 200     if ( handler == NULL ) {
 201         wxLogWarning("no bitmap handler for type %d defined.", type);
 202
 203         return FALSE;
 204     }
 205
 206     return handler->LoadFile(this, filename, type, -1, -1);
 207 }
 208
 209 bool wxBitmap::Create(void *data, long type, int width, int height, int depth)
 210 {
 211     UnRef();
 212
 213     m_refData = new wxBitmapRefData;
 214
 215     wxBitmapHandler *handler = FindHandler(type);
 216
 217     if ( handler == NULL ) {
 218         wxLogWarning("no bitmap handler for type %d defined.", type);
 219
 220         return FALSE;
 221     }
 222
 223     return handler->Create(this, data, type, width, height, depth);
 224 }
 225
 226 bool wxBitmap::SaveFile(const wxString& filename, int type, const wxPalette *palette)
 227 {
 228     wxBitmapHandler *handler = FindHandler(type);
 229
 230     if ( handler == NULL ) {
 231         wxLogWarning("no bitmap handler for type %d defined.", type);
 232
 233         return FALSE;
 234   }
 235
 236   return handler->SaveFile(this, filename, type, palette);
 237 }
 238
 239 void wxBitmap::SetWidth(int w)
 240 {
 241     if (!M_BITMAPDATA)
 242         m_refData = new wxBitmapRefData;
 243
 244     M_BITMAPDATA->m_width = w;
 245 }
 246
 247 void wxBitmap::SetHeight(int h)
 248 {
 249     if (!M_BITMAPDATA)
 250         m_refData = new wxBitmapRefData;
 251
 252     M_BITMAPDATA->m_height = h;
 253 }
 254
 255 void wxBitmap::SetDepth(int d)
 256 {
 257     if (!M_BITMAPDATA)
 258         m_refData = new wxBitmapRefData;
 259
 260     M_BITMAPDATA->m_depth = d;
 261 }
 262
 263 void wxBitmap::SetQuality(int q)
 264 {
 265     if (!M_BITMAPDATA)
 266         m_refData = new wxBitmapRefData;
 267
 268     M_BITMAPDATA->m_quality = q;
 269 }
 270
 271 void wxBitmap::SetOk(bool isOk)
 272 {
 273     if (!M_BITMAPDATA)
 274         m_refData = new wxBitmapRefData;
 275
 276     M_BITMAPDATA->m_ok = isOk;
 277 }
 278
 279 void wxBitmap::SetPalette(const wxPalette& palette)
 280 {
 281     if (!M_BITMAPDATA)
 282         m_refData = new wxBitmapRefData;
 283
 284     M_BITMAPDATA->m_bitmapPalette = palette ;
 285 }
 286
 287 void wxBitmap::SetMask(wxMask *mask)
 288 {
 289     if (!M_BITMAPDATA)
 290         m_refData = new wxBitmapRefData;
 291
 292     M_BITMAPDATA->m_bitmapMask = mask ;
 293 }
 294
 295 void wxBitmap::AddHandler(wxBitmapHandler *handler)
 296 {
 297     sm_handlers.Append(handler);
 298 }
 299
 300 void wxBitmap::InsertHandler(wxBitmapHandler *handler)
 301 {
 302     sm_handlers.Insert(handler);
 303 }
 304
 305 bool wxBitmap::RemoveHandler(const wxString& name)
 306 {
 307     wxBitmapHandler *handler = FindHandler(name);
 308     if ( handler )
 309     {
 310         sm_handlers.DeleteObject(handler);
 311         return TRUE;
 312     }
 313     else
 314         return FALSE;
 315 }
 316
 317 wxBitmapHandler *wxBitmap::FindHandler(const wxString& name)
 318 {
 319     wxNode *node = sm_handlers.First();
 320     while ( node )
 321     {
 322         wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
 323         if ( handler->GetName() == name )
 324             return handler;
 325         node = node->Next();
 326     }
 327     return NULL;
 328 }
 329
 330 wxBitmapHandler *wxBitmap::FindHandler(const wxString& extension, long bitmapType)
 331 {
 332     wxNode *node = sm_handlers.First();
 333     while ( node )
 334     {
 335         wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
 336         if ( handler->GetExtension() == extension &&
 337                     (bitmapType == -1 || handler->GetType() == bitmapType) )
 338             return handler;
 339         node = node->Next();
 340     }
 341     return NULL;
 342 }
 343
 344 wxBitmapHandler *wxBitmap::FindHandler(long bitmapType)
 345 {
 346     wxNode *node = sm_handlers.First();
 347     while ( node )
 348     {
 349         wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
 350         if (handler->GetType() == bitmapType)
 351             return handler;
 352         node = node->Next();
 353     }
 354     return NULL;
 355 }
 356
 357 /*
 358  * wxMask
 359  */
 360
 361 wxMask::wxMask()
 362 {
 363     m_pixmap = (WXPixmap) 0;
 364 }
 365
 366 // Construct a mask from a bitmap and a colour indicating
 367 // the transparent area
 368 wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour)
 369 {
 370     m_pixmap = (WXPixmap) 0;
 371
 372     Create(bitmap, colour);
 373 }
 374
 375 // Construct a mask from a bitmap and a palette index indicating
 376 // the transparent area
 377 wxMask::wxMask(const wxBitmap& bitmap, int paletteIndex)
 378 {
 379     m_pixmap = (WXPixmap) 0;
 380
 381     Create(bitmap, paletteIndex);
 382 }
 383
 384 // Construct a mask from a mono bitmap (copies the bitmap).
 385 wxMask::wxMask(const wxBitmap& bitmap)
 386 {
 387     m_pixmap = (WXPixmap) 0;
 388
 389     Create(bitmap);
 390 }
 391
 392 wxMask::~wxMask()
 393 {
 394     // TODO: this may be the wrong display
 395     if ( m_pixmap )
 396         XFreePixmap ((Display*) wxGetDisplay(), (Pixmap) m_pixmap);
 397 }
 398
 399 // Create a mask from a mono bitmap (copies the bitmap).
 400 bool wxMask::Create(const wxBitmap& WXUNUSED(bitmap))
 401 {
 402 // TODO
 403     return FALSE;
 404 }
 405
 406 // Create a mask from a bitmap and a palette index indicating
 407 // the transparent area
 408 bool wxMask::Create(const wxBitmap& WXUNUSED(bitmap), int WXUNUSED(paletteIndex))
 409 {
 410 // TODO
 411     return FALSE;
 412 }
 413
 414 // Create a mask from a bitmap and a colour indicating
 415 // the transparent area
 416 bool wxMask::Create(const wxBitmap& WXUNUSED(bitmap), const wxColour& WXUNUSED(colour))
 417 {
 418 // TODO
 419     return FALSE;
 420 }
 421
 422 /*
 423  * wxBitmapHandler
 424  */
 425
 426 IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject)
 427
 428 bool wxBitmapHandler::Create(wxBitmap *WXUNUSED(bitmap), void *WXUNUSED(data), long WXUNUSED(type),
 429    int WXUNUSED(width), int WXUNUSED(height), int WXUNUSED(depth))
 430 {
 431     return FALSE;
 432 }
 433
 434 bool wxBitmapHandler::LoadFile(wxBitmap *WXUNUSED(bitmap), const wxString& WXUNUSED(name), long WXUNUSED(type),
 435         int WXUNUSED(desiredWidth), int WXUNUSED(desiredHeight))
 436 {
 437     return FALSE;
 438 }
 439
 440 bool wxBitmapHandler::SaveFile(wxBitmap *WXUNUSED(bitmap), const wxString& WXUNUSED(name), int WXUNUSED(type),
 441    const wxPalette *WXUNUSED(palette))
 442 {
 443     return FALSE;
 444 }
 445
 446 /*
 447  * Standard handlers
 448  */
 449
 450 class WXDLLEXPORT wxXBMFileHandler: public wxBitmapHandler
 451 {
 452     DECLARE_DYNAMIC_CLASS(wxXBMFileHandler)
 453 public:
 454     inline wxXBMFileHandler()
 455     {
 456         m_name = "XBM file";
 457         m_extension = "xbm";
 458         m_type = wxBITMAP_TYPE_XBM;
 459     };
 460
 461     virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
 462           int desiredWidth, int desiredHeight);
 463 };
 464 IMPLEMENT_DYNAMIC_CLASS(wxXBMFileHandler, wxBitmapHandler)
 465
 466 bool wxXBMFileHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long WXUNUSED(flags),
 467           int WXUNUSED(desiredWidth), int WXUNUSED(desiredHeight))
 468 {
 469     M_BITMAPHANDLERDATA->m_freePixmap = TRUE;
 470
 471     int hotX, hotY;
 472     unsigned int w, h;
 473     Pixmap pixmap;
 474
 475     Display *dpy = (Display*) wxGetDisplay();
 476     M_BITMAPDATA->m_display = (WXDisplay*) dpy;
 477
 478     int value = XReadBitmapFile (dpy, RootWindow (dpy, DefaultScreen (dpy)),
 479                         (char*) (const char*) name, &w, &h, &pixmap, &hotX, &hotY);
 480     M_BITMAPHANDLERDATA->m_width = w;
 481     M_BITMAPHANDLERDATA->m_height = h;
 482     M_BITMAPHANDLERDATA->m_depth = 1;
 483     M_BITMAPHANDLERDATA->m_pixmap = (WXPixmap) pixmap;
 484
 485     if ((value == BitmapFileInvalid) ||
 486         (value == BitmapOpenFailed) ||
 487         (value == BitmapNoMemory))
 488     {
 489         M_BITMAPHANDLERDATA->m_ok = FALSE;
 490         M_BITMAPHANDLERDATA->m_pixmap = (WXPixmap) 0;
 491     }
 492     else
 493         M_BITMAPHANDLERDATA->m_ok = TRUE;
 494
 495     return M_BITMAPHANDLERDATA->m_ok ;
 496 }
 497
 498 class WXDLLEXPORT wxXBMDataHandler: public wxBitmapHandler
 499 {
 500     DECLARE_DYNAMIC_CLASS(wxXBMDataHandler)
 501 public:
 502     inline wxXBMDataHandler()
 503     {
 504         m_name = "XBM data";
 505         m_extension = "xbm";
 506         m_type = wxBITMAP_TYPE_XBM_DATA;
 507     };
 508
 509     virtual bool Create(wxBitmap *bitmap, void *data, long flags, int width, int height, int depth = 1);
 510 };
 511 IMPLEMENT_DYNAMIC_CLASS(wxXBMDataHandler, wxBitmapHandler)
 512
 513 bool wxXBMDataHandler::Create( wxBitmap *bitmap, void *data, long WXUNUSED(flags),
 514                                int width, int height, int WXUNUSED(depth))
 515 {
 516     M_BITMAPHANDLERDATA->m_width = width;
 517     M_BITMAPHANDLERDATA->m_height = height;
 518     M_BITMAPHANDLERDATA->m_depth = 1;
 519     M_BITMAPHANDLERDATA->m_freePixmap = TRUE;
 520
 521     Display *dpy = (Display*) wxGetDisplay();
 522     M_BITMAPHANDLERDATA->m_display = (WXDisplay*) dpy;
 523
 524     M_BITMAPHANDLERDATA->m_pixmap = (WXPixmap) XCreateBitmapFromData (dpy, RootWindow (dpy, DefaultScreen (dpy)), (char*) data, width, height);
 525     M_BITMAPHANDLERDATA->m_ok = (M_BITMAPHANDLERDATA->m_pixmap != (WXPixmap) 0) ;
 526
 527     // code for wxControl. TODO: can we avoid doing this until we need it?
 528     // E.g. have CreateButtonPixmaps which is called on demand.
 529     XImage* image = (XImage *) XtMalloc (sizeof (XImage));
 530     image->width = width;
 531     image->height = height;
 532     image->data = (char*) data;
 533     image->depth = 1;
 534     image->xoffset = 0;
 535     image->format = XYBitmap;
 536     image->byte_order = LSBFirst;
 537     image->bitmap_unit = 8;
 538     image->bitmap_bit_order = LSBFirst;
 539     image->bitmap_pad = 8;
 540     image->bytes_per_line = (width + 7) >> 3;
 541
 542     char tmp[128];
 543     sprintf (tmp, "Im%x", (unsigned int) image);
 544     XmInstallImage (image, tmp);
 545
 546     // Build our manually stipped pixmap.
 547
 548     int bpl = (width + 7) / 8;
 549     char *data1 = new char[height * bpl];
 550     char* bits = (char*) data;
 551     int i;
 552     for (i = 0; i < height; i++)
 553     {
 554         int mask = i % 2 ? 0x55 : 0xaa;
 555         int j;
 556         for (j = 0; j < bpl; j++)
 557             data1[i * bpl + j] = bits[i * bpl + j] & mask;
 558     }
 559     XImage* insensImage = (XImage *) XtMalloc (sizeof (XImage));
 560     insensImage->width = width;
 561     insensImage->height = height;
 562     insensImage->data = data1;
 563     insensImage->depth = 1;
 564     insensImage->xoffset = 0;
 565     insensImage->format = XYBitmap;
 566     insensImage->byte_order = LSBFirst;
 567     insensImage->bitmap_unit = 8;
 568     insensImage->bitmap_bit_order = LSBFirst;
 569     insensImage->bitmap_pad = 8;
 570     insensImage->bytes_per_line = bpl;
 571
 572     sprintf (tmp, "Not%x", (unsigned int)insensImage);
 573     XmInstallImage (insensImage, tmp);
 574
 575     M_BITMAPHANDLERDATA->m_image = (WXImage*) image;
 576     M_BITMAPHANDLERDATA->m_insensImage = (WXImage*) insensImage;
 577
 578     return TRUE;
 579 }
 580
 581 #if wxUSE_XPM
 582 class WXDLLEXPORT wxXPMFileHandler: public wxBitmapHandler
 583 {
 584     DECLARE_DYNAMIC_CLASS(wxXPMFileHandler)
 585 public:
 586     inline wxXPMFileHandler()
 587     {
 588         m_name = "XPM file";
 589         m_extension = "xpm";
 590         m_type = wxBITMAP_TYPE_XPM;
 591     };
 592
 593     virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
 594           int desiredWidth, int desiredHeight);
 595     virtual bool SaveFile(wxBitmap *bitmap, const wxString& name, int type, const wxPalette *palette = NULL);
 596 };
 597
 598 IMPLEMENT_DYNAMIC_CLASS(wxXPMFileHandler, wxBitmapHandler)
 599
 600 bool wxXPMFileHandler::LoadFile( wxBitmap *bitmap, const wxString& name, long WXUNUSED(flags),
 601                                  int WXUNUSED(desiredWidth), int WXUNUSED(desiredHeight) )
 602 {
 603     Display *dpy = (Display*) wxGetDisplay();
 604     M_BITMAPHANDLERDATA->m_display = (WXDisplay*) dpy;
 605
 606     XpmAttributes xpmAttr;
 607     Pixmap pixmap;
 608     Pixmap mask = 0;
 609
 610     M_BITMAPHANDLERDATA->m_ok = FALSE;
 611     xpmAttr.valuemask = XpmReturnInfos | XpmCloseness;
 612     xpmAttr.closeness = 40000;
 613     int errorStatus = XpmReadFileToPixmap(dpy,
 614         RootWindow(dpy, DefaultScreen(dpy)), (char*) (const char*) name,
 615         &pixmap, &mask, &xpmAttr);
 616
 617     if (errorStatus == XpmSuccess)
 618     {
 619         M_BITMAPHANDLERDATA->m_pixmap = (WXPixmap) pixmap;
 620         if ( mask )
 621         {
 622             M_BITMAPHANDLERDATA->m_bitmapMask = new wxMask;
 623             M_BITMAPHANDLERDATA->m_bitmapMask->SetPixmap((WXPixmap) mask);
 624         }
 625
 626         unsigned int depthRet;
 627         int xRet, yRet;
 628         unsigned int widthRet, heightRet, borderWidthRet;
 629         Window rootWindowRet;
 630         XGetGeometry(dpy, pixmap, &rootWindowRet, &xRet, &yRet,
 631             &widthRet, &heightRet, &borderWidthRet, &depthRet);
 632
 633         M_BITMAPHANDLERDATA->m_width = xpmAttr.width;
 634         M_BITMAPHANDLERDATA->m_height = xpmAttr.height;
 635
 636         /*
 637         if ( xpmAttr.npixels > 2 )
 638         {
 639             M_BITMAPHANDLERDATA->m_depth = 8;   // TODO: next time not just a guess :-) ...
 640         } else
 641         {
 642             M_BITMAPHANDLERDATA->m_depth = 1;   // mono
 643         }
 644         */
 645
 646         M_BITMAPHANDLERDATA->m_depth = depthRet;
 647
 648         M_BITMAPHANDLERDATA->m_numColors = xpmAttr.npixels;
 649
 650             XpmFreeAttributes(&xpmAttr);
 651
 652         M_BITMAPHANDLERDATA->m_ok = TRUE;
 653         return TRUE;
 654     } else
 655     {
 656 //      XpmDebugError(errorStatus, name);
 657         M_BITMAPHANDLERDATA->m_ok = FALSE;
 658         return FALSE;
 659     }
 660 }
 661
 662 bool wxXPMFileHandler::SaveFile( wxBitmap *bitmap, const wxString& name, int WXUNUSED(type),
 663                                  const wxPalette *WXUNUSED(palette))
 664 {
 665     if (M_BITMAPHANDLERDATA->m_ok && M_BITMAPHANDLERDATA->m_pixmap)
 666     {
 667         Display *dpy =  (Display*) M_BITMAPHANDLERDATA->m_display;
 668         int errorStatus = XpmWriteFileFromPixmap(dpy, (char*) (const char*) name,
 669           (Pixmap) M_BITMAPHANDLERDATA->m_pixmap,
 670           (M_BITMAPHANDLERDATA->m_bitmapMask ? (Pixmap) M_BITMAPHANDLERDATA->m_bitmapMask->GetPixmap() : (Pixmap) 0),
 671           (XpmAttributes *) NULL);
 672         if (errorStatus == XpmSuccess)
 673           return TRUE;
 674         else
 675           return FALSE;
 676     }
 677     else
 678         return FALSE;
 679 }
 680
 681 class WXDLLEXPORT wxXPMDataHandler: public wxBitmapHandler
 682 {
 683     DECLARE_DYNAMIC_CLASS(wxXPMDataHandler)
 684 public:
 685     inline wxXPMDataHandler()
 686     {
 687         m_name = "XPM data";
 688         m_extension = "xpm";
 689         m_type = wxBITMAP_TYPE_XPM_DATA;
 690     };
 691
 692     virtual bool Create(wxBitmap *bitmap, void *data, long flags, int width, int height, int depth = 1);
 693 };
 694 IMPLEMENT_DYNAMIC_CLASS(wxXPMDataHandler, wxBitmapHandler)
 695
 696 bool wxXPMDataHandler::Create( wxBitmap *bitmap, void *data, long WXUNUSED(flags),
 697                                int width, int height, int WXUNUSED(depth))
 698 {
 699     M_BITMAPHANDLERDATA->m_width = width;
 700     M_BITMAPHANDLERDATA->m_height = height;
 701     M_BITMAPHANDLERDATA->m_depth = 1;
 702     M_BITMAPHANDLERDATA->m_freePixmap = TRUE;
 703
 704     Display *dpy = (Display*) wxGetDisplay();
 705     M_BITMAPHANDLERDATA->m_display = (WXDisplay*) dpy;
 706
 707     XpmAttributes xpmAttr;
 708
 709     xpmAttr.valuemask = XpmReturnInfos;    /* nothing yet, but get infos back */
 710
 711     XpmColorSymbol symbolicColors[4];
 712     if (sg_Control && sg_Control->GetMainWidget())
 713     {
 714         symbolicColors[0].name = "foreground";
 715         symbolicColors[0].value = NULL;
 716         symbolicColors[1].name = "background";
 717         symbolicColors[1].value = NULL;
 718         XtVaGetValues((Widget) sg_Control->GetMainWidget(),
 719             XmNforeground,  &symbolicColors[0].pixel,
 720             XmNbackground,  &symbolicColors[1].pixel,NULL);
 721         xpmAttr.numsymbols = 2;
 722         xpmAttr.colorsymbols = symbolicColors;
 723         xpmAttr.valuemask |= XpmColorSymbols;    // add flag
 724     }
 725
 726     Pixmap pixmap;
 727     Pixmap mask = 0;
 728     int ErrorStatus = XpmCreatePixmapFromData(dpy, RootWindow(dpy, DefaultScreen(dpy)),
 729                (char**) data, &pixmap, &mask, &xpmAttr);
 730     if (ErrorStatus == XpmSuccess)
 731     {
 732         // Set attributes
 733         M_BITMAPHANDLERDATA->m_width = xpmAttr.width;
 734         M_BITMAPHANDLERDATA->m_height = xpmAttr.height;
 735
 736         unsigned int depthRet;
 737         int xRet, yRet;
 738         unsigned int widthRet, heightRet, borderWidthRet;
 739         Window rootWindowRet;
 740         XGetGeometry(dpy, pixmap, &rootWindowRet, &xRet, &yRet,
 741             &widthRet, &heightRet, &borderWidthRet, &depthRet);
 742
 743         /*
 744         if ( xpmAttr.npixels > 2 )
 745         {
 746             M_BITMAPHANDLERDATA->m_depth = 8;    // next time not just a guess :-) ...
 747         } else
 748         {
 749             M_BITMAPHANDLERDATA->m_depth = 1;    // mono
 750         }
 751         */
 752
 753         M_BITMAPHANDLERDATA->m_depth = depthRet;
 754
 755         M_BITMAPHANDLERDATA->m_numColors = xpmAttr.npixels;
 756         XpmFreeAttributes(&xpmAttr);
 757         M_BITMAPHANDLERDATA->m_ok = TRUE;
 758         M_BITMAPHANDLERDATA->m_pixmap = (WXPixmap) pixmap;
 759         if ( mask )
 760         {
 761             M_BITMAPHANDLERDATA->m_bitmapMask = new wxMask;
 762             M_BITMAPHANDLERDATA->m_bitmapMask->SetPixmap((WXPixmap) mask);
 763         }
 764     }
 765     else
 766     {
 767 //      XpmDebugError(ErrorStatus, NULL);
 768         M_BITMAPHANDLERDATA->m_ok = FALSE;
 769     }
 770     return M_BITMAPHANDLERDATA->m_ok ;
 771 }
 772
 773 #endif
 774
 775 void wxBitmap::CleanUpHandlers()
 776 {
 777     wxNode *node = sm_handlers.First();
 778     while ( node )
 779     {
 780         wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
 781         wxNode *next = node->Next();
 782         delete handler;
 783         delete node;
 784         node = next;
 785     }
 786 }
 787
 788 void wxBitmap::InitStandardHandlers()
 789 {
 790     // Initialize all standard bitmap or derived class handlers here.
 791     AddHandler(new wxXBMFileHandler);
 792     AddHandler(new wxXBMDataHandler);
 793
 794     // XPM is considered standard for Moif, although it can be omitted if absolutely
 795     // necessary.
 796 #if wxUSE_XPM
 797     AddHandler(new wxXPMFileHandler);
 798     AddHandler(new wxXPMDataHandler);
 799 #endif
 800 }
 801
 802 WXPixmap wxBitmap::GetLabelPixmap (WXWidget w)
 803 {
 804   if (M_BITMAPDATA->m_image == (WXPixmap) 0)
 805     return M_BITMAPDATA->m_pixmap;
 806
 807   Display *dpy = (Display*) M_BITMAPDATA->m_display;
 808
 809 #ifdef FOO
 810 /*
 811    If we do:
 812    if (labelPixmap) return labelPixmap;
 813    things can be wrong, because colors can have been changed.
 814
 815    If we do:
 816    if (labelPixmap)
 817    XmDestroyPixmap(DefaultScreenOfDisplay(dpy),labelPixmap) ;
 818    we got BadDrawable if the pixmap is referenced by multiples widgets
 819
 820    this is a catch22!!
 821
 822    So, before doing thing really clean, I just do nothing; if the pixmap is
 823    referenced by many widgets, Motif performs caching functions.
 824    And if pixmap is referenced with multiples colors, we just have some
 825    memory leaks... I hope we can deal with them...
 826  */
 827   // Must be destroyed, because colours can have been changed!
 828   if (M_BITMAPDATA->m_labelPixmap)
 829     XmDestroyPixmap (DefaultScreenOfDisplay (dpy), M_BITMAPDATA->m_labelPixmap);
 830 #endif
 831
 832   char tmp[128];
 833   sprintf (tmp, "Im%x", (unsigned int) M_BITMAPDATA->m_image);
 834
 835   Pixel fg, bg;
 836   Widget widget = (Widget) w;
 837
 838   while (XmIsGadget ( widget ))
 839     widget = XtParent (widget);
 840   XtVaGetValues (widget, XmNbackground, &bg, XmNforeground, &fg, NULL);
 841
 842   M_BITMAPDATA->m_labelPixmap = (WXPixmap) XmGetPixmap (DefaultScreenOfDisplay (dpy), tmp, fg, bg);
 843
 844   return M_BITMAPDATA->m_labelPixmap;
 845 }
 846
 847 WXPixmap wxBitmap::GetArmPixmap (WXWidget w)
 848 {
 849   if (M_BITMAPDATA->m_image == (WXPixmap) 0)
 850     return M_BITMAPDATA->m_pixmap;
 851
 852   Display *dpy = (Display*) M_BITMAPDATA->m_display;
 853 #ifdef FOO
 854   See GetLabelPixmap () comment
 855   // Must be destroyed, because colours can have been changed!
 856   if (M_BITMAPDATA->m_armPixmap)
 857       XmDestroyPixmap (DefaultScreenOfDisplay (dpy), M_BITMAPDATA->m_armPixmap);
 858 #endif
 859
 860   char tmp[128];
 861   sprintf (tmp, "Im%x", (unsigned int) M_BITMAPDATA->m_image);
 862
 863   Pixel fg, bg;
 864   Widget widget = (Widget) w;
 865
 866   XtVaGetValues (widget, XmNarmColor, &bg, NULL);
 867   while (XmIsGadget (widget))
 868     widget = XtParent (widget);
 869   XtVaGetValues (widget, XmNforeground, &fg, NULL);
 870
 871   M_BITMAPDATA->m_armPixmap = (WXPixmap) XmGetPixmap (DefaultScreenOfDisplay (dpy), tmp, fg, bg);
 872
 873   return M_BITMAPDATA->m_armPixmap;
 874 }
 875
 876 WXPixmap wxBitmap::GetInsensPixmap (WXWidget w)
 877 {
 878   Display *dpy = (Display*) M_BITMAPDATA->m_display;
 879
 880   if (M_BITMAPDATA->m_insensPixmap)
 881     return M_BITMAPDATA->m_insensPixmap;
 882
 883   if (!w)
 884   {
 885     M_BITMAPDATA->m_insensPixmap = (WXPixmap) XCreateInsensitivePixmap(dpy, (Pixmap) M_BITMAPDATA->m_pixmap);
 886     if (M_BITMAPDATA->m_insensPixmap)
 887       return M_BITMAPDATA->m_insensPixmap;
 888     else
 889       return M_BITMAPDATA->m_pixmap;
 890   }
 891
 892   if (M_BITMAPDATA->m_insensImage == (WXPixmap) 0)
 893     return M_BITMAPDATA->m_pixmap;
 894
 895 #ifdef FOO
 896   See GetLabelPixmap () comment
 897   // Must be destroyed, because colours can have been changed!
 898   if (M_BITMAPDATA->m_insensPixmap)
 899       XmDestroyPixmap (DefaultScreenOfDisplay (dpy), (Pixmap) M_BITMAPDATA->m_insensPixmap);
 900 #endif
 901
 902   char tmp[128];
 903   sprintf (tmp, "Not%x", (unsigned int) M_BITMAPDATA->m_insensImage);
 904
 905   Pixel fg, bg;
 906   Widget widget = (Widget) w;
 907
 908   while (XmIsGadget (widget))
 909     widget = XtParent (widget);
 910   XtVaGetValues (widget, XmNbackground, &bg, XmNforeground, &fg, NULL);
 911
 912   M_BITMAPDATA->m_insensPixmap = (WXPixmap) XmGetPixmap (DefaultScreenOfDisplay (dpy), tmp, fg, bg);
 913
 914   return M_BITMAPDATA->m_insensPixmap;
 915 }
 916
 917 // We may need this sometime...
 918
 919 /****************************************************************************
 920
 921 NAME
 922     XCreateInsensitivePixmap - create a grayed-out copy of a pixmap
 923
 924 SYNOPSIS
 925     Pixmap XCreateInsensitivePixmap( Display *display, Pixmap pixmap )
 926
 927 DESCRIPTION
 928     This function creates a grayed-out copy of the argument pixmap, suitable
 929     for use as a XmLabel's XmNlabelInsensitivePixmap resource.
 930
 931 RETURN VALUES
 932     The return value is the new Pixmap id or zero on error.  Errors include
 933     a NULL display argument or an invalid Pixmap argument.
 934
 935 ERRORS
 936     If one of the XLib functions fail, it will produce a X error.  The
 937     default X error handler prints a diagnostic and calls exit().
 938
 939 SEE ALSO
 940     XCopyArea(3), XCreateBitmapFromData(3), XCreateGC(3), XCreatePixmap(3),
 941     XFillRectangle(3), exit(2)
 942
 943 AUTHOR
 944     John R Veregge - john@puente.jpl.nasa.gov
 945     Advanced Engineering and Prototyping Group (AEG)
 946     Information Systems Technology Section (395)
 947     Jet Propulsion Lab - Calif Institute of Technology
 948
 949 *****************************************************************************/
 950
 951 Pixmap
 952 XCreateInsensitivePixmap( Display *display, Pixmap pixmap )
 953
 954 {
 955 static
 956     char    stipple_data[] =
 957         {
 958             0x55, 0x55, 0xAA, 0xAA, 0x55, 0x55, 0xAA, 0xAA,
 959             0x55, 0x55, 0xAA, 0xAA, 0x55, 0x55, 0xAA, 0xAA,
 960             0x55, 0x55, 0xAA, 0xAA, 0x55, 0x55, 0xAA, 0xAA,
 961             0x55, 0x55, 0xAA, 0xAA, 0x55, 0x55, 0xAA, 0xAA
 962         };
 963     GC        gc;
 964     Pixmap    ipixmap, stipple;
 965     unsigned    width, height, depth;
 966
 967     Window    window;    /* These return values */
 968     unsigned    border;    /* from XGetGeometry() */
 969     int        x, y;    /* are not needed.     */
 970
 971     ipixmap = 0;
 972
 973     if ( NULL == display || 0 == pixmap )
 974     return ipixmap;
 975
 976     if ( 0 == XGetGeometry( display, pixmap, &window, &x, &y,
 977                 &width, &height, &border, &depth )
 978        )
 979     return ipixmap; /* BadDrawable: probably an invalid pixmap */
 980
 981     /* Get the stipple pixmap to be used to 'gray-out' the argument pixmap.
 982     */
 983     stipple = XCreateBitmapFromData( display, pixmap, stipple_data, 16, 16 );
 984     if ( 0 != stipple )
 985     {
 986     gc = XCreateGC( display, pixmap, (XtGCMask)0, (XGCValues*)NULL );
 987     if ( NULL != gc )
 988     {
 989         /* Create an identical copy of the argument pixmap.
 990         */
 991         ipixmap = XCreatePixmap( display, pixmap, width, height, depth );
 992         if ( 0 != ipixmap )
 993         {
 994         /* Copy the argument pixmap into the new pixmap.
 995         */
 996         XCopyArea( display, pixmap, ipixmap,
 997                gc, 0, 0, width, height, 0, 0 );
 998
 999         /* Refill the new pixmap using the stipple algorithm/pixmap.
1000         */
1001         XSetStipple( display, gc, stipple );
1002         XSetFillStyle( display, gc, FillStippled );
1003         XFillRectangle( display, ipixmap, gc, 0, 0, width, height );
1004         }
1005         XFreeGC( display, gc );
1006     }
1007     XFreePixmap( display, stipple );
1008     }
1009     return ipixmap;
1010 }
1011
1012 // Creates a bitmap with transparent areas drawn in
1013 // the given colour.
1014 wxBitmap wxCreateMaskedBitmap(wxBitmap& bitmap, wxColour& colour)
1015 {
1016     wxBitmap newBitmap(bitmap.GetWidth(),
1017                        bitmap.GetHeight(),
1018                        bitmap.GetDepth());
1019     wxMemoryDC destDC;
1020     wxMemoryDC srcDC;
1021     srcDC.SelectObject(bitmap);
1022     destDC.SelectObject(newBitmap);
1023
1024     wxBrush brush(colour, wxSOLID);
1025     destDC.SetOptimization(FALSE);
1026     destDC.SetBackground(brush);
1027     destDC.Clear();
1028     destDC.Blit(0, 0, bitmap.GetWidth(), bitmap.GetHeight(), & srcDC, 0, 0, wxCOPY, TRUE);
1029
1030     return newBitmap;
1031 }