1. wxGCBoolRenderer looks better under MSW

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

diff --git a/src/motif/bitmap.cpp b/src/motif/bitmap.cpp
index 2f1b0e52188f5a2993dd20f2fb483078b49c3c0c..76aa578d775550802c658a805445ede07a65cdb1 100644 (file)
--- a/src/motif/bitmap.cpp
+++ b/src/motif/bitmap.cpp
@@ -21,19 +21,24 @@
 #include "wx/log.h"
 #include "wx/control.h"
 #include "wx/dcmemory.h"
 #include "wx/log.h"
 #include "wx/control.h"
 #include "wx/dcmemory.h"

+#include "wx/image.h"

 
 

+#ifdef __VMS__
+#pragma message disable nosimpint
+#endif

 #include <Xm/Xm.h>
 #include <Xm/Xm.h>

+#ifdef __VMS__
+#pragma message enable nosimpint
+#endif

 
 #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
 
 #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()
 {
 
 wxBitmapRefData::wxBitmapRefData()
 {


@@ -44,14 +49,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 +69,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 +90,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 +100,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;


@@ -103,10 +108,12 @@ wxBitmapRefData::~wxBitmapRefData()
 
 wxList wxBitmap::sm_handlers;
 
 
 wxList wxBitmap::sm_handlers;
 

+#define M_BMPDATA ((wxBitmapRefData *)m_refData)
+

 wxBitmap::wxBitmap()
 {
     m_refData = NULL;
 wxBitmap::wxBitmap()
 {
     m_refData = NULL;

-    
+

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


@@ -120,9 +127,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 +137,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 +145,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 +153,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 +164,40 @@ 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;
 }
 
     sg_Control = (wxControl*) NULL;
 }
 

+bool wxBitmap::CreateFromXpm(const char **bits)
+{
+    wxCHECK_MSG( bits, FALSE, _T("NULL pointer in wxBitmap::CreateFromXpm") );
+
+    return Create(bits, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0);
+}
+

 bool wxBitmap::Create(int w, int h, int d)
 {
     UnRef();
 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 +205,52 @@ 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 ) {
     if ( handler == NULL ) {

-        wxLogWarning("no bitmap handler for type %d defined.", type);
-        
-        return FALSE;
+        wxImage image;
+        if (!image.LoadFile( filename, type )) return FALSE;
+        if (image.Ok()) 
+        {
+            *this = image.ConvertToBitmap();
+            return TRUE;
+        }
+        else 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 ) {
     if ( handler == NULL ) {

-        wxLogWarning("no bitmap handler for type %d defined.", type);
-        
+        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);
-        
-        return FALSE;
+
+    if ( handler == NULL ) { // try wxImage
+        wxImage image( *this );
+        if (image.Ok()) return image.SaveFile( filename, type );
+        else return FALSE;

     }
     }

-    
+

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


@@ -239,7 +258,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 +266,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 +274,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 +282,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 +290,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 +298,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,10 +306,24 @@ 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 ;
 }
 

+wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const
+{
+    wxCHECK_MSG( Ok() &&
+                 (rect.x >= 0) && (rect.y >= 0) &&
+                 (rect.x+rect.width <= M_BMPDATA->m_width) && (rect.y+rect.height <= M_BMPDATA->m_height),
+                 wxNullBitmap, wxT("invalid bitmap or bitmap region") );
+
+    wxBitmap ret( rect.width, rect.height, 0 );
+    wxASSERT_MSG( ret.Ok(), wxT("GetSubBitmap error") );
+
+   // The remaining still TODO
+   return ret;
+}
+

 void wxBitmap::AddHandler(wxBitmapHandler *handler)
 {
     sm_handlers.Append(handler);
 void wxBitmap::AddHandler(wxBitmapHandler *handler)
 {
     sm_handlers.Append(handler);


@@ -367,7 +400,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 +409,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 +417,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 +457,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 +469,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 +489,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 +499,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 +523,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 +537,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 +570,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 +600,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 +621,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 +634,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 +654,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 +674,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 +691,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 +720,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 +754,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 +764,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 +781,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 +802,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,57 +822,57 @@ 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 Moif, 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
-          memory leaks... I hope we can deal with them...
+
+      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
+      memory leaks... I hope we can deal with them...

     */
     // Must be destroyed, because colours can have been changed!
     if (M_BITMAPDATA->m_labelPixmap)
         XmDestroyPixmap (DefaultScreenOfDisplay (dpy), M_BITMAPDATA->m_labelPixmap);
 #endif
     */
     // Must be destroyed, because colours can have been changed!
     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,38 +880,39 @@ 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
     Display *dpy = (Display*) M_BITMAPDATA->m_display;
 #ifdef FOO

-    See GetLabelPixmap () comment
-        // Must be destroyed, because colours can have been changed!
-        if (M_BITMAPDATA->m_armPixmap)
-            XmDestroyPixmap (DefaultScreenOfDisplay (dpy), M_BITMAPDATA->m_armPixmap);
+    // See GetLabelPixmap () comment
+
+    // Must be destroyed, because colours can have been changed!
+    if (M_BITMAPDATA->m_armPixmap)
+        XmDestroyPixmap (DefaultScreenOfDisplay (dpy), M_BITMAPDATA->m_armPixmap);

 #endif
 #endif

-        
-        char tmp[128];
-        sprintf (tmp, "Im%x", (unsigned int) M_BITMAPDATA->m_image);
-        
-        Pixel fg, bg;
-        Widget widget = (Widget) w;
-        
-        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);
-        
-        return M_BITMAPDATA->m_armPixmap;
+
+    char tmp[128];
+    sprintf (tmp, "Im%x", (unsigned int) M_BITMAPDATA->m_image);
+
+    Pixel fg, bg;
+    Widget widget = (Widget) w;
+
+    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);
+
+    return M_BITMAPDATA->m_armPixmap;

 }
 
 WXPixmap wxBitmap::GetInsensPixmap (WXWidget w)
 {
     Display *dpy = (Display*) M_BITMAPDATA->m_display;
 }
 
 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,30 +921,30 @@ 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);
-        
-        Pixel fg, bg;
-        Widget widget = (Widget) w;
-        
-        while (XmIsGadget (widget))
-            widget = XtParent (widget);
-        XtVaGetValues (widget, XmNbackground, &bg, XmNforeground, &fg, NULL);
-        
-        M_BITMAPDATA->m_insensPixmap = (WXPixmap) XmGetPixmap (DefaultScreenOfDisplay (dpy), tmp, fg, bg);
-        
-        return M_BITMAPDATA->m_insensPixmap;
+
+    char tmp[128];
+    sprintf (tmp, "Not%x", (unsigned int) M_BITMAPDATA->m_insensImage);
+
+    Pixel fg, bg;
+    Widget widget = (Widget) w;
+
+    while (XmIsGadget (widget))
+        widget = XtParent (widget);
+    XtVaGetValues (widget, XmNbackground, &bg, XmNforeground, &fg, NULL);
+
+    M_BITMAPDATA->m_insensPixmap = (WXPixmap) XmGetPixmap (DefaultScreenOfDisplay (dpy), tmp, fg, bg);
+
+    return M_BITMAPDATA->m_insensPixmap;

 }
 
 // We may need this sometime...
 }
 
 // We may need this sometime...


@@ -919,84 +953,83 @@ 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 )
-    
-      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.
-        
-          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)
-            
-              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
-              
+
+  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.
+
+  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().
+
+  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
+

 *****************************************************************************/
 
 Pixmap
 XCreateInsensitivePixmap( Display *display, Pixmap pixmap )
 
 {
 *****************************************************************************/
 
 Pixmap
 XCreateInsensitivePixmap( Display *display, Pixmap pixmap )
 
 {

-    static
-        char    stipple_data[] = 
-    {
-        0x55, 0x55, 0xAA, 0xAA, 0x55, 0x55, 0xAA, 0xAA,
+    static 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
             0x55, 0x55, 0xAA, 0xAA, 0x55, 0x55, 0xAA, 0xAA,
             0x55, 0x55, 0xAA, 0xAA, 0x55, 0x55, 0xAA, 0xAA,
             0x55, 0x55, 0xAA, 0xAA, 0x55, 0x55, 0xAA, 0xAA

-    };
+        };

     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,
     if ( 0 == XGetGeometry( display, pixmap, &window, &x, &y,

-        &width, &height, &border, &depth )
-        )
+                &width, &height, &border, &depth )
+       )

         return ipixmap; /* BadDrawable: probably an invalid pixmap */
         return ipixmap; /* BadDrawable: probably an invalid pixmap */

-    
-                        /* Get the stipple pixmap to be used to 'gray-out' the argument pixmap.
-    */
+
+    /* Get the stipple pixmap to be used to 'gray-out' the argument pixmap.
+     */

     stipple = XCreateBitmapFromData( display, pixmap, stipple_data, 16, 16 );
     if ( 0 != stipple )
     {
         gc = XCreateGC( display, pixmap, (XtGCMask)0, (XGCValues*)NULL );
         if ( NULL != gc )
         {
     stipple = XCreateBitmapFromData( display, pixmap, stipple_data, 16, 16 );
     if ( 0 != stipple )
     {
         gc = XCreateGC( display, pixmap, (XtGCMask)0, (XGCValues*)NULL );
         if ( NULL != gc )
         {

-        /* Create an identical copy of the argument pixmap.
-            */
+            /* Create an identical copy of the argument pixmap.
+             */

             ipixmap = XCreatePixmap( display, pixmap, width, height, depth );
             if ( 0 != ipixmap )
             {
             ipixmap = XCreatePixmap( display, pixmap, width, height, depth );
             if ( 0 != ipixmap )
             {

-            /* Copy the argument pixmap into the new pixmap.
-                */
+                /* Copy the argument pixmap into the new pixmap.
+                 */

                 XCopyArea( display, pixmap, ipixmap,
                 XCopyArea( display, pixmap, ipixmap,

-                    gc, 0, 0, width, height, 0, 0 );
-                
-                    /* Refill the new pixmap using the stipple algorithm/pixmap.
-                */
+                        gc, 0, 0, width, height, 0, 0 );
+
+                /* Refill the new pixmap using the stipple algorithm/pixmap.
+                 */

                 XSetStipple( display, gc, stipple );
                 XSetFillStyle( display, gc, FillStippled );
                 XFillRectangle( display, ipixmap, gc, 0, 0, width, height );
                 XSetStipple( display, gc, stipple );
                 XSetFillStyle( display, gc, FillStippled );
                 XFillRectangle( display, ipixmap, gc, 0, 0, width, height );


@@ -1010,7 +1043,7 @@ XCreateInsensitivePixmap( Display *display, Pixmap pixmap )
 
 // Creates a bitmap with transparent areas drawn in
 // the given colour.
 
 // Creates a bitmap with transparent areas drawn in
 // the given colour.

-wxBitmap wxCreateMaskedBitmap(wxBitmap& bitmap, wxColour& colour)
+wxBitmap wxCreateMaskedBitmap(const wxBitmap& bitmap, wxColour& colour)

 {
     wxBitmap newBitmap(bitmap.GetWidth(),
         bitmap.GetHeight(),
 {
     wxBitmap newBitmap(bitmap.GetWidth(),
         bitmap.GetHeight(),


@@ -1019,12 +1052,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;
 }