Added a check for -lresolv in configure.in

[wxWidgets.git] / src / motif / bitmap.cpp

diff --git a/src/motif/bitmap.cpp b/src/motif/bitmap.cpp
index 0f6bb1a7a5a4af95fae074dab7ee420e7b23e013..58bc1cc259dbc6dce2d7fc0721030632a81fe7b3 100644 (file)
--- a/src/motif/bitmap.cpp
+++ b/src/motif/bitmap.cpp
@@ -26,13 +26,13 @@
 
 #include "wx/motif/private.h"
 
 
 #include "wx/motif/private.h"
 

-#if wxUSE_XPM
-#include <X11/xpm.h>
+#if wxHAVE_LIB_XPM
+    #include <X11/xpm.h>

 #endif
 
 #if !USE_SHARED_LIBRARIES
 #endif
 
 #if !USE_SHARED_LIBRARIES

-IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
-IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
+    IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
+    IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)

 #endif
 
 wxBitmapRefData::wxBitmapRefData()
 #endif
 
 wxBitmapRefData::wxBitmapRefData()


@@ -44,14 +44,14 @@ wxBitmapRefData::wxBitmapRefData()
     m_quality = 0;
     m_numColors = 0;
     m_bitmapMask = NULL;
     m_quality = 0;
     m_numColors = 0;
     m_bitmapMask = NULL;

-    
+

     m_pixmap = (WXPixmap) 0;
     m_display = (WXDisplay*) 0;
     m_pixmap = (WXPixmap) 0;
     m_display = (WXDisplay*) 0;

-    
+

     m_freePixmap = TRUE; //TODO: necessary?
     m_freeColors = (unsigned long*) 0;
     m_freeColorsCount = 0;
     m_freePixmap = TRUE; //TODO: necessary?
     m_freeColors = (unsigned long*) 0;
     m_freeColorsCount = 0;

-    
+

     // These 5 variables are for wxControl
     m_insensPixmap = (WXPixmap) 0;
     m_labelPixmap = (WXPixmap) 0;
     // These 5 variables are for wxControl
     m_insensPixmap = (WXPixmap) 0;
     m_labelPixmap = (WXPixmap) 0;


@@ -64,19 +64,19 @@ wxBitmapRefData::~wxBitmapRefData()
 {
     if (m_labelPixmap)
         XmDestroyPixmap (DefaultScreenOfDisplay ((Display*) m_display), (Pixmap) m_labelPixmap);
 {
     if (m_labelPixmap)
         XmDestroyPixmap (DefaultScreenOfDisplay ((Display*) m_display), (Pixmap) m_labelPixmap);

-    
+

     if (m_armPixmap)
         XmDestroyPixmap (DefaultScreenOfDisplay ((Display*) m_display), (Pixmap) m_armPixmap);
     if (m_armPixmap)
         XmDestroyPixmap (DefaultScreenOfDisplay ((Display*) m_display), (Pixmap) m_armPixmap);

-    
+

     if (m_insensPixmap)
         XmDestroyPixmap (DefaultScreenOfDisplay ((Display*) m_display), (Pixmap) m_insensPixmap);
     if (m_insensPixmap)
         XmDestroyPixmap (DefaultScreenOfDisplay ((Display*) m_display), (Pixmap) m_insensPixmap);

-    
+

     if (m_image)
     {
         XmUninstallImage ((XImage*) m_image);
         XtFree ((char *) (XImage*) m_image);
     }
     if (m_image)
     {
         XmUninstallImage ((XImage*) m_image);
         XtFree ((char *) (XImage*) m_image);
     }

-    
+

     if (m_insensImage)
     {
         XmUninstallImage ((XImage*) m_insensImage);
     if (m_insensImage)
     {
         XmUninstallImage ((XImage*) m_insensImage);


@@ -85,7 +85,7 @@ wxBitmapRefData::~wxBitmapRefData()
     }
     if (m_pixmap && m_freePixmap)
         XFreePixmap ((Display*) m_display, (Pixmap) m_pixmap);
     }
     if (m_pixmap && m_freePixmap)
         XFreePixmap ((Display*) m_display, (Pixmap) m_pixmap);

-    
+

     if (m_freeColors)
     {
         int screen = DefaultScreen((Display*) m_display);
     if (m_freeColors)
     {
         int screen = DefaultScreen((Display*) m_display);


@@ -95,7 +95,7 @@ wxBitmapRefData::~wxBitmapRefData()
             XFreeColors((Display*) m_display, cmp, &m_freeColors[llp], 1, 0L);
         delete m_freeColors;
     };
             XFreeColors((Display*) m_display, cmp, &m_freeColors[llp], 1, 0L);
         delete m_freeColors;
     };

-    
+

     if (m_bitmapMask)
         delete m_bitmapMask;
     m_bitmapMask = NULL;
     if (m_bitmapMask)
         delete m_bitmapMask;
     m_bitmapMask = NULL;


@@ -106,7 +106,7 @@ wxList wxBitmap::sm_handlers;
 wxBitmap::wxBitmap()
 {
     m_refData = NULL;
 wxBitmap::wxBitmap()
 {
     m_refData = NULL;

-    
+

     if ( wxTheBitmapList )
         wxTheBitmapList->AddBitmap(this);
 }
     if ( wxTheBitmapList )
         wxTheBitmapList->AddBitmap(this);
 }


@@ -120,9 +120,9 @@ wxBitmap::~wxBitmap()
 wxBitmap::wxBitmap(const char bits[], int width, int height, int depth)
 {
     m_refData = new wxBitmapRefData;
 wxBitmap::wxBitmap(const char bits[], int width, int height, int depth)
 {
     m_refData = new wxBitmapRefData;

-    
+

     (void) Create((void*) bits, wxBITMAP_TYPE_XBM_DATA, width, height, depth);
     (void) Create((void*) bits, wxBITMAP_TYPE_XBM_DATA, width, height, depth);

-    
+

     if ( wxTheBitmapList )
         wxTheBitmapList->AddBitmap(this);
 }
     if ( wxTheBitmapList )
         wxTheBitmapList->AddBitmap(this);
 }


@@ -130,7 +130,7 @@ wxBitmap::wxBitmap(const char bits[], int width, int height, int depth)
 wxBitmap::wxBitmap(int w, int h, int d)
 {
     (void)Create(w, h, d);
 wxBitmap::wxBitmap(int w, int h, int d)
 {
     (void)Create(w, h, d);

-    
+

     if ( wxTheBitmapList )
         wxTheBitmapList->AddBitmap(this);
 }
     if ( wxTheBitmapList )
         wxTheBitmapList->AddBitmap(this);
 }


@@ -138,7 +138,7 @@ wxBitmap::wxBitmap(int w, int h, int d)
 wxBitmap::wxBitmap(void *data, long type, int width, int height, int depth)
 {
     (void) Create(data, type, width, height, depth);
 wxBitmap::wxBitmap(void *data, long type, int width, int height, int depth)
 {
     (void) Create(data, type, width, height, depth);

-    
+

     if ( wxTheBitmapList )
         wxTheBitmapList->AddBitmap(this);
 }
     if ( wxTheBitmapList )
         wxTheBitmapList->AddBitmap(this);
 }


@@ -146,7 +146,7 @@ wxBitmap::wxBitmap(void *data, long type, int width, int height, int depth)
 wxBitmap::wxBitmap(const wxString& filename, long type)
 {
     LoadFile(filename, (int)type);
 wxBitmap::wxBitmap(const wxString& filename, long type)
 {
     LoadFile(filename, (int)type);

-    
+

     if ( wxTheBitmapList )
         wxTheBitmapList->AddBitmap(this);
 }
     if ( wxTheBitmapList )
         wxTheBitmapList->AddBitmap(this);
 }


@@ -157,33 +157,33 @@ wxBitmap::wxBitmap(char **data, wxControl* control)
 {
     // Pass the control to the Create function using a global
     sg_Control = control;
 {
     // Pass the control to the Create function using a global
     sg_Control = control;

-    
+

     (void) Create((void *)data, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0);
     (void) Create((void *)data, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0);

-    
+

     sg_Control = (wxControl*) NULL;
 }
 
 bool wxBitmap::Create(int w, int h, int d)
 {
     UnRef();
     sg_Control = (wxControl*) NULL;
 }
 
 bool wxBitmap::Create(int w, int h, int d)
 {
     UnRef();

-    
+

     m_refData = new wxBitmapRefData;
     m_refData = new wxBitmapRefData;

-    
+

     if (d < 1)
         d = wxDisplayDepth();
     if (d < 1)
         d = wxDisplayDepth();

-    
+

     M_BITMAPDATA->m_width = w;
     M_BITMAPDATA->m_height = h;
     M_BITMAPDATA->m_depth = d;
     M_BITMAPDATA->m_freePixmap = TRUE;
     M_BITMAPDATA->m_width = w;
     M_BITMAPDATA->m_height = h;
     M_BITMAPDATA->m_depth = d;
     M_BITMAPDATA->m_freePixmap = TRUE;

-    
+

     Display *dpy = (Display*) wxGetDisplay();
     Display *dpy = (Display*) wxGetDisplay();

-    
+

     M_BITMAPDATA->m_display = dpy; /* MATTHEW: [4] Remember the display */
     M_BITMAPDATA->m_display = dpy; /* MATTHEW: [4] Remember the display */

-    
+

     M_BITMAPDATA->m_pixmap = (WXPixmap) XCreatePixmap (dpy, RootWindow (dpy, DefaultScreen (dpy)),
         w, h, d);
     M_BITMAPDATA->m_pixmap = (WXPixmap) XCreatePixmap (dpy, RootWindow (dpy, DefaultScreen (dpy)),
         w, h, d);

-    
+

     M_BITMAPDATA->m_ok = (M_BITMAPDATA->m_pixmap != (WXPixmap) 0) ;
     return M_BITMAPDATA->m_ok;
 }
     M_BITMAPDATA->m_ok = (M_BITMAPDATA->m_pixmap != (WXPixmap) 0) ;
     return M_BITMAPDATA->m_ok;
 }


@@ -191,47 +191,47 @@ bool wxBitmap::Create(int w, int h, int d)
 bool wxBitmap::LoadFile(const wxString& filename, long type)
 {
     UnRef();
 bool wxBitmap::LoadFile(const wxString& filename, long type)
 {
     UnRef();

-    
+

     m_refData = new wxBitmapRefData;
     m_refData = new wxBitmapRefData;

-    
+

     wxBitmapHandler *handler = FindHandler(type);
     wxBitmapHandler *handler = FindHandler(type);

-    
+

     if ( handler == NULL ) {
         wxLogWarning("%s: no bitmap handler for type %d defined.", (const char*) filename, type);
     if ( handler == NULL ) {
         wxLogWarning("%s: no bitmap handler for type %d defined.", (const char*) filename, type);

-        
+

         return FALSE;
     }
         return FALSE;
     }

-    
+

     return handler->LoadFile(this, filename, type, -1, -1);
 }
 
 bool wxBitmap::Create(void *data, long type, int width, int height, int depth)
 {
     UnRef();
     return handler->LoadFile(this, filename, type, -1, -1);
 }
 
 bool wxBitmap::Create(void *data, long type, int width, int height, int depth)
 {
     UnRef();

-    
+

     m_refData = new wxBitmapRefData;
     m_refData = new wxBitmapRefData;

-    
+

     wxBitmapHandler *handler = FindHandler(type);
     wxBitmapHandler *handler = FindHandler(type);

-    
+

     if ( handler == NULL ) {
         wxLogWarning("no data bitmap handler for type %d defined.", type);
     if ( handler == NULL ) {
         wxLogWarning("no data bitmap handler for type %d defined.", type);

-        
+

         return FALSE;
     }
         return FALSE;
     }

-    
+

     return handler->Create(this, data, type, width, height, depth);
 }
 
 bool wxBitmap::SaveFile(const wxString& filename, int type, const wxPalette *palette)
 {
     wxBitmapHandler *handler = FindHandler(type);
     return handler->Create(this, data, type, width, height, depth);
 }
 
 bool wxBitmap::SaveFile(const wxString& filename, int type, const wxPalette *palette)
 {
     wxBitmapHandler *handler = FindHandler(type);

-    
+

     if ( handler == NULL ) {
         wxLogWarning("no bitmap handler for type %d defined.", type);
     if ( handler == NULL ) {
         wxLogWarning("no bitmap handler for type %d defined.", type);

-        
+

         return FALSE;
     }
         return FALSE;
     }

-    
+

     return handler->SaveFile(this, filename, type, palette);
 }
 
     return handler->SaveFile(this, filename, type, palette);
 }
 


@@ -239,7 +239,7 @@ void wxBitmap::SetWidth(int w)
 {
     if (!M_BITMAPDATA)
         m_refData = new wxBitmapRefData;
 {
     if (!M_BITMAPDATA)
         m_refData = new wxBitmapRefData;

-    
+

     M_BITMAPDATA->m_width = w;
 }
 
     M_BITMAPDATA->m_width = w;
 }
 


@@ -247,7 +247,7 @@ void wxBitmap::SetHeight(int h)
 {
     if (!M_BITMAPDATA)
         m_refData = new wxBitmapRefData;
 {
     if (!M_BITMAPDATA)
         m_refData = new wxBitmapRefData;

-    
+

     M_BITMAPDATA->m_height = h;
 }
 
     M_BITMAPDATA->m_height = h;
 }
 


@@ -255,7 +255,7 @@ void wxBitmap::SetDepth(int d)
 {
     if (!M_BITMAPDATA)
         m_refData = new wxBitmapRefData;
 {
     if (!M_BITMAPDATA)
         m_refData = new wxBitmapRefData;

-    
+

     M_BITMAPDATA->m_depth = d;
 }
 
     M_BITMAPDATA->m_depth = d;
 }
 


@@ -263,7 +263,7 @@ void wxBitmap::SetQuality(int q)
 {
     if (!M_BITMAPDATA)
         m_refData = new wxBitmapRefData;
 {
     if (!M_BITMAPDATA)
         m_refData = new wxBitmapRefData;

-    
+

     M_BITMAPDATA->m_quality = q;
 }
 
     M_BITMAPDATA->m_quality = q;
 }
 


@@ -271,7 +271,7 @@ void wxBitmap::SetOk(bool isOk)
 {
     if (!M_BITMAPDATA)
         m_refData = new wxBitmapRefData;
 {
     if (!M_BITMAPDATA)
         m_refData = new wxBitmapRefData;

-    
+

     M_BITMAPDATA->m_ok = isOk;
 }
 
     M_BITMAPDATA->m_ok = isOk;
 }
 


@@ -279,7 +279,7 @@ void wxBitmap::SetPalette(const wxPalette& palette)
 {
     if (!M_BITMAPDATA)
         m_refData = new wxBitmapRefData;
 {
     if (!M_BITMAPDATA)
         m_refData = new wxBitmapRefData;

-    
+

     M_BITMAPDATA->m_bitmapPalette = palette ;
 }
 
     M_BITMAPDATA->m_bitmapPalette = palette ;
 }
 


@@ -287,7 +287,7 @@ void wxBitmap::SetMask(wxMask *mask)
 {
     if (!M_BITMAPDATA)
         m_refData = new wxBitmapRefData;
 {
     if (!M_BITMAPDATA)
         m_refData = new wxBitmapRefData;

-    
+

     M_BITMAPDATA->m_bitmapMask = mask ;
 }
 
     M_BITMAPDATA->m_bitmapMask = mask ;
 }
 


@@ -367,7 +367,7 @@ wxMask::wxMask()
 wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour)
 {
     m_pixmap = (WXPixmap) 0;
 wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour)
 {
     m_pixmap = (WXPixmap) 0;

-    
+

     Create(bitmap, colour);
 }
 
     Create(bitmap, colour);
 }
 


@@ -376,7 +376,7 @@ wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour)
 wxMask::wxMask(const wxBitmap& bitmap, int paletteIndex)
 {
     m_pixmap = (WXPixmap) 0;
 wxMask::wxMask(const wxBitmap& bitmap, int paletteIndex)
 {
     m_pixmap = (WXPixmap) 0;

-    
+

     Create(bitmap, paletteIndex);
 }
 
     Create(bitmap, paletteIndex);
 }
 


@@ -384,7 +384,7 @@ wxMask::wxMask(const wxBitmap& bitmap, int paletteIndex)
 wxMask::wxMask(const wxBitmap& bitmap)
 {
     m_pixmap = (WXPixmap) 0;
 wxMask::wxMask(const wxBitmap& bitmap)
 {
     m_pixmap = (WXPixmap) 0;

-    
+

     Create(bitmap);
 }
 
     Create(bitmap);
 }
 


@@ -424,7 +424,7 @@ bool wxMask::Create(const wxBitmap& WXUNUSED(bitmap), const wxColour& WXUNUSED(c
 
 IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject)
 
 
 IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject)
 

-bool wxBitmapHandler::Create(wxBitmap *WXUNUSED(bitmap), void *WXUNUSED(data), long WXUNUSED(type), 
+bool wxBitmapHandler::Create(wxBitmap *WXUNUSED(bitmap), void *WXUNUSED(data), long WXUNUSED(type),

                              int WXUNUSED(width), int WXUNUSED(height), int WXUNUSED(depth))
 {
     return FALSE;
                              int WXUNUSED(width), int WXUNUSED(height), int WXUNUSED(depth))
 {
     return FALSE;


@@ -436,7 +436,7 @@ bool wxBitmapHandler::LoadFile(wxBitmap *WXUNUSED(bitmap), const wxString& WXUNU
     return FALSE;
 }
 
     return FALSE;
 }
 

-bool wxBitmapHandler::SaveFile(wxBitmap *WXUNUSED(bitmap), const wxString& WXUNUSED(name), int WXUNUSED(type), 
+bool wxBitmapHandler::SaveFile(wxBitmap *WXUNUSED(bitmap), const wxString& WXUNUSED(name), int WXUNUSED(type),

                                const wxPalette *WXUNUSED(palette))
 {
     return FALSE;
                                const wxPalette *WXUNUSED(palette))
 {
     return FALSE;


@@ -456,7 +456,7 @@ public:
         m_extension = "xbm";
         m_type = wxBITMAP_TYPE_XBM;
     };
         m_extension = "xbm";
         m_type = wxBITMAP_TYPE_XBM;
     };

-    
+

     virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
         int desiredWidth, int desiredHeight);
 };
     virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
         int desiredWidth, int desiredHeight);
 };


@@ -466,21 +466,21 @@ bool wxXBMFileHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long WXU
                                 int WXUNUSED(desiredWidth), int WXUNUSED(desiredHeight))
 {
     M_BITMAPHANDLERDATA->m_freePixmap = TRUE;
                                 int WXUNUSED(desiredWidth), int WXUNUSED(desiredHeight))
 {
     M_BITMAPHANDLERDATA->m_freePixmap = TRUE;

-    
+

     int hotX, hotY;
     unsigned int w, h;
     Pixmap pixmap;
     int hotX, hotY;
     unsigned int w, h;
     Pixmap pixmap;

-    
+

     Display *dpy = (Display*) wxGetDisplay();
     M_BITMAPDATA->m_display = (WXDisplay*) dpy;
     Display *dpy = (Display*) wxGetDisplay();
     M_BITMAPDATA->m_display = (WXDisplay*) dpy;

-    
+

     int value = XReadBitmapFile (dpy, RootWindow (dpy, DefaultScreen (dpy)),
         (char*) (const char*) name, &w, &h, &pixmap, &hotX, &hotY);
     M_BITMAPHANDLERDATA->m_width = w;
     M_BITMAPHANDLERDATA->m_height = h;
     M_BITMAPHANDLERDATA->m_depth = 1;
     M_BITMAPHANDLERDATA->m_pixmap = (WXPixmap) pixmap;
     int value = XReadBitmapFile (dpy, RootWindow (dpy, DefaultScreen (dpy)),
         (char*) (const char*) name, &w, &h, &pixmap, &hotX, &hotY);
     M_BITMAPHANDLERDATA->m_width = w;
     M_BITMAPHANDLERDATA->m_height = h;
     M_BITMAPHANDLERDATA->m_depth = 1;
     M_BITMAPHANDLERDATA->m_pixmap = (WXPixmap) pixmap;

-    
+

     if ((value == BitmapFileInvalid) ||
         (value == BitmapOpenFailed) ||
         (value == BitmapNoMemory))
     if ((value == BitmapFileInvalid) ||
         (value == BitmapOpenFailed) ||
         (value == BitmapNoMemory))


@@ -490,7 +490,7 @@ bool wxXBMFileHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long WXU
     }
     else
         M_BITMAPHANDLERDATA->m_ok = TRUE;
     }
     else
         M_BITMAPHANDLERDATA->m_ok = TRUE;

-    
+

     return M_BITMAPHANDLERDATA->m_ok ;
 }
 
     return M_BITMAPHANDLERDATA->m_ok ;
 }
 


@@ -504,25 +504,25 @@ public:
         m_extension = "xbm";
         m_type = wxBITMAP_TYPE_XBM_DATA;
     };
         m_extension = "xbm";
         m_type = wxBITMAP_TYPE_XBM_DATA;
     };

-    
+

     virtual bool Create(wxBitmap *bitmap, void *data, long flags, int width, int height, int depth = 1);
 };
 IMPLEMENT_DYNAMIC_CLASS(wxXBMDataHandler, wxBitmapHandler)
 
     virtual bool Create(wxBitmap *bitmap, void *data, long flags, int width, int height, int depth = 1);
 };
 IMPLEMENT_DYNAMIC_CLASS(wxXBMDataHandler, wxBitmapHandler)
 

-bool wxXBMDataHandler::Create( wxBitmap *bitmap, void *data, long WXUNUSED(flags), 
+bool wxXBMDataHandler::Create( wxBitmap *bitmap, void *data, long WXUNUSED(flags),

                               int width, int height, int WXUNUSED(depth))
 {
     M_BITMAPHANDLERDATA->m_width = width;
     M_BITMAPHANDLERDATA->m_height = height;
     M_BITMAPHANDLERDATA->m_depth = 1;
     M_BITMAPHANDLERDATA->m_freePixmap = TRUE;
                               int width, int height, int WXUNUSED(depth))
 {
     M_BITMAPHANDLERDATA->m_width = width;
     M_BITMAPHANDLERDATA->m_height = height;
     M_BITMAPHANDLERDATA->m_depth = 1;
     M_BITMAPHANDLERDATA->m_freePixmap = TRUE;

-    
+

     Display *dpy = (Display*) wxGetDisplay();
     M_BITMAPHANDLERDATA->m_display = (WXDisplay*) dpy;
     Display *dpy = (Display*) wxGetDisplay();
     M_BITMAPHANDLERDATA->m_display = (WXDisplay*) dpy;

-    
+

     M_BITMAPHANDLERDATA->m_pixmap = (WXPixmap) XCreateBitmapFromData (dpy, RootWindow (dpy, DefaultScreen (dpy)), (char*) data, width, height);
     M_BITMAPHANDLERDATA->m_ok = (M_BITMAPHANDLERDATA->m_pixmap != (WXPixmap) 0) ;
     M_BITMAPHANDLERDATA->m_pixmap = (WXPixmap) XCreateBitmapFromData (dpy, RootWindow (dpy, DefaultScreen (dpy)), (char*) data, width, height);
     M_BITMAPHANDLERDATA->m_ok = (M_BITMAPHANDLERDATA->m_pixmap != (WXPixmap) 0) ;

-    
+

     // code for wxControl. TODO: can we avoid doing this until we need it?
     // E.g. have CreateButtonPixmaps which is called on demand.
     XImage* image = (XImage *) XtMalloc (sizeof (XImage));
     // code for wxControl. TODO: can we avoid doing this until we need it?
     // E.g. have CreateButtonPixmaps which is called on demand.
     XImage* image = (XImage *) XtMalloc (sizeof (XImage));


@@ -537,13 +537,13 @@ bool wxXBMDataHandler::Create( wxBitmap *bitmap, void *data, long WXUNUSED(flags
     image->bitmap_bit_order = LSBFirst;
     image->bitmap_pad = 8;
     image->bytes_per_line = (width + 7) >> 3;
     image->bitmap_bit_order = LSBFirst;
     image->bitmap_pad = 8;
     image->bytes_per_line = (width + 7) >> 3;

-    
+

     char tmp[128];
     sprintf (tmp, "Im%x", (unsigned int) image);
     XmInstallImage (image, tmp);
     char tmp[128];
     sprintf (tmp, "Im%x", (unsigned int) image);
     XmInstallImage (image, tmp);

-    
+

     // Build our manually stipped pixmap.
     // Build our manually stipped pixmap.

-    
+

     int bpl = (width + 7) / 8;
     char *data1 = new char[height * bpl];
     char* bits = (char*) data;
     int bpl = (width + 7) / 8;
     char *data1 = new char[height * bpl];
     char* bits = (char*) data;


@@ -567,17 +567,17 @@ bool wxXBMDataHandler::Create( wxBitmap *bitmap, void *data, long WXUNUSED(flags
     insensImage->bitmap_bit_order = LSBFirst;
     insensImage->bitmap_pad = 8;
     insensImage->bytes_per_line = bpl;
     insensImage->bitmap_bit_order = LSBFirst;
     insensImage->bitmap_pad = 8;
     insensImage->bytes_per_line = bpl;

-    
+

     sprintf (tmp, "Not%x", (unsigned int)insensImage);
     XmInstallImage (insensImage, tmp);
     sprintf (tmp, "Not%x", (unsigned int)insensImage);
     XmInstallImage (insensImage, tmp);

-    
+

     M_BITMAPHANDLERDATA->m_image = (WXImage*) image;
     M_BITMAPHANDLERDATA->m_insensImage = (WXImage*) insensImage;
     M_BITMAPHANDLERDATA->m_image = (WXImage*) image;
     M_BITMAPHANDLERDATA->m_insensImage = (WXImage*) insensImage;

-    
+

     return TRUE;
 }
 
     return TRUE;
 }
 

-#if wxUSE_XPM
+#if wxHAVE_LIB_XPM

 class WXDLLEXPORT wxXPMFileHandler: public wxBitmapHandler
 {
     DECLARE_DYNAMIC_CLASS(wxXPMFileHandler)
 class WXDLLEXPORT wxXPMFileHandler: public wxBitmapHandler
 {
     DECLARE_DYNAMIC_CLASS(wxXPMFileHandler)


@@ -588,7 +588,7 @@ public:
         m_extension = "xpm";
         m_type = wxBITMAP_TYPE_XPM;
     };
         m_extension = "xpm";
         m_type = wxBITMAP_TYPE_XPM;
     };

-    
+

     virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
         int desiredWidth, int desiredHeight);
     virtual bool SaveFile(wxBitmap *bitmap, const wxString& name, int type, const wxPalette *palette = NULL);
     virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
         int desiredWidth, int desiredHeight);
     virtual bool SaveFile(wxBitmap *bitmap, const wxString& name, int type, const wxPalette *palette = NULL);


@@ -601,18 +601,18 @@ bool wxXPMFileHandler::LoadFile( wxBitmap *bitmap, const wxString& name, long WX
 {
     Display *dpy = (Display*) wxGetDisplay();
     M_BITMAPHANDLERDATA->m_display = (WXDisplay*) dpy;
 {
     Display *dpy = (Display*) wxGetDisplay();
     M_BITMAPHANDLERDATA->m_display = (WXDisplay*) dpy;

-    
+

     XpmAttributes xpmAttr;
     Pixmap pixmap;
     Pixmap mask = 0;
     XpmAttributes xpmAttr;
     Pixmap pixmap;
     Pixmap mask = 0;

-    
+

     M_BITMAPHANDLERDATA->m_ok = FALSE;
     xpmAttr.valuemask = XpmReturnInfos | XpmCloseness;
     xpmAttr.closeness = 40000;
     int errorStatus = XpmReadFileToPixmap(dpy,
         RootWindow(dpy, DefaultScreen(dpy)), (char*) (const char*) name,
         &pixmap, &mask, &xpmAttr);
     M_BITMAPHANDLERDATA->m_ok = FALSE;
     xpmAttr.valuemask = XpmReturnInfos | XpmCloseness;
     xpmAttr.closeness = 40000;
     int errorStatus = XpmReadFileToPixmap(dpy,
         RootWindow(dpy, DefaultScreen(dpy)), (char*) (const char*) name,
         &pixmap, &mask, &xpmAttr);

-    
+

     if (errorStatus == XpmSuccess)
     {
         M_BITMAPHANDLERDATA->m_pixmap = (WXPixmap) pixmap;
     if (errorStatus == XpmSuccess)
     {
         M_BITMAPHANDLERDATA->m_pixmap = (WXPixmap) pixmap;


@@ -621,17 +621,17 @@ bool wxXPMFileHandler::LoadFile( wxBitmap *bitmap, const wxString& name, long WX
             M_BITMAPHANDLERDATA->m_bitmapMask = new wxMask;
             M_BITMAPHANDLERDATA->m_bitmapMask->SetPixmap((WXPixmap) mask);
         }
             M_BITMAPHANDLERDATA->m_bitmapMask = new wxMask;
             M_BITMAPHANDLERDATA->m_bitmapMask->SetPixmap((WXPixmap) mask);
         }

-        
+

         unsigned int depthRet;
         int xRet, yRet;
         unsigned int widthRet, heightRet, borderWidthRet;
         Window rootWindowRet;
         XGetGeometry(dpy, pixmap, &rootWindowRet, &xRet, &yRet,
             &widthRet, &heightRet, &borderWidthRet, &depthRet);
         unsigned int depthRet;
         int xRet, yRet;
         unsigned int widthRet, heightRet, borderWidthRet;
         Window rootWindowRet;
         XGetGeometry(dpy, pixmap, &rootWindowRet, &xRet, &yRet,
             &widthRet, &heightRet, &borderWidthRet, &depthRet);

-        
+

         M_BITMAPHANDLERDATA->m_width = xpmAttr.width;
         M_BITMAPHANDLERDATA->m_height = xpmAttr.height;
         M_BITMAPHANDLERDATA->m_width = xpmAttr.width;
         M_BITMAPHANDLERDATA->m_height = xpmAttr.height;

-        
+

         /*
         if ( xpmAttr.npixels > 2 )
         {
         /*
         if ( xpmAttr.npixels > 2 )
         {


@@ -641,13 +641,13 @@ bool wxXPMFileHandler::LoadFile( wxBitmap *bitmap, const wxString& name, long WX
         M_BITMAPHANDLERDATA->m_depth = 1;      // mono
         }
         */
         M_BITMAPHANDLERDATA->m_depth = 1;      // mono
         }
         */

-        
+

         M_BITMAPHANDLERDATA->m_depth = depthRet;
         M_BITMAPHANDLERDATA->m_depth = depthRet;

-        
+

         M_BITMAPHANDLERDATA->m_numColors = xpmAttr.npixels;
         M_BITMAPHANDLERDATA->m_numColors = xpmAttr.npixels;

-        
+

         XpmFreeAttributes(&xpmAttr);
         XpmFreeAttributes(&xpmAttr);

-        
+

         M_BITMAPHANDLERDATA->m_ok = TRUE;
         return TRUE;
     } else
         M_BITMAPHANDLERDATA->m_ok = TRUE;
         return TRUE;
     } else


@@ -658,7 +658,7 @@ bool wxXPMFileHandler::LoadFile( wxBitmap *bitmap, const wxString& name, long WX
     }
 }
 
     }
 }
 

-bool wxXPMFileHandler::SaveFile( wxBitmap *bitmap, const wxString& name, int WXUNUSED(type), 
+bool wxXPMFileHandler::SaveFile( wxBitmap *bitmap, const wxString& name, int WXUNUSED(type),

                                 const wxPalette *WXUNUSED(palette))
 {
     if (M_BITMAPHANDLERDATA->m_ok && M_BITMAPHANDLERDATA->m_pixmap)
                                 const wxPalette *WXUNUSED(palette))
 {
     if (M_BITMAPHANDLERDATA->m_ok && M_BITMAPHANDLERDATA->m_pixmap)


@@ -687,26 +687,26 @@ public:
         m_extension = "xpm";
         m_type = wxBITMAP_TYPE_XPM_DATA;
     };
         m_extension = "xpm";
         m_type = wxBITMAP_TYPE_XPM_DATA;
     };

-    
+

     virtual bool Create(wxBitmap *bitmap, void *data, long flags, int width, int height, int depth = 1);
 };
 IMPLEMENT_DYNAMIC_CLASS(wxXPMDataHandler, wxBitmapHandler)
 
     virtual bool Create(wxBitmap *bitmap, void *data, long flags, int width, int height, int depth = 1);
 };
 IMPLEMENT_DYNAMIC_CLASS(wxXPMDataHandler, wxBitmapHandler)
 

-bool wxXPMDataHandler::Create( wxBitmap *bitmap, void *data, long WXUNUSED(flags), 
+bool wxXPMDataHandler::Create( wxBitmap *bitmap, void *data, long WXUNUSED(flags),

                               int width, int height, int WXUNUSED(depth))
 {
     M_BITMAPHANDLERDATA->m_width = width;
     M_BITMAPHANDLERDATA->m_height = height;
     M_BITMAPHANDLERDATA->m_depth = 1;
     M_BITMAPHANDLERDATA->m_freePixmap = TRUE;
                               int width, int height, int WXUNUSED(depth))
 {
     M_BITMAPHANDLERDATA->m_width = width;
     M_BITMAPHANDLERDATA->m_height = height;
     M_BITMAPHANDLERDATA->m_depth = 1;
     M_BITMAPHANDLERDATA->m_freePixmap = TRUE;

-    
+

     Display *dpy = (Display*) wxGetDisplay();
     M_BITMAPHANDLERDATA->m_display = (WXDisplay*) dpy;
     Display *dpy = (Display*) wxGetDisplay();
     M_BITMAPHANDLERDATA->m_display = (WXDisplay*) dpy;

-    
+

     XpmAttributes xpmAttr;
     XpmAttributes xpmAttr;

-    
+

     xpmAttr.valuemask = XpmReturnInfos;    /* nothing yet, but get infos back */
     xpmAttr.valuemask = XpmReturnInfos;    /* nothing yet, but get infos back */

-    
+

     XpmColorSymbol symbolicColors[4];
     if (sg_Control && sg_Control->GetMainWidget())
     {
     XpmColorSymbol symbolicColors[4];
     if (sg_Control && sg_Control->GetMainWidget())
     {


@@ -721,7 +721,7 @@ bool wxXPMDataHandler::Create( wxBitmap *bitmap, void *data, long WXUNUSED(flags
         xpmAttr.colorsymbols = symbolicColors;
         xpmAttr.valuemask |= XpmColorSymbols;    // add flag
     }
         xpmAttr.colorsymbols = symbolicColors;
         xpmAttr.valuemask |= XpmColorSymbols;    // add flag
     }

-    
+

     Pixmap pixmap;
     Pixmap mask = 0;
     int ErrorStatus = XpmCreatePixmapFromData(dpy, RootWindow(dpy, DefaultScreen(dpy)),
     Pixmap pixmap;
     Pixmap mask = 0;
     int ErrorStatus = XpmCreatePixmapFromData(dpy, RootWindow(dpy, DefaultScreen(dpy)),


@@ -731,14 +731,14 @@ bool wxXPMDataHandler::Create( wxBitmap *bitmap, void *data, long WXUNUSED(flags
         // Set attributes
         M_BITMAPHANDLERDATA->m_width = xpmAttr.width;
         M_BITMAPHANDLERDATA->m_height = xpmAttr.height;
         // Set attributes
         M_BITMAPHANDLERDATA->m_width = xpmAttr.width;
         M_BITMAPHANDLERDATA->m_height = xpmAttr.height;

-        
+

         unsigned int depthRet;
         int xRet, yRet;
         unsigned int widthRet, heightRet, borderWidthRet;
         Window rootWindowRet;
         XGetGeometry(dpy, pixmap, &rootWindowRet, &xRet, &yRet,
             &widthRet, &heightRet, &borderWidthRet, &depthRet);
         unsigned int depthRet;
         int xRet, yRet;
         unsigned int widthRet, heightRet, borderWidthRet;
         Window rootWindowRet;
         XGetGeometry(dpy, pixmap, &rootWindowRet, &xRet, &yRet,
             &widthRet, &heightRet, &borderWidthRet, &depthRet);

-        
+

             /*
             if ( xpmAttr.npixels > 2 )
             {
             /*
             if ( xpmAttr.npixels > 2 )
             {


@@ -748,9 +748,9 @@ bool wxXPMDataHandler::Create( wxBitmap *bitmap, void *data, long WXUNUSED(flags
             M_BITMAPHANDLERDATA->m_depth = 1;    // mono
             }
         */
             M_BITMAPHANDLERDATA->m_depth = 1;    // mono
             }
         */

-        
+

         M_BITMAPHANDLERDATA->m_depth = depthRet;
         M_BITMAPHANDLERDATA->m_depth = depthRet;

-        
+

         M_BITMAPHANDLERDATA->m_numColors = xpmAttr.npixels;
         XpmFreeAttributes(&xpmAttr);
         M_BITMAPHANDLERDATA->m_ok = TRUE;
         M_BITMAPHANDLERDATA->m_numColors = xpmAttr.npixels;
         XpmFreeAttributes(&xpmAttr);
         M_BITMAPHANDLERDATA->m_ok = TRUE;


@@ -769,7 +769,7 @@ bool wxXPMDataHandler::Create( wxBitmap *bitmap, void *data, long WXUNUSED(flags
     return M_BITMAPHANDLERDATA->m_ok ;
 }
 
     return M_BITMAPHANDLERDATA->m_ok ;
 }
 

-#endif
+#endif // wxHAVE_LIB_XPM

 
 void wxBitmap::CleanUpHandlers()
 {
 
 void wxBitmap::CleanUpHandlers()
 {


@@ -789,35 +789,35 @@ void wxBitmap::InitStandardHandlers()
     // Initialize all standard bitmap or derived class handlers here.
     AddHandler(new wxXBMFileHandler);
     AddHandler(new wxXBMDataHandler);
     // Initialize all standard bitmap or derived class handlers here.
     AddHandler(new wxXBMFileHandler);
     AddHandler(new wxXBMDataHandler);

-    
-    // XPM is considered standard for Motif, although it can be omitted if absolutely
-    // necessary.
-#if wxUSE_XPM
+
+    // XPM is considered standard for Motif, although it can be omitted if
+    // libXpm is not installed
+#if wxHAVE_LIB_XPM

     AddHandler(new wxXPMFileHandler);
     AddHandler(new wxXPMDataHandler);
     AddHandler(new wxXPMFileHandler);
     AddHandler(new wxXPMDataHandler);

-#endif
+#endif // wxHAVE_LIB_XPM

 }
 
 WXPixmap wxBitmap::GetLabelPixmap (WXWidget w)
 {
     if (M_BITMAPDATA->m_image == (WXPixmap) 0)
         return M_BITMAPDATA->m_pixmap;
 }
 
 WXPixmap wxBitmap::GetLabelPixmap (WXWidget w)
 {
     if (M_BITMAPDATA->m_image == (WXPixmap) 0)
         return M_BITMAPDATA->m_pixmap;

-    
+

     Display *dpy = (Display*) M_BITMAPDATA->m_display;
     Display *dpy = (Display*) M_BITMAPDATA->m_display;

-    
+

 #ifdef FOO
     /*
     If we do:
     if (labelPixmap) return labelPixmap;
     things can be wrong, because colors can have been changed.
 #ifdef FOO
     /*
     If we do:
     if (labelPixmap) return labelPixmap;
     things can be wrong, because colors can have been changed.

-    
+

       If we do:
       if (labelPixmap)
       XmDestroyPixmap(DefaultScreenOfDisplay(dpy),labelPixmap) ;
       we got BadDrawable if the pixmap is referenced by multiples widgets
       If we do:
       if (labelPixmap)
       XmDestroyPixmap(DefaultScreenOfDisplay(dpy),labelPixmap) ;
       we got BadDrawable if the pixmap is referenced by multiples widgets

-      
+

         this is a catch22!!
         this is a catch22!!

-        
+

           So, before doing thing really clean, I just do nothing; if the pixmap is
           referenced by many widgets, Motif performs caching functions.
           And if pixmap is referenced with multiples colors, we just have some
           So, before doing thing really clean, I just do nothing; if the pixmap is
           referenced by many widgets, Motif performs caching functions.
           And if pixmap is referenced with multiples colors, we just have some


@@ -827,19 +827,19 @@ WXPixmap wxBitmap::GetLabelPixmap (WXWidget w)
     if (M_BITMAPDATA->m_labelPixmap)
         XmDestroyPixmap (DefaultScreenOfDisplay (dpy), M_BITMAPDATA->m_labelPixmap);
 #endif
     if (M_BITMAPDATA->m_labelPixmap)
         XmDestroyPixmap (DefaultScreenOfDisplay (dpy), M_BITMAPDATA->m_labelPixmap);
 #endif

-    
+

     char tmp[128];
     sprintf (tmp, "Im%x", (unsigned int) M_BITMAPDATA->m_image);
     char tmp[128];
     sprintf (tmp, "Im%x", (unsigned int) M_BITMAPDATA->m_image);

-    
+

     Pixel fg, bg;
     Widget widget = (Widget) w;
     Pixel fg, bg;
     Widget widget = (Widget) w;

-    
+

     while (XmIsGadget ( widget ))
         widget = XtParent (widget);
     XtVaGetValues (widget, XmNbackground, &bg, XmNforeground, &fg, NULL);
     while (XmIsGadget ( widget ))
         widget = XtParent (widget);
     XtVaGetValues (widget, XmNbackground, &bg, XmNforeground, &fg, NULL);

-    
+

     M_BITMAPDATA->m_labelPixmap = (WXPixmap) XmGetPixmap (DefaultScreenOfDisplay (dpy), tmp, fg, bg);
     M_BITMAPDATA->m_labelPixmap = (WXPixmap) XmGetPixmap (DefaultScreenOfDisplay (dpy), tmp, fg, bg);

-    
+

     return M_BITMAPDATA->m_labelPixmap;
 }
 
     return M_BITMAPDATA->m_labelPixmap;
 }
 


@@ -847,7 +847,7 @@ WXPixmap wxBitmap::GetArmPixmap (WXWidget w)
 {
     if (M_BITMAPDATA->m_image == (WXPixmap) 0)
         return M_BITMAPDATA->m_pixmap;
 {
     if (M_BITMAPDATA->m_image == (WXPixmap) 0)
         return M_BITMAPDATA->m_pixmap;

-    
+

     Display *dpy = (Display*) M_BITMAPDATA->m_display;
 #ifdef FOO
     See GetLabelPixmap () comment
     Display *dpy = (Display*) M_BITMAPDATA->m_display;
 #ifdef FOO
     See GetLabelPixmap () comment


@@ -855,30 +855,30 @@ WXPixmap wxBitmap::GetArmPixmap (WXWidget w)
         if (M_BITMAPDATA->m_armPixmap)
             XmDestroyPixmap (DefaultScreenOfDisplay (dpy), M_BITMAPDATA->m_armPixmap);
 #endif
         if (M_BITMAPDATA->m_armPixmap)
             XmDestroyPixmap (DefaultScreenOfDisplay (dpy), M_BITMAPDATA->m_armPixmap);
 #endif

-        
+

         char tmp[128];
         sprintf (tmp, "Im%x", (unsigned int) M_BITMAPDATA->m_image);
         char tmp[128];
         sprintf (tmp, "Im%x", (unsigned int) M_BITMAPDATA->m_image);

-        
+

         Pixel fg, bg;
         Widget widget = (Widget) w;
         Pixel fg, bg;
         Widget widget = (Widget) w;

-        
+

         XtVaGetValues (widget, XmNarmColor, &bg, NULL);
         while (XmIsGadget (widget))
             widget = XtParent (widget);
         XtVaGetValues (widget, XmNforeground, &fg, NULL);
         XtVaGetValues (widget, XmNarmColor, &bg, NULL);
         while (XmIsGadget (widget))
             widget = XtParent (widget);
         XtVaGetValues (widget, XmNforeground, &fg, NULL);

-        
+

         M_BITMAPDATA->m_armPixmap = (WXPixmap) XmGetPixmap (DefaultScreenOfDisplay (dpy), tmp, fg, bg);
         M_BITMAPDATA->m_armPixmap = (WXPixmap) XmGetPixmap (DefaultScreenOfDisplay (dpy), tmp, fg, bg);

-        
+

         return M_BITMAPDATA->m_armPixmap;
 }
 
 WXPixmap wxBitmap::GetInsensPixmap (WXWidget w)
 {
     Display *dpy = (Display*) M_BITMAPDATA->m_display;
         return M_BITMAPDATA->m_armPixmap;
 }
 
 WXPixmap wxBitmap::GetInsensPixmap (WXWidget w)
 {
     Display *dpy = (Display*) M_BITMAPDATA->m_display;

-    
+

     if (M_BITMAPDATA->m_insensPixmap)
         return M_BITMAPDATA->m_insensPixmap;
     if (M_BITMAPDATA->m_insensPixmap)
         return M_BITMAPDATA->m_insensPixmap;

-    
+

     if (!w)
     {
         M_BITMAPDATA->m_insensPixmap = (WXPixmap) XCreateInsensitivePixmap(dpy, (Pixmap) M_BITMAPDATA->m_pixmap);
     if (!w)
     {
         M_BITMAPDATA->m_insensPixmap = (WXPixmap) XCreateInsensitivePixmap(dpy, (Pixmap) M_BITMAPDATA->m_pixmap);


@@ -887,29 +887,29 @@ WXPixmap wxBitmap::GetInsensPixmap (WXWidget w)
         else
             return M_BITMAPDATA->m_pixmap;
     }
         else
             return M_BITMAPDATA->m_pixmap;
     }

-    
+

     if (M_BITMAPDATA->m_insensImage == (WXPixmap) 0)
         return M_BITMAPDATA->m_pixmap;
     if (M_BITMAPDATA->m_insensImage == (WXPixmap) 0)
         return M_BITMAPDATA->m_pixmap;

-    
+

 #ifdef FOO
     See GetLabelPixmap () comment
         // Must be destroyed, because colours can have been changed!
         if (M_BITMAPDATA->m_insensPixmap)
             XmDestroyPixmap (DefaultScreenOfDisplay (dpy), (Pixmap) M_BITMAPDATA->m_insensPixmap);
 #endif
 #ifdef FOO
     See GetLabelPixmap () comment
         // Must be destroyed, because colours can have been changed!
         if (M_BITMAPDATA->m_insensPixmap)
             XmDestroyPixmap (DefaultScreenOfDisplay (dpy), (Pixmap) M_BITMAPDATA->m_insensPixmap);
 #endif

-        
+

         char tmp[128];
         sprintf (tmp, "Not%x", (unsigned int) M_BITMAPDATA->m_insensImage);
         char tmp[128];
         sprintf (tmp, "Not%x", (unsigned int) M_BITMAPDATA->m_insensImage);

-        
+

         Pixel fg, bg;
         Widget widget = (Widget) w;
         Pixel fg, bg;
         Widget widget = (Widget) w;

-        
+

         while (XmIsGadget (widget))
             widget = XtParent (widget);
         XtVaGetValues (widget, XmNbackground, &bg, XmNforeground, &fg, NULL);
         while (XmIsGadget (widget))
             widget = XtParent (widget);
         XtVaGetValues (widget, XmNbackground, &bg, XmNforeground, &fg, NULL);

-        
+

         M_BITMAPDATA->m_insensPixmap = (WXPixmap) XmGetPixmap (DefaultScreenOfDisplay (dpy), tmp, fg, bg);
         M_BITMAPDATA->m_insensPixmap = (WXPixmap) XmGetPixmap (DefaultScreenOfDisplay (dpy), tmp, fg, bg);

-        
+

         return M_BITMAPDATA->m_insensPixmap;
 }
 
         return M_BITMAPDATA->m_insensPixmap;
 }
 


@@ -919,32 +919,32 @@ WXPixmap wxBitmap::GetInsensPixmap (WXWidget w)
 
   NAME
   XCreateInsensitivePixmap - create a grayed-out copy of a pixmap
 
   NAME
   XCreateInsensitivePixmap - create a grayed-out copy of a pixmap

-  
+

     SYNOPSIS
     Pixmap XCreateInsensitivePixmap( Display *display, Pixmap pixmap )
     SYNOPSIS
     Pixmap XCreateInsensitivePixmap( Display *display, Pixmap pixmap )

-    
+

       DESCRIPTION
       This function creates a grayed-out copy of the argument pixmap, suitable
       for use as a XmLabel's XmNlabelInsensitivePixmap resource.
       DESCRIPTION
       This function creates a grayed-out copy of the argument pixmap, suitable
       for use as a XmLabel's XmNlabelInsensitivePixmap resource.

-      
+

         RETURN VALUES
         The return value is the new Pixmap id or zero on error.  Errors include
         a NULL display argument or an invalid Pixmap argument.
         RETURN VALUES
         The return value is the new Pixmap id or zero on error.  Errors include
         a NULL display argument or an invalid Pixmap argument.

-        
+

           ERRORS
           If one of the XLib functions fail, it will produce a X error.  The
           default X error handler prints a diagnostic and calls exit().
           ERRORS
           If one of the XLib functions fail, it will produce a X error.  The
           default X error handler prints a diagnostic and calls exit().

-          
+

             SEE ALSO
             XCopyArea(3), XCreateBitmapFromData(3), XCreateGC(3), XCreatePixmap(3),
             XFillRectangle(3), exit(2)
             SEE ALSO
             XCopyArea(3), XCreateBitmapFromData(3), XCreateGC(3), XCreatePixmap(3),
             XFillRectangle(3), exit(2)

-            
+

               AUTHOR
               John R Veregge - john@puente.jpl.nasa.gov
               Advanced Engineering and Prototyping Group (AEG)
               Information Systems Technology Section (395)
               Jet Propulsion Lab - Calif Institute of Technology
               AUTHOR
               John R Veregge - john@puente.jpl.nasa.gov
               Advanced Engineering and Prototyping Group (AEG)
               Information Systems Technology Section (395)
               Jet Propulsion Lab - Calif Institute of Technology

-              
+

 *****************************************************************************/
 
 Pixmap
 *****************************************************************************/
 
 Pixmap


@@ -952,7 +952,7 @@ XCreateInsensitivePixmap( Display *display, Pixmap pixmap )
 
 {
     static
 
 {
     static

-        char    stipple_data[] = 
+        char    stipple_data[] =

     {
         0x55, 0x55, 0xAA, 0xAA, 0x55, 0x55, 0xAA, 0xAA,
             0x55, 0x55, 0xAA, 0xAA, 0x55, 0x55, 0xAA, 0xAA,
     {
         0x55, 0x55, 0xAA, 0xAA, 0x55, 0x55, 0xAA, 0xAA,
             0x55, 0x55, 0xAA, 0xAA, 0x55, 0x55, 0xAA, 0xAA,


@@ -962,21 +962,21 @@ XCreateInsensitivePixmap( Display *display, Pixmap pixmap )
     GC        gc;
     Pixmap    ipixmap, stipple;
     unsigned    width, height, depth;
     GC        gc;
     Pixmap    ipixmap, stipple;
     unsigned    width, height, depth;

-    
+

     Window    window;    /* These return values */
     unsigned    border;    /* from XGetGeometry() */
     int        x, y;    /* are not needed.     */
     Window    window;    /* These return values */
     unsigned    border;    /* from XGetGeometry() */
     int        x, y;    /* are not needed.     */

-    
+

     ipixmap = 0;
     ipixmap = 0;

-    
+

     if ( NULL == display || 0 == pixmap )
         return ipixmap;
     if ( NULL == display || 0 == pixmap )
         return ipixmap;

-    
+

     if ( 0 == XGetGeometry( display, pixmap, &window, &x, &y,
         &width, &height, &border, &depth )
         )
         return ipixmap; /* BadDrawable: probably an invalid pixmap */
     if ( 0 == XGetGeometry( display, pixmap, &window, &x, &y,
         &width, &height, &border, &depth )
         )
         return ipixmap; /* BadDrawable: probably an invalid pixmap */

-    
+

                         /* Get the stipple pixmap to be used to 'gray-out' the argument pixmap.
     */
     stipple = XCreateBitmapFromData( display, pixmap, stipple_data, 16, 16 );
                         /* Get the stipple pixmap to be used to 'gray-out' the argument pixmap.
     */
     stipple = XCreateBitmapFromData( display, pixmap, stipple_data, 16, 16 );


@@ -994,7 +994,7 @@ XCreateInsensitivePixmap( Display *display, Pixmap pixmap )
                 */
                 XCopyArea( display, pixmap, ipixmap,
                     gc, 0, 0, width, height, 0, 0 );
                 */
                 XCopyArea( display, pixmap, ipixmap,
                     gc, 0, 0, width, height, 0, 0 );

-                
+

                     /* Refill the new pixmap using the stipple algorithm/pixmap.
                 */
                 XSetStipple( display, gc, stipple );
                     /* Refill the new pixmap using the stipple algorithm/pixmap.
                 */
                 XSetStipple( display, gc, stipple );


@@ -1019,12 +1019,12 @@ wxBitmap wxCreateMaskedBitmap(wxBitmap& bitmap, wxColour& colour)
     wxMemoryDC srcDC;
     srcDC.SelectObject(bitmap);
     destDC.SelectObject(newBitmap);
     wxMemoryDC srcDC;
     srcDC.SelectObject(bitmap);
     destDC.SelectObject(newBitmap);

-    
+

     wxBrush brush(colour, wxSOLID);
     destDC.SetOptimization(FALSE);
     destDC.SetBackground(brush);
     destDC.Clear();
     destDC.Blit(0, 0, bitmap.GetWidth(), bitmap.GetHeight(), & srcDC, 0, 0, wxCOPY, TRUE);
     wxBrush brush(colour, wxSOLID);
     destDC.SetOptimization(FALSE);
     destDC.SetBackground(brush);
     destDC.Clear();
     destDC.Blit(0, 0, bitmap.GetWidth(), bitmap.GetHeight(), & srcDC, 0, 0, wxCOPY, TRUE);

-    
+

     return newBitmap;
 }
     return newBitmap;
 }