]> git.saurik.com Git - wxWidgets.git/blobdiff - src/x11/bitmap.cpp
projects / wxWidgets.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Fit the generic preferences editor dialog to its pages size initially.
[wxWidgets.git] / src / x11 / bitmap.cpp
diff --git a/src/x11/bitmap.cpp b/src/x11/bitmap.cpp
index 398e85126f310ecc011aaad5b6bccdb11291aae6..b35d0861ac25df8eb109781615bde9e2ae98746d 100644 (file)
--- a/src/x11/bitmap.cpp
+++ b/src/x11/bitmap.cpp
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////
-// Name:        bitmap.cpp
+// Name:        src/x11/bitmap.cpp
 // Purpose:     wxBitmap
 // Author:      Julian Smart, Robert Roebling
 // Modified by:
 // Purpose:     wxBitmap
 // Author:      Julian Smart, Robert Roebling
 // Modified by:
@@ -9,17 +9,18 @@
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
-#ifdef __GNUG__
-#pragma implementation "bitmap.h"
-#endif
+// for compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
 
 #include "wx/bitmap.h"
 
 #include "wx/bitmap.h"
-#include "wx/icon.h"
-#include "wx/log.h"
-#include "wx/image.h"
-#include "wx/app.h"
-#if wxUSE_NANOX
-#include "wx/dcmemory.h"
+
+#ifndef WX_PRECOMP
+    #include "wx/log.h"
+    #include "wx/app.h"
+    #include "wx/dcmemory.h"
+    #include "wx/icon.h"
+    #include "wx/math.h"
+    #include "wx/image.h"
 #endif
 
 #include "wx/x11/private.h"
 #endif
 
 #include "wx/x11/private.h"
@@ -33,6 +34,10 @@
 bool wxGetImageFromDrawable(GR_DRAW_ID drawable, int srcX, int srcY, int width, int height, wxImage& image);
 #endif
 
 bool wxGetImageFromDrawable(GR_DRAW_ID drawable, int srcX, int srcY, int width, int height, wxImage& image);
 #endif
 
+static WXPixmap wxGetSubPixmap( WXDisplay* xdisplay, WXPixmap xpixmap,
+                                int x, int y, int width, int height,
+                                int depth );
+
 #if wxUSE_XPM
 #if wxHAVE_LIB_XPM
 #include <X11/xpm.h>
 #if wxUSE_XPM
 #if wxHAVE_LIB_XPM
 #include <X11/xpm.h>
@@ -41,7 +46,6 @@ bool wxGetImageFromDrawable(GR_DRAW_ID drawable, int srcX, int srcY, int width,
 #include "wx/wfstream.h"
 #endif
 #endif
 #include "wx/wfstream.h"
 #endif
 #endif
-#include <math.h>
 
 //-----------------------------------------------------------------------------
 // wxMask
 
 //-----------------------------------------------------------------------------
 // wxMask
@@ -55,6 +59,24 @@ wxMask::wxMask()
     m_display = NULL;
 }
 
     m_display = NULL;
 }
 
+wxMask::wxMask(const wxMask& mask)
+{
+    m_display = mask.m_display;
+    if ( !mask.m_bitmap )
+    {
+        m_bitmap = NULL;
+        return;
+    }
+
+    m_size = mask.m_size;
+
+    // Duplicate the mask bitmap using the existing wxGetSubPixmap() function.
+    // There are probably/surely better ways to do it.
+    m_bitmap = wxGetSubPixmap(m_display, mask.m_bitmap,
+                              0, 0, m_size.x, m_size.y,
+                              1);
+}
+
 wxMask::wxMask( const wxBitmap& bitmap, const wxColour& colour )
 {
     m_bitmap = NULL;
 wxMask::wxMask( const wxBitmap& bitmap, const wxColour& colour )
 {
     m_bitmap = NULL;
@@ -82,6 +104,8 @@ wxMask::~wxMask()
 bool wxMask::Create( const wxBitmap& bitmap,
                      const wxColour& colour )
 {
 bool wxMask::Create( const wxBitmap& bitmap,
                      const wxColour& colour )
 {
+    m_size = bitmap.GetSize();
+
 #if !wxUSE_NANOX
     if (m_bitmap)
     {
 #if !wxUSE_NANOX
     if (m_bitmap)
     {
@@ -92,14 +116,14 @@ bool wxMask::Create( const wxBitmap& bitmap,
     m_display = bitmap.GetDisplay();
 
     wxImage image = bitmap.ConvertToImage();
     m_display = bitmap.GetDisplay();
 
     wxImage image = bitmap.ConvertToImage();
-    if (!image.Ok()) return FALSE;
-    
+    if (!image.IsOk()) return false;
+
     m_display = bitmap.GetDisplay();
     m_display = bitmap.GetDisplay();
-    
+
     Display *xdisplay = (Display*) m_display;
     int xscreen = DefaultScreen( xdisplay );
     Window xroot = RootWindow( xdisplay, xscreen );
     Display *xdisplay = (Display*) m_display;
     int xscreen = DefaultScreen( xdisplay );
     Window xroot = RootWindow( xdisplay, xscreen );
-    
+
     m_bitmap = (WXPixmap) XCreatePixmap( xdisplay, xroot, image.GetWidth(), image.GetHeight(), 1 );
     GC gc = XCreateGC( xdisplay, (Pixmap) m_bitmap, 0, NULL );
 
     m_bitmap = (WXPixmap) XCreatePixmap( xdisplay, xroot, image.GetWidth(), image.GetHeight(), 1 );
     GC gc = XCreateGC( xdisplay, (Pixmap) m_bitmap, 0, NULL );
 
@@ -114,25 +138,25 @@ bool wxMask::Create( const wxBitmap& bitmap,
     unsigned char green = colour.Green();
     unsigned char blue = colour.Blue();
 
     unsigned char green = colour.Green();
     unsigned char blue = colour.Blue();
 
-    int bpp = wxTheApp->m_visualDepth;
-    
+    int bpp = wxTheApp->GetVisualInfo(m_display)->m_visualDepth;
+
     if (bpp == 15)
     {
     if (bpp == 15)
     {
-        red = red & 0xf8;
-        green = green & 0xf8;
-        blue = blue & 0xf8;
+        red &= 0xf8;
+        green &= 0xf8;
+        blue &= 0xf8;
     } else
     if (bpp == 16)
     {
     } else
     if (bpp == 16)
     {
-        red = red & 0xf8;
-        green = green & 0xfc;
-        blue = blue & 0xf8;
+        red &= 0xf8;
+        green &= 0xfc;
+        blue &= 0xf8;
     } else
     if (bpp == 12)
     {
     } else
     if (bpp == 12)
     {
-        red = red & 0xf0;
-        green = green & 0xf0;
-        blue = blue & 0xf0;
+        red &= 0xf0;
+        green &= 0xf0;
+        blue &= 0xf0;
     }
 
     XSetForeground( xdisplay, gc, BlackPixel(xdisplay,xscreen) );
     }
 
     XSetForeground( xdisplay, gc, BlackPixel(xdisplay,xscreen) );
@@ -165,12 +189,12 @@ bool wxMask::Create( const wxBitmap& bitmap,
         if (start_x != -1)
             XDrawLine( xdisplay, (Pixmap) m_bitmap, gc, start_x, j, i, j );
     }
         if (start_x != -1)
             XDrawLine( xdisplay, (Pixmap) m_bitmap, gc, start_x, j, i, j );
     }
-    
+
     XFreeGC( xdisplay, gc );
 
     XFreeGC( xdisplay, gc );
 
-    return TRUE;
+    return true;
 #else
 #else
-    return FALSE;
+    return false;
 #endif
     // wxUSE_NANOX
 }
 #endif
     // wxUSE_NANOX
 }
@@ -180,7 +204,7 @@ bool wxMask::Create( const wxBitmap& bitmap, int paletteIndex )
     unsigned char r,g,b;
     wxPalette *pal = bitmap.GetPalette();
 
     unsigned char r,g,b;
     wxPalette *pal = bitmap.GetPalette();
 
-    wxCHECK_MSG( pal, FALSE, wxT("Cannot create mask from bitmap without palette") );
+    wxCHECK_MSG( pal, false, wxT("Cannot create mask from bitmap without palette") );
 
     pal->GetRGB(paletteIndex, &r, &g, &b);
 
 
     pal->GetRGB(paletteIndex, &r, &g, &b);
 
@@ -196,46 +220,52 @@ bool wxMask::Create( const wxBitmap& bitmap )
         m_bitmap = NULL;
     }
 
         m_bitmap = NULL;
     }
 
-    if (!bitmap.Ok()) return FALSE;
+    if (!bitmap.IsOk()) return false;
+
+    wxCHECK_MSG( bitmap.GetBitmap(), false, wxT("Cannot create mask from colour bitmap") );
 
 
-    wxCHECK_MSG( bitmap.GetBitmap(), FALSE, wxT("Cannot create mask from colour bitmap") );
-    
     m_display = bitmap.GetDisplay();
 
     int xscreen = DefaultScreen( (Display*) m_display );
     Window xroot = RootWindow( (Display*) m_display, xscreen );
     m_display = bitmap.GetDisplay();
 
     int xscreen = DefaultScreen( (Display*) m_display );
     Window xroot = RootWindow( (Display*) m_display, xscreen );
-    
+
     m_bitmap = (WXPixmap) XCreatePixmap( (Display*) m_display, xroot, bitmap.GetWidth(), bitmap.GetHeight(), 1 );
 
     m_bitmap = (WXPixmap) XCreatePixmap( (Display*) m_display, xroot, bitmap.GetWidth(), bitmap.GetHeight(), 1 );
 
-    if (!m_bitmap) return FALSE;
-    
+    if (!m_bitmap) return false;
+
     GC gc = XCreateGC( (Display*) m_display, (Pixmap) m_bitmap, 0, NULL );
 
     XCopyPlane( (Display*) m_display, (Pixmap) bitmap.GetBitmap(), (Pixmap) m_bitmap,
        gc, 0, 0, bitmap.GetWidth(), bitmap.GetHeight(), 0, 0, 1 );
     GC gc = XCreateGC( (Display*) m_display, (Pixmap) m_bitmap, 0, NULL );
 
     XCopyPlane( (Display*) m_display, (Pixmap) bitmap.GetBitmap(), (Pixmap) m_bitmap,
        gc, 0, 0, bitmap.GetWidth(), bitmap.GetHeight(), 0, 0, 1 );
-       
+
     XFreeGC( (Display*) m_display, gc );
 
     XFreeGC( (Display*) m_display, gc );
 
-    return TRUE;
+    return true;
 #else
 #else
-    return FALSE;
+    return false;
 #endif
     // wxUSE_NANOX
 }
 
 //-----------------------------------------------------------------------------
 #endif
     // wxUSE_NANOX
 }
 
 //-----------------------------------------------------------------------------
-// wxBitmap
+// wxBitmapRefData
 //-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------
 
-class wxBitmapRefData: public wxObjectRefData
+class wxBitmapRefData : public wxGDIRefData
 {
 public:
     wxBitmapRefData();
 {
 public:
     wxBitmapRefData();
-    ~wxBitmapRefData();
+    wxBitmapRefData(const wxBitmapRefData& data);
+    virtual ~wxBitmapRefData();
+
+    // shouldn't be called more than once as it doesn't free the existing data
+    bool Create(int width, int height, int depth);
 
 
-    WXPixmap        m_pixmap;
-    WXPixmap        m_bitmap;
-    WXDisplay      *m_display;
+    virtual bool IsOk() const { return m_pixmap || m_bitmap; }
+
+    Pixmap          m_pixmap;
+    Pixmap          m_bitmap;
+    Display        *m_display;
     wxMask         *m_mask;
     int             m_width;
     int             m_height;
     wxMask         *m_mask;
     int             m_width;
     int             m_height;
@@ -245,22 +275,67 @@ public:
 
 wxBitmapRefData::wxBitmapRefData()
 {
 
 wxBitmapRefData::wxBitmapRefData()
 {
-    m_pixmap = NULL;
-    m_bitmap = NULL;
+    m_pixmap = 0;
+    m_bitmap = 0;
     m_display = NULL;
     m_display = NULL;
-    m_mask = (wxMask *) NULL;
+    m_mask = NULL;
     m_width = 0;
     m_height = 0;
     m_bpp = 0;
     m_width = 0;
     m_height = 0;
     m_bpp = 0;
-    m_palette = (wxPalette *) NULL;
+    m_palette = NULL;
+}
+
+wxBitmapRefData::wxBitmapRefData(const wxBitmapRefData& data)
+{
+    m_pixmap = 0;
+    m_bitmap = 0;
+    m_display = data.m_display;
+    m_mask = NULL; // FIXME: should copy
+    m_palette = NULL; // FIXME: should copy
+
+    Create(data.m_width, data.m_height, data.m_bpp);
+}
+
+bool wxBitmapRefData::Create(int width, int height, int depth)
+{
+    m_width = width;
+    m_height = height;
+    m_bpp = depth;
+
+    m_display = wxGlobalDisplay();
+
+    wxCHECK_MSG( m_display, false, wxT("No display") );
+
+    int xscreen = DefaultScreen(m_display);
+    int bpp = DefaultDepth(m_display, xscreen);
+    if ( depth == -1 )
+        depth = bpp;
+
+    wxCHECK_MSG( (depth == bpp) || (depth == 1), false,
+                 wxT("invalid bitmap depth") );
+
+#if wxUSE_NANOX
+    m_pixmap = (WXPixmap) GrNewPixmap(width, height, NULL);
+#else // !wxUSE_NANOX
+    Window xroot = RootWindow(m_display, xscreen);
+
+    *(depth == 1 ? &m_bitmap : &m_pixmap) =
+        XCreatePixmap(m_display, xroot, width, height, depth);
+#endif // wxUSE_NANOX/!wxUSE_NANOX
+
+    wxCHECK_MSG( m_pixmap || m_bitmap, false, wxT("Bitmap creation failed") );
+
+    return true;
 }
 
 wxBitmapRefData::~wxBitmapRefData()
 {
 }
 
 wxBitmapRefData::~wxBitmapRefData()
 {
-    if (m_pixmap) XFreePixmap( (Display*) m_display, (Pixmap) m_pixmap );
-    if (m_bitmap) XFreePixmap( (Display*) m_display, (Pixmap) m_bitmap );
-    if (m_mask) delete m_mask;
-    if (m_palette) delete m_palette;
+    if (m_pixmap)
+       XFreePixmap(m_display, m_pixmap);
+    if (m_bitmap)
+       XFreePixmap(m_display, m_bitmap);
+    delete m_mask;
+    delete m_palette;
 }
 
 //-----------------------------------------------------------------------------
 }
 
 //-----------------------------------------------------------------------------
@@ -271,94 +346,52 @@ static WXPixmap wxGetSubPixmap( WXDisplay* xdisplay, WXPixmap xpixmap,
                                 int x, int y, int width, int height,
                                 int depth )
 {
                                 int x, int y, int width, int height,
                                 int depth )
 {
-    int xscreen = DefaultScreen( (Display*)xdisplay );
-    Window xroot = RootWindow( (Display*)xdisplay, xscreen );
-    Visual* xvisual = DefaultVisual( xdisplay, xscreen );
+    Display * const dpy = (Display *)xdisplay;
 
 
-    XImage* ximage = XCreateImage( (Display*)xdisplay, xvisual, depth,
+    int xscreen = DefaultScreen( dpy );
+    Window xroot = RootWindow( dpy, xscreen );
+    Visual* xvisual = DefaultVisual( dpy, xscreen );
+
+    XImage* ximage = XCreateImage( dpy, xvisual, depth,
                                    ZPixmap, 0, 0, width, height, 32, 0 );
     ximage->data = (char*)malloc( ximage->bytes_per_line * ximage->height );
                                    ZPixmap, 0, 0, width, height, 32, 0 );
     ximage->data = (char*)malloc( ximage->bytes_per_line * ximage->height );
-    ximage = XGetSubImage( (Display*)xdisplay, (Pixmap)xpixmap,
-                           x, y, width, height, 
+    ximage = XGetSubImage( dpy, (Pixmap)xpixmap,
+                           x, y, width, height,
                            AllPlanes, ZPixmap, ximage, 0, 0 );
 
                            AllPlanes, ZPixmap, ximage, 0, 0 );
 
-    GC gc = XCreateGC( (Display*)xdisplay, (Pixmap)xpixmap, 0, NULL );
-    Pixmap ret = XCreatePixmap( (Display*)xdisplay, xroot,
+    GC gc = XCreateGC( dpy, (Pixmap)xpixmap, 0, NULL );
+    Pixmap ret = XCreatePixmap( dpy, xroot,
                                 width, height, depth );
 
                                 width, height, depth );
 
-    XPutImage( (Display*)xdisplay, ret, gc, ximage,
+    XPutImage( dpy, ret, gc, ximage,
                0, 0, 0, 0, width, height );
     XDestroyImage( ximage );
                0, 0, 0, 0, width, height );
     XDestroyImage( ximage );
-    XFreeGC( (Display*)xdisplay, gc );
+    XFreeGC( dpy, gc );
 
     return (WXPixmap)ret;
 }
 
 
     return (WXPixmap)ret;
 }
 
-#define M_BMPDATA ((wxBitmapRefData *)m_refData)
 
 
-IMPLEMENT_DYNAMIC_CLASS(wxBitmap,wxGDIObject)
+//-----------------------------------------------------------------------------
+// wxBitmap
+//-----------------------------------------------------------------------------
 
 
-wxBitmap::wxBitmap()
-{
-}
+#define M_BMPDATA ((wxBitmapRefData *)m_refData)
 
 
-wxBitmap::wxBitmap( int width, int height, int depth )
-{
-    Create( width, height, depth );
-}
+IMPLEMENT_DYNAMIC_CLASS(wxBitmap,wxGDIObject)
 
 bool wxBitmap::Create( int width, int height, int depth )
 {
     UnRef();
 
 
 bool wxBitmap::Create( int width, int height, int depth )
 {
     UnRef();
 
-    wxCHECK_MSG( (width > 0) && (height > 0), FALSE, wxT("invalid bitmap size") )
+    wxCHECK_MSG( (width > 0) && (height > 0), false, wxT("invalid bitmap size") );
 
     m_refData = new wxBitmapRefData();
 
     m_refData = new wxBitmapRefData();
-    
-    M_BMPDATA->m_display = wxGlobalDisplay();
-    
-    wxASSERT_MSG( M_BMPDATA->m_display, wxT("No display") );
-    
-    int xscreen = DefaultScreen( (Display*) M_BMPDATA->m_display );
-    Window xroot = RootWindow( (Display*) M_BMPDATA->m_display, xscreen );
-    
-    int bpp = DefaultDepth( (Display*) M_BMPDATA->m_display, xscreen );
-    if (depth == -1) depth = bpp;
-
-    wxCHECK_MSG( (depth == bpp) ||
-                 (depth == 1), FALSE, wxT("invalid bitmap depth") )
-
-    M_BMPDATA->m_mask = (wxMask *) NULL;
-    M_BMPDATA->m_width = width;
-    M_BMPDATA->m_height = height;
 
 
-#if wxUSE_NANOX
-    M_BMPDATA->m_pixmap = (WXPixmap) GrNewPixmap(width, height, NULL);
-    M_BMPDATA->m_bpp = bpp;
-
-    wxASSERT_MSG( M_BMPDATA->m_pixmap, wxT("Bitmap creation failed") );
-#else
-    if (depth == 1)
-    {
-        M_BMPDATA->m_bitmap = (WXPixmap) XCreatePixmap( (Display*) M_BMPDATA->m_display, xroot, width, height, 1 );
-        
-        wxASSERT_MSG( M_BMPDATA->m_bitmap, wxT("Bitmap creation failed") );
-        
-        M_BMPDATA->m_bpp = 1;
-    }
-    else
-    {
-        M_BMPDATA->m_pixmap = (WXPixmap) XCreatePixmap( (Display*) M_BMPDATA->m_display, xroot, width, height, depth );
-        
-        wxASSERT_MSG( M_BMPDATA->m_pixmap, wxT("Pixmap creation failed") );
-        
-        M_BMPDATA->m_bpp = depth;
-    }
-#endif
-    return Ok();
+    return M_BMPDATA->Create(width, height, depth);
 }
 
 }
 
-bool wxBitmap::Create(void *data, wxBitmapType type,
+bool wxBitmap::Create(const void* data, wxBitmapType type,
                       int width, int height, int depth)
 {
     UnRef();
                       int width, int height, int depth)
 {
     UnRef();
@@ -366,36 +399,83 @@ bool wxBitmap::Create(void *data, wxBitmapType type,
     wxBitmapHandler *handler = FindHandler(type);
 
     if ( handler == NULL ) {
     wxBitmapHandler *handler = FindHandler(type);
 
     if ( handler == NULL ) {
-        wxLogWarning("no data bitmap handler for type %ld defined.",
+        wxLogWarning(wxT("no data bitmap handler for type %ld defined."),
                      (long)type);
 
                      (long)type);
 
-        return FALSE;
+        return false;
     }
 
     return handler->Create(this, data, type, width, height, depth);
 }
 
     }
 
     return handler->Create(this, data, type, width, height, depth);
 }
 
-bool wxBitmap::CreateFromXpm( const char **bits )
+bool wxBitmap::Create(WXPixmap pixmap)
 {
 {
-    wxCHECK_MSG( bits, FALSE, _T("NULL pointer in wxBitmap::CreateFromXpm") );
+    UnRef();
+    Pixmap xpixmap = (Pixmap)pixmap;
+    Display* xdisplay = wxGlobalDisplay();
+    int xscreen = DefaultScreen( xdisplay );
+    Window xroot = RootWindow( xdisplay, xscreen );
+
+    // make a copy of the Pixmap
+    Window root;
+    int x, y;
+    unsigned width, height, border, depth;
+
+    XGetGeometry( xdisplay, (Drawable)xpixmap, &root, &x, &y,
+                  &width, &height, &border, &depth );
+    Pixmap copy = XCreatePixmap( xdisplay, xroot, width, height, depth );
+
+    GC gc = XCreateGC( xdisplay, copy, 0, NULL );
+    XCopyArea( xdisplay, xpixmap, copy, gc, 0, 0, width, height, 0, 0 );
+    XFreeGC( xdisplay, gc );
+
+    // fill in ref data
+    wxBitmapRefData* ref = new wxBitmapRefData();
 
 
-    return Create(bits, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0);
+    if( depth == 1 )
+        ref->m_bitmap = copy;
+    else
+        ref->m_pixmap = copy;
+
+    ref->m_display = xdisplay;
+    ref->m_width = width;
+    ref->m_height = height;
+    ref->m_bpp = depth;
+
+    m_refData = ref;
+
+    return true;
+}
+
+wxBitmap::wxBitmap(const char* const* bits)
+{
+    Create(bits, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0);
+}
+
+wxGDIRefData *wxBitmap::CreateGDIRefData() const
+{
+    return new wxBitmapRefData;
+}
+
+wxGDIRefData *wxBitmap::CloneGDIRefData(const wxGDIRefData *data) const
+{
+    return new wxBitmapRefData(*static_cast<const wxBitmapRefData *>(data));
 }
 
 bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
 {
 #if wxUSE_NANOX
 }
 
 bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
 {
 #if wxUSE_NANOX
-    if (!image.Ok())
+    if (!image.IsOk())
     {
     {
-        wxASSERT_MSG(image.Ok(), "Invalid wxImage passed to wxBitmap::CreateFromImage.");
-        return FALSE;
+        wxASSERT_MSG(image.IsOk(), wxT("Invalid wxImage passed to wxBitmap::CreateFromImage."));
+        return false;
     }
     }
-    
+
     int w = image.GetWidth();
     int h = image.GetHeight();
     int w = image.GetWidth();
     int h = image.GetHeight();
-    
+
     if (!Create(w, h, depth))
     if (!Create(w, h, depth))
-        return FALSE;
+        return false;
 
     // Unfortunately the mask has to be screen-depth since
     // 1-bpp bitmaps don't seem to be supported
 
     // Unfortunately the mask has to be screen-depth since
     // 1-bpp bitmaps don't seem to be supported
@@ -409,7 +489,7 @@ bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
     // pixmap. See demos/nxroach.c.
 
     bool hasMask = image.HasMask();
     // pixmap. See demos/nxroach.c.
 
     bool hasMask = image.HasMask();
-    
+
     GC pixmapGC = GrNewGC();
     Pixmap pixmap = (Pixmap) GetPixmap();
 
     GC pixmapGC = GrNewGC();
     Pixmap pixmap = (Pixmap) GetPixmap();
 
@@ -425,11 +505,11 @@ bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
         maskR = image.GetMaskRed();
         maskG = image.GetMaskGreen();
         maskB = image.GetMaskBlue();
         maskR = image.GetMaskRed();
         maskG = image.GetMaskGreen();
         maskB = image.GetMaskBlue();
-        
+
         maskGC = GrNewGC();
         maskPixmap = GrNewPixmap(w, h, 0);
         if (!maskPixmap)
         maskGC = GrNewGC();
         maskPixmap = GrNewPixmap(w, h, 0);
         if (!maskPixmap)
-            hasMask = FALSE;
+            hasMask = false;
         else
         {
             wxMask* mask = new wxMask;
         else
         {
             wxMask* mask = new wxMask;
@@ -440,7 +520,7 @@ bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
 
     GR_COLOR lastPixmapColour = 0;
     GR_COLOR lastMaskColour = 0;
 
     GR_COLOR lastPixmapColour = 0;
     GR_COLOR lastMaskColour = 0;
-    
+
     int i, j;
     for (i = 0; i < w; i++)
     {
     int i, j;
     for (i = 0; i < w; i++)
     {
@@ -458,9 +538,9 @@ bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
                 GrSetGCForeground(pixmapGC, colour);
                 lastPixmapColour = colour;
             }
                 GrSetGCForeground(pixmapGC, colour);
                 lastPixmapColour = colour;
             }
-            
+
             GrPoint(pixmap, pixmapGC, i, j);
             GrPoint(pixmap, pixmapGC, i, j);
-            
+
             if (hasMask)
             {
                 // scan the bitmap for the transparent colour and set the corresponding
             if (hasMask)
             {
                 // scan the bitmap for the transparent colour and set the corresponding
@@ -486,28 +566,28 @@ bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
     GrDestroyGC(pixmapGC);
     if (hasMask)
         GrDestroyGC(maskGC);
     GrDestroyGC(pixmapGC);
     if (hasMask)
         GrDestroyGC(maskGC);
-    
-    return TRUE;
+
+    return true;
 #else
     // !wxUSE_NANOX
 #else
     // !wxUSE_NANOX
-    
+
     UnRef();
 
     UnRef();
 
-    wxCHECK_MSG( image.Ok(), FALSE, wxT("invalid image") )
-    wxCHECK_MSG( depth == -1, FALSE, wxT("invalid bitmap depth") )
+    wxCHECK_MSG( image.IsOk(), false, wxT("invalid image") );
+    wxCHECK_MSG( depth == -1, false, wxT("invalid bitmap depth") );
 
     m_refData = new wxBitmapRefData();
 
     M_BMPDATA->m_display = wxGlobalDisplay();
 
     m_refData = new wxBitmapRefData();
 
     M_BMPDATA->m_display = wxGlobalDisplay();
-    
+
     Display *xdisplay = (Display*) M_BMPDATA->m_display;
     Display *xdisplay = (Display*) M_BMPDATA->m_display;
-    
+
     int xscreen = DefaultScreen( xdisplay );
     Window xroot = RootWindow( xdisplay, xscreen );
     Visual* xvisual = DefaultVisual( xdisplay, xscreen );
     int xscreen = DefaultScreen( xdisplay );
     Window xroot = RootWindow( xdisplay, xscreen );
     Visual* xvisual = DefaultVisual( xdisplay, xscreen );
-    
-    int bpp = wxTheApp->m_visualDepth;
-    
+
+    int bpp = wxTheApp->GetVisualInfo(M_BMPDATA->m_display)->m_visualDepth;
+
     int width = image.GetWidth();
     int height = image.GetHeight();
     M_BMPDATA->m_width = width;
     int width = image.GetWidth();
     int height = image.GetHeight();
     M_BMPDATA->m_width = width;
@@ -515,40 +595,41 @@ bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
 
     if (depth != 1) depth = bpp;
     M_BMPDATA->m_bpp = depth;
 
     if (depth != 1) depth = bpp;
     M_BMPDATA->m_bpp = depth;
-    
+
     if (depth == 1)
     {
     if (depth == 1)
     {
-        wxFAIL_MSG( "mono images later" );
+        wxFAIL_MSG( wxT("mono images later") );
     }
     else
     {
         // Create image
     }
     else
     {
         // Create image
-    
+
         XImage *data_image = XCreateImage( xdisplay, xvisual, bpp, ZPixmap, 0, 0, width, height, 32, 0 );
         data_image->data = (char*) malloc( data_image->bytes_per_line * data_image->height );
         XImage *data_image = XCreateImage( xdisplay, xvisual, bpp, ZPixmap, 0, 0, width, height, 32, 0 );
         data_image->data = (char*) malloc( data_image->bytes_per_line * data_image->height );
-    
+
         if (data_image->data == NULL)
         {
             wxLogError( wxT("Out of memory.") );  // TODO clean
         if (data_image->data == NULL)
         {
             wxLogError( wxT("Out of memory.") );  // TODO clean
-            return FALSE;
+            return false;
         }
 
         }
 
-        M_BMPDATA->m_pixmap = (WXPixmap) XCreatePixmap( xdisplay, xroot, width, height, depth );
+        M_BMPDATA->m_pixmap = XCreatePixmap( xdisplay, xroot, width, height, depth );
 
 
-        // Create mask
+        // Create mask if necessary
+        const bool hasMask = image.HasMask();
 
 
-        XImage *mask_image = (XImage*) NULL;
-        if (image.HasMask())
-        { 
+        XImage *mask_image = NULL;
+        if ( hasMask )
+        {
             mask_image = XCreateImage( xdisplay, xvisual, 1, ZPixmap, 0, 0, width, height, 32, 0 );
             mask_image->data = (char*) malloc( mask_image->bytes_per_line * mask_image->height );
             mask_image = XCreateImage( xdisplay, xvisual, 1, ZPixmap, 0, 0, width, height, 32, 0 );
             mask_image->data = (char*) malloc( mask_image->bytes_per_line * mask_image->height );
-        
+
             if (mask_image->data == NULL)
             {
                 wxLogError( wxT("Out of memory.") ); // TODO clean
             if (mask_image->data == NULL)
             {
                 wxLogError( wxT("Out of memory.") ); // TODO clean
-                return FALSE;
+                return false;
             }
             }
-            
+
             wxMask *mask = new wxMask();
             mask->SetDisplay( xdisplay );
             mask->SetBitmap( (WXPixmap) XCreatePixmap( xdisplay, xroot, width, height, 1 ) );
             wxMask *mask = new wxMask();
             mask->SetDisplay( xdisplay );
             mask->SetBitmap( (WXPixmap) XCreatePixmap( xdisplay, xroot, width, height, 1 ) );
@@ -563,14 +644,19 @@ bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
         enum byte_order { RGB, RBG, BRG, BGR, GRB, GBR };
         byte_order b_o = RGB;
 
         enum byte_order { RGB, RBG, BRG, BGR, GRB, GBR };
         byte_order b_o = RGB;
 
+        wxXVisualInfo* vi = wxTheApp->GetVisualInfo(M_BMPDATA->m_display);
+        unsigned long greenMask = vi->m_visualGreenMask,
+                      redMask   = vi->m_visualRedMask,
+                      blueMask  = vi->m_visualBlueMask;
+
         if (bpp > 8)
         {
         if (bpp > 8)
         {
-            if ((wxTheApp->m_visualRedMask > wxTheApp->m_visualGreenMask) && (wxTheApp->m_visualGreenMask > wxTheApp->m_visualBlueMask))      b_o = RGB;
-            else if ((wxTheApp->m_visualRedMask > wxTheApp->m_visualBlueMask) && (wxTheApp->m_visualBlueMask > wxTheApp->m_visualGreenMask))  b_o = RBG;
-            else if ((wxTheApp->m_visualBlueMask > wxTheApp->m_visualRedMask) && (wxTheApp->m_visualRedMask > wxTheApp->m_visualGreenMask))   b_o = BRG;
-            else if ((wxTheApp->m_visualBlueMask > wxTheApp->m_visualGreenMask) && (wxTheApp->m_visualGreenMask > wxTheApp->m_visualRedMask)) b_o = BGR;
-            else if ((wxTheApp->m_visualGreenMask > wxTheApp->m_visualRedMask) && (wxTheApp->m_visualRedMask > wxTheApp->m_visualBlueMask))   b_o = GRB;
-            else if ((wxTheApp->m_visualGreenMask > wxTheApp->m_visualBlueMask) && (wxTheApp->m_visualBlueMask > wxTheApp->m_visualRedMask))  b_o = GBR;
+            if ((redMask > greenMask) && (greenMask > blueMask))     b_o = RGB;
+            else if ((redMask > blueMask) && (blueMask > greenMask)) b_o = RBG;
+            else if ((blueMask > redMask) && (redMask > greenMask))  b_o = BRG;
+            else if ((blueMask > greenMask) && (greenMask > redMask))b_o = BGR;
+            else if ((greenMask > redMask) && (redMask > blueMask))  b_o = GRB;
+            else if ((greenMask > blueMask) && (blueMask > redMask)) b_o = GBR;
         }
 
         int r_mask = image.GetMaskRed();
         }
 
         int r_mask = image.GetMaskRed();
@@ -578,11 +664,10 @@ bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
         int b_mask = image.GetMaskBlue();
 
         unsigned char* data = image.GetData();
         int b_mask = image.GetMaskBlue();
 
         unsigned char* data = image.GetData();
-        wxASSERT_MSG( data, "No image data" );
-        
-        unsigned char *colorCube = wxTheApp->m_colorCube;
+        wxASSERT_MSG( data, wxT("No image data") );
 
 
-        bool hasMask = image.HasMask();
+        unsigned char *colorCube =
+            wxTheApp->GetVisualInfo(M_BMPDATA->m_display)->m_colorCube;
 
         int index = 0;
         for (int y = 0; y < height; y++)
 
         int index = 0;
         for (int y = 0; y < height; y++)
@@ -688,7 +773,7 @@ bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
         XFreeGC( xdisplay, gc );
 
         // Blit mask
         XFreeGC( xdisplay, gc );
 
         // Blit mask
-        
+
         if (image.HasMask())
         {
             GC gc = XCreateGC( xdisplay, (Pixmap) GetMask()->GetBitmap(), 0, NULL );
         if (image.HasMask())
         {
             GC gc = XCreateGC( xdisplay, (Pixmap) GetMask()->GetBitmap(), 0, NULL );
@@ -699,7 +784,7 @@ bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
         }
     }
 
         }
     }
 
-    return TRUE;
+    return true;
 #endif
     // wxUSE_NANOX
 }
 #endif
     // wxUSE_NANOX
 }
@@ -708,7 +793,7 @@ wxImage wxBitmap::ConvertToImage() const
 {
     wxImage image;
 
 {
     wxImage image;
 
-    wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
+    wxCHECK_MSG( IsOk(), wxNullImage, wxT("invalid bitmap") );
 
     Display *xdisplay = (Display*) M_BMPDATA->m_display;
     wxASSERT_MSG( xdisplay, wxT("No display") );
 
     Display *xdisplay = (Display*) M_BMPDATA->m_display;
     wxASSERT_MSG( xdisplay, wxT("No display") );
@@ -719,7 +804,7 @@ wxImage wxBitmap::ConvertToImage() const
     return image;
 #else
     // !wxUSE_NANOX
     return image;
 #else
     // !wxUSE_NANOX
-    int bpp = wxTheApp->m_visualDepth;
+    int bpp = wxTheApp->GetVisualInfo(M_BMPDATA->m_display)->m_visualDepth;
     XImage *x_image = NULL;
     if (GetPixmap())
     {
     XImage *x_image = NULL;
     if (GetPixmap())
     {
@@ -756,7 +841,7 @@ wxImage wxBitmap::ConvertToImage() const
     {
         x_image_mask = XGetImage( xdisplay, (Pixmap) GetMask()->GetBitmap(),
             0, 0,
     {
         x_image_mask = XGetImage( xdisplay, (Pixmap) GetMask()->GetBitmap(),
             0, 0,
-            GetWidth(), GetHeight(), 
+            GetWidth(), GetHeight(),
             AllPlanes, ZPixmap );
 
         image.SetMaskColour( 16, 16, 16 );  // anything unlikely and dividable
             AllPlanes, ZPixmap );
 
         image.SetMaskColour( 16, 16, 16 );  // anything unlikely and dividable
@@ -768,26 +853,30 @@ wxImage wxBitmap::ConvertToImage() const
     int red_shift_left = 0;
     int green_shift_left = 0;
     int blue_shift_left = 0;
     int red_shift_left = 0;
     int green_shift_left = 0;
     int blue_shift_left = 0;
-    bool use_shift = FALSE;
+    bool use_shift = false;
 
     if (GetPixmap())
     {
 
     if (GetPixmap())
     {
-        red_shift_right = wxTheApp->m_visualRedShift;
-        red_shift_left = 8-wxTheApp->m_visualRedPrec;
-        green_shift_right = wxTheApp->m_visualGreenShift;
-        green_shift_left = 8-wxTheApp->m_visualGreenPrec;
-        blue_shift_right = wxTheApp->m_visualBlueShift;
-        blue_shift_left = 8-wxTheApp->m_visualBluePrec;
-        
-        use_shift = (wxTheApp->m_visualType == GrayScale) || (wxTheApp->m_visualType != PseudoColor);
+        wxXVisualInfo* vi = wxTheApp->GetVisualInfo(M_BMPDATA->m_display);
+
+        red_shift_right = vi->m_visualRedShift;
+        red_shift_left = 8 - vi->m_visualRedPrec;
+        green_shift_right = vi->m_visualGreenShift;
+        green_shift_left = 8 - vi->m_visualGreenPrec;
+        blue_shift_right = vi->m_visualBlueShift;
+        blue_shift_left = 8 - vi->m_visualBluePrec;
+
+        use_shift = (vi->m_visualType == GrayScale) ||
+                    (vi->m_visualType != PseudoColor);
     }
     }
-    
+
     if (GetBitmap())
     {
         bpp = 1;
     }
 
     if (GetBitmap())
     {
         bpp = 1;
     }
 
-    XColor *colors = (XColor*) wxTheApp->m_visualColormap;
+    XColor *colors = (XColor*)wxTheApp->
+        GetVisualInfo(M_BMPDATA->m_display)->m_visualColormap;
 
     int width = GetWidth();
     int height = GetHeight();
 
     int width = GetWidth();
     int height = GetHeight();
@@ -814,15 +903,15 @@ wxImage wxBitmap::ConvertToImage() const
             }
             else if (use_shift)
             {
             }
             else if (use_shift)
             {
-                data[pos] =   (pixel >> red_shift_right)   << red_shift_left;
-                data[pos+1] = (pixel >> green_shift_right) << green_shift_left;
-                data[pos+2] = (pixel >> blue_shift_right)  << blue_shift_left;
+                data[pos] =   (unsigned char)((pixel >> red_shift_right)   << red_shift_left);
+                data[pos+1] = (unsigned char)((pixel >> green_shift_right) << green_shift_left);
+                data[pos+2] = (unsigned char)((pixel >> blue_shift_right)  << blue_shift_left);
             }
             else if (colors)
             {
             }
             else if (colors)
             {
-                data[pos] =   colors[pixel].red   >> 8;
-                data[pos+1] = colors[pixel].green >> 8;
-                data[pos+2] = colors[pixel].blue  >> 8;
+                data[pos] =   (unsigned char)(colors[pixel].red   >> 8);
+                data[pos+1] = (unsigned char)(colors[pixel].green >> 8);
+                data[pos+2] = (unsigned char)(colors[pixel].blue  >> 8);
             }
             else
             {
             }
             else
             {
@@ -851,11 +940,6 @@ wxImage wxBitmap::ConvertToImage() const
     // wxUSE_NANOX
 }
 
     // wxUSE_NANOX
 }
 
-wxBitmap::wxBitmap( const wxBitmap& bmp )
-{
-    Ref( bmp );
-}
-
 wxBitmap::wxBitmap( const wxString &filename, wxBitmapType type )
 {
     LoadFile( filename, type );
 wxBitmap::wxBitmap( const wxString &filename, wxBitmapType type )
 {
     LoadFile( filename, type );
@@ -865,68 +949,46 @@ wxBitmap::wxBitmap( const char bits[], int width, int height, int depth )
 {
     m_refData = new wxBitmapRefData;
 
 {
     m_refData = new wxBitmapRefData;
 
-    (void) Create((void*) bits, wxBITMAP_TYPE_XBM_DATA, width, height, depth);
+    (void) Create(bits, wxBITMAP_TYPE_XBM_DATA, width, height, depth);
 }
 
 wxBitmap::~wxBitmap()
 {
 }
 
 }
 
 wxBitmap::~wxBitmap()
 {
 }
 
-wxBitmap& wxBitmap::operator = ( const wxBitmap& bmp )
-{
-    if ( m_refData != bmp.m_refData )
-        Ref( bmp );
-
-    return *this;
-}
-
-bool wxBitmap::operator == ( const wxBitmap& bmp ) const
-{
-    return m_refData == bmp.m_refData;
-}
-
-bool wxBitmap::operator != ( const wxBitmap& bmp ) const
-{
-    return m_refData != bmp.m_refData;
-}
-
-bool wxBitmap::Ok() const
-{
-    return (m_refData != NULL);
-}
-
 int wxBitmap::GetHeight() const
 {
 int wxBitmap::GetHeight() const
 {
-    wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
+    wxCHECK_MSG( IsOk(), -1, wxT("invalid bitmap") );
 
     return M_BMPDATA->m_height;
 }
 
 int wxBitmap::GetWidth() const
 {
 
     return M_BMPDATA->m_height;
 }
 
 int wxBitmap::GetWidth() const
 {
-    wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
+    wxCHECK_MSG( IsOk(), -1, wxT("invalid bitmap") );
 
     return M_BMPDATA->m_width;
 }
 
 int wxBitmap::GetDepth() const
 {
 
     return M_BMPDATA->m_width;
 }
 
 int wxBitmap::GetDepth() const
 {
-    wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
+    wxCHECK_MSG( IsOk(), -1, wxT("invalid bitmap") );
 
     return M_BMPDATA->m_bpp;
 }
 
 wxMask *wxBitmap::GetMask() const
 {
 
     return M_BMPDATA->m_bpp;
 }
 
 wxMask *wxBitmap::GetMask() const
 {
-    wxCHECK_MSG( Ok(), (wxMask *) NULL, wxT("invalid bitmap") );
+    wxCHECK_MSG( IsOk(), NULL, wxT("invalid bitmap") );
 
     return M_BMPDATA->m_mask;
 }
 
 void wxBitmap::SetMask( wxMask *mask )
 {
 
     return M_BMPDATA->m_mask;
 }
 
 void wxBitmap::SetMask( wxMask *mask )
 {
-    wxCHECK_RET( Ok(), wxT("invalid bitmap") );
+    wxCHECK_RET( IsOk(), wxT("invalid bitmap") );
 
 
+    AllocExclusive();
     if (M_BMPDATA->m_mask) delete M_BMPDATA->m_mask;
 
     M_BMPDATA->m_mask = mask;
     if (M_BMPDATA->m_mask) delete M_BMPDATA->m_mask;
 
     M_BMPDATA->m_mask = mask;
@@ -935,19 +997,19 @@ void wxBitmap::SetMask( wxMask *mask )
 bool wxBitmap::CopyFromIcon(const wxIcon& icon)
 {
     *this = icon;
 bool wxBitmap::CopyFromIcon(const wxIcon& icon)
 {
     *this = icon;
-    return TRUE;
+    return true;
 }
 
 wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const
 {
 }
 
 wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const
 {
-    wxCHECK_MSG( Ok() &&
+    wxCHECK_MSG( IsOk() &&
                  (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, M_BMPDATA->m_bpp );
                  (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, M_BMPDATA->m_bpp );
-    wxASSERT_MSG( ret.Ok(), wxT("GetSubBitmap error") );
+    wxASSERT_MSG( ret.IsOk(), wxT("GetSubBitmap error") );
 
     if( GetMask() )
     {
 
     if( GetMask() )
     {
@@ -986,17 +1048,17 @@ wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const
 bool wxBitmap::SaveFile( const wxString &name, wxBitmapType type,
                          const wxPalette *palette ) const
 {
 bool wxBitmap::SaveFile( const wxString &name, wxBitmapType type,
                          const wxPalette *palette ) const
 {
-    wxCHECK_MSG( Ok(), FALSE, wxT("invalid bitmap") );
+    wxCHECK_MSG( IsOk(), false, wxT("invalid bitmap") );
 
     wxBitmapHandler *handler = FindHandler(type);
 
     // Try to save the bitmap via wxImage handlers:
     if (handler == NULL)
 
     wxBitmapHandler *handler = FindHandler(type);
 
     // Try to save the bitmap via wxImage handlers:
     if (handler == NULL)
-    { 
+    {
         wxImage image(this->ConvertToImage());
         wxImage image(this->ConvertToImage());
-        if (image.Ok()) return image.SaveFile( name, type );
+        if (image.IsOk()) return image.SaveFile( name, type );
 
 
-        return FALSE;
+        return false;
     }
 
     return handler->SaveFile(this, name, type, palette);
     }
 
     return handler->SaveFile(this, name, type, palette);
@@ -1006,7 +1068,7 @@ bool wxBitmap::LoadFile( const wxString &name, wxBitmapType type )
 {
     UnRef();
 
 {
     UnRef();
 
-    if (!wxFileExists(name)) return FALSE;
+    if (!wxFileExists(name)) return false;
 
     wxBitmapHandler *handler = FindHandler(type);
 
 
     wxBitmapHandler *handler = FindHandler(type);
 
@@ -1014,14 +1076,14 @@ bool wxBitmap::LoadFile( const wxString &name, wxBitmapType type )
     {
         wxImage image;
         if (!image.LoadFile( name, type ))
     {
         wxImage image;
         if (!image.LoadFile( name, type ))
-            return FALSE;
+            return false;
 
 
-        if (image.Ok()) 
+        if (image.IsOk())
         {
             *this = wxBitmap(image);
         {
             *this = wxBitmap(image);
-            return TRUE;
+            return true;
         }
         }
-        else return FALSE;
+        else return false;
     }
 
     return handler->LoadFile(this, name, type, -1, -1);
     }
 
     return handler->LoadFile(this, name, type, -1, -1);
@@ -1029,42 +1091,42 @@ bool wxBitmap::LoadFile( const wxString &name, wxBitmapType type )
 
 void wxBitmap::SetPalette(const wxPalette& palette)
 {
 
 void wxBitmap::SetPalette(const wxPalette& palette)
 {
-    wxCHECK_RET(Ok(), wxT("invalid bitmap"));
+    wxCHECK_RET(IsOk(), wxT("invalid bitmap"));
     wxCHECK_RET(GetDepth() > 1 && GetDepth() <= 8,
                 wxT("cannot set palette for bitmap of this depth"));
 
     wxCHECK_RET(GetDepth() > 1 && GetDepth() <= 8,
                 wxT("cannot set palette for bitmap of this depth"));
 
-    delete M_BMPDATA->m_palette;
-    M_BMPDATA->m_palette = NULL;
+    AllocExclusive();
+    wxDELETE(M_BMPDATA->m_palette);
+
+    if (!palette.IsOk()) return;
 
 
-    if (!palette.Ok()) return;
-   
     M_BMPDATA->m_palette = new wxPalette(palette);
 }
 
 wxPalette *wxBitmap::GetPalette() const
 {
     M_BMPDATA->m_palette = new wxPalette(palette);
 }
 
 wxPalette *wxBitmap::GetPalette() const
 {
-    if (!Ok()) return (wxPalette *) NULL;
+    if (!IsOk()) return NULL;
 
     return M_BMPDATA->m_palette;
 }
 
 void wxBitmap::SetHeight( int height )
 {
 
     return M_BMPDATA->m_palette;
 }
 
 void wxBitmap::SetHeight( int height )
 {
-    if (!m_refData) m_refData = new wxBitmapRefData();
+    AllocExclusive();
 
     M_BMPDATA->m_height = height;
 }
 
 void wxBitmap::SetWidth( int width )
 {
 
     M_BMPDATA->m_height = height;
 }
 
 void wxBitmap::SetWidth( int width )
 {
-    if (!m_refData) m_refData = new wxBitmapRefData();
+    AllocExclusive();
 
     M_BMPDATA->m_width = width;
 }
 
 void wxBitmap::SetDepth( int depth )
 {
 
     M_BMPDATA->m_width = width;
 }
 
 void wxBitmap::SetDepth( int depth )
 {
-    if (!m_refData) m_refData = new wxBitmapRefData();
+    AllocExclusive();
 
     M_BMPDATA->m_bpp = depth;
 }
 
     M_BMPDATA->m_bpp = depth;
 }
@@ -1073,33 +1135,41 @@ void wxBitmap::SetPixmap( WXPixmap pixmap )
 {
     if (!m_refData) m_refData = new wxBitmapRefData();
 
 {
     if (!m_refData) m_refData = new wxBitmapRefData();
 
-    M_BMPDATA->m_pixmap = pixmap;
+    M_BMPDATA->m_pixmap = (Pixmap)pixmap;
 }
 
 void wxBitmap::SetBitmap( WXPixmap bitmap )
 {
     if (!m_refData) m_refData = new wxBitmapRefData();
 
 }
 
 void wxBitmap::SetBitmap( WXPixmap bitmap )
 {
     if (!m_refData) m_refData = new wxBitmapRefData();
 
-    M_BMPDATA->m_bitmap = bitmap;
+    M_BMPDATA->m_bitmap = (Pixmap)bitmap;
 }
 
 WXPixmap wxBitmap::GetPixmap() const
 {
 }
 
 WXPixmap wxBitmap::GetPixmap() const
 {
-    wxCHECK_MSG( Ok(), (WXPixmap) NULL, wxT("invalid bitmap") );
+    wxCHECK_MSG( IsOk(), (WXPixmap) NULL, wxT("invalid bitmap") );
 
 
-    return M_BMPDATA->m_pixmap;
+    return (WXPixmap)M_BMPDATA->m_pixmap;
 }
 
 WXPixmap wxBitmap::GetBitmap() const
 {
 }
 
 WXPixmap wxBitmap::GetBitmap() const
 {
-    wxCHECK_MSG( Ok(), (WXPixmap) NULL, wxT("invalid bitmap") );
+    wxCHECK_MSG( IsOk(), (WXPixmap) NULL, wxT("invalid bitmap") );
+
+    return (WXPixmap)M_BMPDATA->m_bitmap;
+}
+
+WXPixmap wxBitmap::GetDrawable() const
+{
+    wxCHECK_MSG( IsOk(), (WXPixmap) NULL, wxT("invalid bitmap") );
 
 
-    return M_BMPDATA->m_bitmap;
+    return (WXPixmap)(M_BMPDATA->m_bpp == 1 ? M_BMPDATA->m_bitmap
+                                            : M_BMPDATA->m_pixmap);
 }
 
 WXDisplay *wxBitmap::GetDisplay() const
 {
 }
 
 WXDisplay *wxBitmap::GetDisplay() const
 {
-    wxCHECK_MSG( Ok(), (WXDisplay*) NULL, wxT("invalid bitmap") );
+    wxCHECK_MSG( IsOk(), NULL, wxT("invalid bitmap") );
 
     return M_BMPDATA->m_display;
 }
 
     return M_BMPDATA->m_display;
 }
@@ -1117,118 +1187,118 @@ bool wxGetImageFromDrawable(GR_DRAW_ID drawable, int srcX, int srcY, int width,
     GrGetScreenInfo(&sinfo);
 
     if (sinfo.pixtype == MWPF_PALETTE) {
     GrGetScreenInfo(&sinfo);
 
     if (sinfo.pixtype == MWPF_PALETTE) {
-               if(!(palette = (GR_PALETTE*) malloc(sizeof(GR_PALETTE)))) {
-                       return FALSE;
-               }
-               GrGetSystemPalette(palette);
-       }
+        if(!(palette = (GR_PALETTE*) malloc(sizeof(GR_PALETTE)))) {
+            return false;
+        }
+        GrGetSystemPalette(palette);
+    }
 
     if(!(pixels = (GR_PIXELVAL*) malloc(sizeof(GR_PIXELVAL) * width * height)))
     {
 
     if(!(pixels = (GR_PIXELVAL*) malloc(sizeof(GR_PIXELVAL) * width * height)))
     {
-        return FALSE;
+        return false;
     }
 
     image.Create(width, height);
 
     }
 
     image.Create(width, height);
 
-       GrReadArea(drawable, srcX, srcY, width, height,
-                                               pixels);
-
-
-               for(x = 0; x < sinfo.cols; x++) {
-
-                       pp = (unsigned char *)pixels +
-                               ((x + (y * sinfo.cols)) *
-                               sizeof(GR_PIXELVAL));
-
-                       switch(sinfo.pixtype) {
-                       /* FIXME: These may need modifying on big endian. */
-                               case MWPF_TRUECOLOR0888:
-                               case MWPF_TRUECOLOR888:
-                                       rgb[0] = pp[2];
-                                       rgb[1] = pp[1];
-                                       rgb[2] = pp[0];
-                                       break;
-                               case MWPF_PALETTE:
-                                       rgb[0] = palette->palette[pp[0]].r;
-                                       rgb[1] = palette->palette[pp[0]].g;
-                                       rgb[2] = palette->palette[pp[0]].b;
-                                       break;
-                               case MWPF_TRUECOLOR565:
-                                       rgb[0] = pp[1] & 0xf8;
-                                       rgb[1] = ((pp[1] & 0x07) << 5) |
-                                               ((pp[0] & 0xe0) >> 3);
-                                       rgb[2] = (pp[0] & 0x1f) << 3;
-                                       break;
-                               case MWPF_TRUECOLOR555:
-                                       rgb[0] = (pp[1] & 0x7c) << 1;
-                                       rgb[1] = ((pp[1] & 0x03) << 6) |
-                                               ((pp[0] & 0xe0) >> 2);
-                                       rgb[2] = (pp[0] & 0x1f) << 3;
-                                       break;
-                               case MWPF_TRUECOLOR332:
-                                       rgb[0] = pp[0] & 0xe0;
-                                       rgb[1] = (pp[0] & 0x1c) << 3;
-                                       rgb[2] = (pp[0] & 0x03) << 6;
-                                       break;
-                               default:
-                                       fprintf(stderr, "Unsupported pixel "
-                                                       "format\n");
-                                       return 1;
-                       }
-
-            image.SetRGB(x, y, rgb[0], rgb[1], rgb[2]);
-
-       }
+    GrReadArea(drawable, srcX, srcY, width, height,
+            pixels);
+
+
+    for(x = 0; x < sinfo.cols; x++) {
+
+        pp = (unsigned char *)pixels +
+            ((x + (y * sinfo.cols)) *
+             sizeof(GR_PIXELVAL));
+
+        switch(sinfo.pixtype) {
+            /* FIXME: These may need modifying on big endian. */
+            case MWPF_TRUECOLOR0888:
+            case MWPF_TRUECOLOR888:
+                rgb[0] = pp[2];
+                rgb[1] = pp[1];
+                rgb[2] = pp[0];
+                break;
+            case MWPF_PALETTE:
+                rgb[0] = palette->palette[pp[0]].r;
+                rgb[1] = palette->palette[pp[0]].g;
+                rgb[2] = palette->palette[pp[0]].b;
+                break;
+            case MWPF_TRUECOLOR565:
+                rgb[0] = pp[1] & 0xf8;
+                rgb[1] = ((pp[1] & 0x07) << 5) |
+                    ((pp[0] & 0xe0) >> 3);
+                rgb[2] = (pp[0] & 0x1f) << 3;
+                break;
+            case MWPF_TRUECOLOR555:
+                rgb[0] = (pp[1] & 0x7c) << 1;
+                rgb[1] = ((pp[1] & 0x03) << 6) |
+                    ((pp[0] & 0xe0) >> 2);
+                rgb[2] = (pp[0] & 0x1f) << 3;
+                break;
+            case MWPF_TRUECOLOR332:
+                rgb[0] = pp[0] & 0xe0;
+                rgb[1] = (pp[0] & 0x1c) << 3;
+                rgb[2] = (pp[0] & 0x03) << 6;
+                break;
+            default:
+                fprintf(stderr, "Unsupported pixel "
+                        "format\n");
+                return 1;
+        }
+
+        image.SetRGB(x, y, rgb[0], rgb[1], rgb[2]);
+
+    }
 
     free(pixels);
     if(palette) free(palette);
 
 
     free(pixels);
     if(palette) free(palette);
 
-    return TRUE;
+    return true;
 }
 
 #if 0
 int GrGetPixelColor(GR_SCREEN_INFO* sinfo, GR_PALETTE* palette, GR_PIXELVAL pixel,
     unsigned char* red, unsigned char* green, unsigned char* blue)
 {
 }
 
 #if 0
 int GrGetPixelColor(GR_SCREEN_INFO* sinfo, GR_PALETTE* palette, GR_PIXELVAL pixel,
     unsigned char* red, unsigned char* green, unsigned char* blue)
 {
-       unsigned char rgb[3], *pp;
+    unsigned char rgb[3], *pp;
 
     pp = (unsigned char*) & pixel ;
 
     switch (sinfo.pixtype)
     {
 
     pp = (unsigned char*) & pixel ;
 
     switch (sinfo.pixtype)
     {
-                       /* FIXME: These may need modifying on big endian. */
-                               case MWPF_TRUECOLOR0888:
-                               case MWPF_TRUECOLOR888:
-                                       rgb[0] = pp[2];
-                                       rgb[1] = pp[1];
-                                       rgb[2] = pp[0];
-                                       break;
-                               case MWPF_PALETTE:
-                                       rgb[0] = palette->palette[pp[0]].r;
-                                       rgb[1] = palette->palette[pp[0]].g;
-                                       rgb[2] = palette->palette[pp[0]].b;
-                                       break;
-                               case MWPF_TRUECOLOR565:
-                                       rgb[0] = pp[1] & 0xf8;
-                                       rgb[1] = ((pp[1] & 0x07) << 5) |
-                                               ((pp[0] & 0xe0) >> 3);
-                                       rgb[2] = (pp[0] & 0x1f) << 3;
-                                       break;
-                               case MWPF_TRUECOLOR555:
-                                       rgb[0] = (pp[1] & 0x7c) << 1;
-                                       rgb[1] = ((pp[1] & 0x03) << 6) |
-                                               ((pp[0] & 0xe0) >> 2);
-                                       rgb[2] = (pp[0] & 0x1f) << 3;
-                                       break;
-                               case MWPF_TRUECOLOR332:
-                                       rgb[0] = pp[0] & 0xe0;
-                                       rgb[1] = (pp[0] & 0x1c) << 3;
-                                       rgb[2] = (pp[0] & 0x03) << 6;
-                                       break;
-                               default:
-                                       fprintf(stderr, "Unsupported pixel format\n");
-                                       return 0;
-       }
+        /* FIXME: These may need modifying on big endian. */
+        case MWPF_TRUECOLOR0888:
+        case MWPF_TRUECOLOR888:
+            rgb[0] = pp[2];
+            rgb[1] = pp[1];
+            rgb[2] = pp[0];
+            break;
+        case MWPF_PALETTE:
+            rgb[0] = palette->palette[pp[0]].r;
+            rgb[1] = palette->palette[pp[0]].g;
+            rgb[2] = palette->palette[pp[0]].b;
+            break;
+        case MWPF_TRUECOLOR565:
+            rgb[0] = pp[1] & 0xf8;
+            rgb[1] = ((pp[1] & 0x07) << 5) |
+                ((pp[0] & 0xe0) >> 3);
+            rgb[2] = (pp[0] & 0x1f) << 3;
+            break;
+        case MWPF_TRUECOLOR555:
+            rgb[0] = (pp[1] & 0x7c) << 1;
+            rgb[1] = ((pp[1] & 0x03) << 6) |
+                ((pp[0] & 0xe0) >> 2);
+            rgb[2] = (pp[0] & 0x1f) << 3;
+            break;
+        case MWPF_TRUECOLOR332:
+            rgb[0] = pp[0] & 0xe0;
+            rgb[1] = (pp[0] & 0x1c) << 3;
+            rgb[2] = (pp[0] & 0x03) << 6;
+            break;
+        default:
+            fprintf(stderr, "Unsupported pixel format\n");
+            return 0;
+    }
 
 
     *(red) = rgb[0];
 
 
     *(red) = rgb[0];
@@ -1245,8 +1315,6 @@ int GrGetPixelColor(GR_SCREEN_INFO* sinfo, GR_PALETTE* palette, GR_PIXELVAL pixe
 // Bitmap handlers
 // ============================================================================
 
 // Bitmap handlers
 // ============================================================================
 
-IMPLEMENT_ABSTRACT_CLASS(wxBitmapHandler, wxBitmapHandlerBase);
-
 #define M_BMPHANDLERDATA ((wxBitmapRefData *)bitmap->GetRefData())
 
 #if wxUSE_XPM
 #define M_BMPHANDLERDATA ((wxBitmapRefData *)bitmap->GetRefData())
 
 #if wxUSE_XPM
@@ -1259,43 +1327,52 @@ IMPLEMENT_ABSTRACT_CLASS(wxBitmapHandler, wxBitmapHandlerBase);
 
 class wxXPMFileHandler : public wxBitmapHandler
 {
 
 class wxXPMFileHandler : public wxBitmapHandler
 {
-    DECLARE_DYNAMIC_CLASS(wxXPMFileHandler);
 public:
     wxXPMFileHandler()
     {
 public:
     wxXPMFileHandler()
     {
-        m_name = "XPM file";
-        m_extension = "xpm";
-        m_type = wxBITMAP_TYPE_XPM;
+        SetName( wxT("XPM file") );
+        SetExtension( wxT("xpm") );
+        SetType( wxBITMAP_TYPE_XPM );
     };
 
     };
 
-    virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
+    virtual bool LoadFile(wxBitmap *bitmap, const wxString& name,
+                          wxBitmapType flags,
                           int desiredWidth, int desiredHeight);
 
     virtual bool SaveFile(const wxBitmap *bitmap, const wxString& name,
                           int desiredWidth, int desiredHeight);
 
     virtual bool SaveFile(const wxBitmap *bitmap, const wxString& name,
-                          int type, const wxPalette *palette = NULL);
-
-    virtual bool Create(wxBitmap *bitmap, void *data, long flags,
-                        int width, int height, int depth = 1)
-        { return FALSE; }
+                          wxBitmapType type,
+                          const wxPalette *palette = NULL) const;
+
+    virtual bool Create(wxBitmap *WXUNUSED(bitmap),
+                        const void* WXUNUSED(data),
+                        wxBitmapType WXUNUSED(flags),
+                        int WXUNUSED(width),
+                        int WXUNUSED(height),
+                        int WXUNUSED(depth) = 1)
+        { return false; }
+
+    DECLARE_DYNAMIC_CLASS(wxXPMFileHandler)
 };
 
 };
 
-IMPLEMENT_DYNAMIC_CLASS(wxXPMFileHandler, wxBitmapHandler);
+IMPLEMENT_DYNAMIC_CLASS(wxXPMFileHandler, wxBitmapHandler)
 
 
-bool wxXPMFileHandler::LoadFile(wxBitmap *bitmap, const wxString& name,
-                                long flags, int desiredWidth,
-                                int desiredHeight)
+bool wxXPMFileHandler::LoadFile(wxBitmap *bitmap,
+                                const wxString& name,
+                                wxBitmapType WXUNUSED(flags),
+                                int WXUNUSED(desiredWidth),
+                                int WXUNUSED(desiredHeight))
 {
 #if wxHAVE_LIB_XPM
     if (!bitmap->GetRefData())
         bitmap->SetRefData( new wxBitmapRefData() );
 
     M_BMPHANDLERDATA->m_display = wxGlobalDisplay();
 {
 #if wxHAVE_LIB_XPM
     if (!bitmap->GetRefData())
         bitmap->SetRefData( new wxBitmapRefData() );
 
     M_BMPHANDLERDATA->m_display = wxGlobalDisplay();
-    
+
     Display *xdisplay = (Display*) M_BMPHANDLERDATA->m_display;
     Display *xdisplay = (Display*) M_BMPHANDLERDATA->m_display;
-    
+
     int xscreen = DefaultScreen( xdisplay );
     Window xroot = RootWindow( xdisplay, xscreen );
     int xscreen = DefaultScreen( xdisplay );
     Window xroot = RootWindow( xdisplay, xscreen );
-    
+
     int bpp = DefaultDepth( xdisplay, xscreen );
 
     XpmAttributes xpmAttr;
     int bpp = DefaultDepth( xdisplay, xscreen );
 
     XpmAttributes xpmAttr;
@@ -1303,11 +1380,11 @@ bool wxXPMFileHandler::LoadFile(wxBitmap *bitmap, const wxString& name,
 
     Pixmap pixmap;
     Pixmap mask = 0;
 
     Pixmap pixmap;
     Pixmap mask = 0;
-    
+
     int ErrorStatus = XpmReadFileToPixmap( xdisplay, xroot,
     int ErrorStatus = XpmReadFileToPixmap( xdisplay, xroot,
-                                           (char*) name.c_str(),
+                                           (char*) ((const char*) name.c_str()),
                                            &pixmap, &mask, &xpmAttr);
                                            &pixmap, &mask, &xpmAttr);
-    
+
     if (ErrorStatus == XpmSuccess)
     {
         M_BMPHANDLERDATA->m_width = xpmAttr.width;
     if (ErrorStatus == XpmSuccess)
     {
         M_BMPHANDLERDATA->m_width = xpmAttr.width;
@@ -1317,8 +1394,8 @@ bool wxXPMFileHandler::LoadFile(wxBitmap *bitmap, const wxString& name,
 
         XpmFreeAttributes(&xpmAttr);
 
 
         XpmFreeAttributes(&xpmAttr);
 
-        M_BMPHANDLERDATA->m_bitmap = (WXPixmap) pixmap;
-        
+        M_BMPHANDLERDATA->m_bitmap = (Pixmap) pixmap;
+
         if (mask)
         {
             M_BMPHANDLERDATA->m_mask = new wxMask;
         if (mask)
         {
             M_BMPHANDLERDATA->m_mask = new wxMask;
@@ -1329,35 +1406,36 @@ bool wxXPMFileHandler::LoadFile(wxBitmap *bitmap, const wxString& name,
     else
     {
         UnRef();
     else
     {
         UnRef();
-    
-        return FALSE;
+
+        return false;
     }
 
     }
 
-    return TRUE;
+    return true;
 #elif wxUSE_STREAMS
     wxXPMDecoder decoder;
     wxFileInputStream stream(name);
 #elif wxUSE_STREAMS
     wxXPMDecoder decoder;
     wxFileInputStream stream(name);
-    if (stream.Ok())
+    if (stream.IsOk())
     {
         wxImage image(decoder.ReadFile(stream));
     {
         wxImage image(decoder.ReadFile(stream));
-        if (image.Ok())
-            return CreateFromImage(image);
-        else
-            return FALSE;
+        return image.IsOk() && bitmap->CreateFromImage(image);
     }
     }
-    else
-        return FALSE;
+
+    return false;
+#else // !wxHAVE_LIB_XPM && !wxUSE_STREAMS
+    return false;
 #endif // wxHAVE_LIB_XPM / wxUSE_STREAMS
 }
 
 #endif // wxHAVE_LIB_XPM / wxUSE_STREAMS
 }
 
-bool wxXPMFileHandler::SaveFile(const wxBitmap *bitmap, const wxString& name,
-                                int type,
-                                const wxPalette *WXUNUSED(palette))
+bool wxXPMFileHandler::SaveFile(const wxBitmap *bitmap,
+                                const wxString& name,
+                                wxBitmapType type,
+                                const wxPalette *WXUNUSED(palette)) const
 {
     wxImage image(bitmap->ConvertToImage());
 {
     wxImage image(bitmap->ConvertToImage());
-    if (image.Ok()) return image.SaveFile( name, (wxBitmapType)type );
+    if (image.IsOk())
+        return image.SaveFile( name, type );
 
 
-    return FALSE;
+    return false;
 }
 
 #endif // wxHAVE_LIB_XPM || wxUSE_STREAMS
 }
 
 #endif // wxHAVE_LIB_XPM || wxUSE_STREAMS
@@ -1368,46 +1446,51 @@ bool wxXPMFileHandler::SaveFile(const wxBitmap *bitmap, const wxString& name,
 
 class wxXPMDataHandler : public wxBitmapHandler
 {
 
 class wxXPMDataHandler : public wxBitmapHandler
 {
-    DECLARE_DYNAMIC_CLASS(wxXPMDataHandler);
+    DECLARE_DYNAMIC_CLASS(wxXPMDataHandler)
 public:
     wxXPMDataHandler()
     {
 public:
     wxXPMDataHandler()
     {
-        m_name = "XPM data";
-        m_extension = "xpm";
-        m_type = wxBITMAP_TYPE_XPM_DATA;
+        SetName( wxT("XPM data") );
+        SetExtension( wxT("xpm") );
+        SetType( wxBITMAP_TYPE_XPM_DATA );
     };
 
     };
 
-    virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
-                          int desiredWidth, int desiredHeight)
-        { return FALSE; }
+    virtual bool LoadFile(wxBitmap *WXUNUSED(bitmap),
+                          const wxString& WXUNUSED(name),
+                          wxBitmapType WXUNUSED(flags),
+                          int WXUNUSED(desiredWidth),
+                          int WXUNUSED(desiredHeight))
+        { return false; }
 
 
-    virtual bool SaveFile(const wxBitmap *bitmap, const wxString& name,
-                          int type, const wxPalette *palette = NULL)
-        { return FALSE; }
+    virtual bool SaveFile(const wxBitmap *WXUNUSED(bitmap),
+                          const wxString& WXUNUSED(name),
+                          wxBitmapType WXUNUSED(type),
+                          const wxPalette *WXUNUSED(palette) = NULL) const
+        { return false; }
 
 
-    virtual bool Create(wxBitmap *bitmap, void *data, long flags,
+    virtual bool Create(wxBitmap *bitmap, const void* data, wxBitmapType flags,
                         int width, int height, int depth = 1);
 };
 
                         int width, int height, int depth = 1);
 };
 
-IMPLEMENT_DYNAMIC_CLASS(wxXPMDataHandler, wxBitmapHandler);
+IMPLEMENT_DYNAMIC_CLASS(wxXPMDataHandler, wxBitmapHandler)
 
 
-bool wxXPMDataHandler::Create(wxBitmap *bitmap, void *bits,
-                              long WXUNUSED(flags),
-                              int width, int height, int WXUNUSED(depth))
+bool wxXPMDataHandler::Create(wxBitmap *bitmap, const void* bits,
+                              wxBitmapType WXUNUSED(flags),
+                              int WXUNUSED(width), int WXUNUSED(height), int WXUNUSED(depth))
 {
 #if wxHAVE_LIB_XPM
 {
 #if wxHAVE_LIB_XPM
-    wxCHECK_MSG( bits != NULL, FALSE, wxT("invalid bitmap data") )
+    wxCHECK_MSG( bits != NULL, false, wxT("invalid bitmap data") );
 
     if (!bitmap->GetRefData())
         bitmap->SetRefData( new wxBitmapRefData() );
 
     M_BMPHANDLERDATA->m_display = wxGlobalDisplay();
 
     if (!bitmap->GetRefData())
         bitmap->SetRefData( new wxBitmapRefData() );
 
     M_BMPHANDLERDATA->m_display = wxGlobalDisplay();
-    
+
     Display *xdisplay = (Display*) M_BMPHANDLERDATA->m_display;
     Display *xdisplay = (Display*) M_BMPHANDLERDATA->m_display;
-    
+
     int xscreen = DefaultScreen( xdisplay );
     Window xroot = RootWindow( xdisplay, xscreen );
     int xscreen = DefaultScreen( xdisplay );
     Window xroot = RootWindow( xdisplay, xscreen );
-    
+
     int bpp = DefaultDepth( xdisplay, xscreen );
 
     XpmAttributes xpmAttr;
     int bpp = DefaultDepth( xdisplay, xscreen );
 
     XpmAttributes xpmAttr;
@@ -1415,10 +1498,10 @@ bool wxXPMDataHandler::Create(wxBitmap *bitmap, void *bits,
 
     Pixmap pixmap = 0;
     Pixmap mask = 0;
 
     Pixmap pixmap = 0;
     Pixmap mask = 0;
-    
+
     int ErrorStatus = XpmCreatePixmapFromData( xdisplay, xroot, (char**) bits,
                                                &pixmap, &mask, &xpmAttr );
     int ErrorStatus = XpmCreatePixmapFromData( xdisplay, xroot, (char**) bits,
                                                &pixmap, &mask, &xpmAttr );
-    
+
     if (ErrorStatus == XpmSuccess)
     {
         M_BMPHANDLERDATA->m_width = xpmAttr.width;
     if (ErrorStatus == XpmSuccess)
     {
         M_BMPHANDLERDATA->m_width = xpmAttr.width;
@@ -1426,7 +1509,7 @@ bool wxXPMDataHandler::Create(wxBitmap *bitmap, void *bits,
 
         M_BMPHANDLERDATA->m_bpp = bpp;  // mono as well?
 
 
         M_BMPHANDLERDATA->m_bpp = bpp;  // mono as well?
 
-#if __WXDEBUG__
+#if wxDEBUG_LEVEL
         unsigned int depthRet;
         int xRet, yRet;
         unsigned int widthRet, heightRet, borderWidthRet;
         unsigned int depthRet;
         int xRet, yRet;
         unsigned int widthRet, heightRet, borderWidthRet;
@@ -1434,34 +1517,31 @@ bool wxXPMDataHandler::Create(wxBitmap *bitmap, void *bits,
             &widthRet, &heightRet, &borderWidthRet, &depthRet);
 
         wxASSERT_MSG( bpp == (int)depthRet, wxT("colour depth mismatch") );
             &widthRet, &heightRet, &borderWidthRet, &depthRet);
 
         wxASSERT_MSG( bpp == (int)depthRet, wxT("colour depth mismatch") );
-#endif
+#endif // wxDEBUG_LEVEL
 
         XpmFreeAttributes(&xpmAttr);
 
         XpmFreeAttributes(&xpmAttr);
-        
-        M_BMPHANDLERDATA->m_pixmap = (WXPixmap) pixmap;
-        
+
+        M_BMPHANDLERDATA->m_pixmap = (Pixmap) pixmap;
+
         if (mask)
         {
             M_BMPHANDLERDATA->m_mask = new wxMask;
             M_BMPHANDLERDATA->m_mask->SetBitmap( (WXPixmap) mask );
             M_BMPHANDLERDATA->m_mask->SetDisplay( xdisplay );
         }
         if (mask)
         {
             M_BMPHANDLERDATA->m_mask = new wxMask;
             M_BMPHANDLERDATA->m_mask->SetBitmap( (WXPixmap) mask );
             M_BMPHANDLERDATA->m_mask->SetDisplay( xdisplay );
         }
-       return TRUE;
+        return true;
     }
     else
     {
         bitmap->UnRef();
     }
     else
     {
         bitmap->UnRef();
-        
-        return FALSE;
+
+        return false;
     }
     }
-#else
+#else // !wxHAVE_LIB_XPM
     wxXPMDecoder decoder;
     wxXPMDecoder decoder;
-    wxImage image(decoder.ReadData(bits));
-    if (image.Ok())
-       return bitmap->CreateFromImage(image);
-    else
-       return FALSE;
-#endif
+    wxImage image(decoder.ReadData((const char **)bits));
+    return image.IsOk() && bitmap->CreateFromImage(image);
+#endif // wxHAVE_LIB_XPM/!wxHAVE_LIB_XPM
 }
 
 #endif // wxUSE_XPM
 }
 
 #endif // wxUSE_XPM
@@ -1476,28 +1556,33 @@ class WXDLLEXPORT wxXBMDataHandler: public wxBitmapHandler
 public:
     inline wxXBMDataHandler()
     {
 public:
     inline wxXBMDataHandler()
     {
-        m_name = "XBM data";
-        m_extension = "xbm";
-        m_type = wxBITMAP_TYPE_XBM_DATA;
+        SetName( wxT("XBM data") );
+        SetExtension( wxT("xbm") );
+        SetType( wxBITMAP_TYPE_XBM_DATA );
     };
 
     };
 
-    virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
-                          int desiredWidth, int desiredHeight)
-        { return FALSE; }
+    virtual bool LoadFile(wxBitmap *WXUNUSED(bitmap),
+                          const wxString& WXUNUSED(name),
+                          wxBitmapType WXUNUSED(flags),
+                          int WXUNUSED(desiredWidth),
+                          int WXUNUSED(desiredHeight))
+        { return false; }
 
 
-    virtual bool SaveFile(const wxBitmap *bitmap, const wxString& name,
-                          int type, const wxPalette *palette = NULL)
-        { return FALSE; }
+    virtual bool SaveFile(const wxBitmap *WXUNUSED(bitmap),
+                          const wxString& WXUNUSED(name),
+                          wxBitmapType WXUNUSED(type),
+                          const wxPalette *WXUNUSED(palette) = NULL) const
+        { return false; }
 
 
-    virtual bool Create(wxBitmap *bitmap, void *data, long flags,
+    virtual bool Create(wxBitmap *bitmap, const void* data, wxBitmapType type,
                         int width, int height, int depth = 1);
 };
 
                         int width, int height, int depth = 1);
 };
 
-IMPLEMENT_DYNAMIC_CLASS(wxXBMDataHandler, wxBitmapHandler);
+IMPLEMENT_DYNAMIC_CLASS(wxXBMDataHandler, wxBitmapHandler)
 
 
-bool wxXBMDataHandler::Create( wxBitmap *bitmap, void *bits,
-                               long WXUNUSED(flags),
-                               int width, int height, int depth)
+bool wxXBMDataHandler::Create( wxBitmap *bitmap, const void* bits,
+                               wxBitmapType WXUNUSED(type),
+                               int width, int height, int WXUNUSED(depth))
 {
 #if !wxUSE_NANOX
     if (!bitmap->GetRefData())
 {
 #if !wxUSE_NANOX
     if (!bitmap->GetRefData())
@@ -1506,22 +1591,23 @@ bool wxXBMDataHandler::Create( wxBitmap *bitmap, void *bits,
     M_BMPHANDLERDATA->m_display = wxGlobalDisplay();
 
     Display *xdisplay = (Display*) M_BMPHANDLERDATA->m_display;
     M_BMPHANDLERDATA->m_display = wxGlobalDisplay();
 
     Display *xdisplay = (Display*) M_BMPHANDLERDATA->m_display;
-    
+
     int xscreen = DefaultScreen( xdisplay );
     Window xroot = RootWindow( xdisplay, xscreen );
     int xscreen = DefaultScreen( xdisplay );
     Window xroot = RootWindow( xdisplay, xscreen );
-    
-    M_BMPHANDLERDATA->m_mask = (wxMask *) NULL;
+
+    M_BMPHANDLERDATA->m_mask = NULL;
     M_BMPHANDLERDATA->m_bitmap =
     M_BMPHANDLERDATA->m_bitmap =
-        (WXPixmap) XCreateBitmapFromData( xdisplay, xroot,
-                                          (char *) bits, width, height );
+        XCreateBitmapFromData(xdisplay, xroot,
+                              (char *) bits, width, height );
     M_BMPHANDLERDATA->m_width = width;
     M_BMPHANDLERDATA->m_height = height;
     M_BMPHANDLERDATA->m_bpp = 1;
 
     M_BMPHANDLERDATA->m_width = width;
     M_BMPHANDLERDATA->m_height = height;
     M_BMPHANDLERDATA->m_bpp = 1;
 
-    return TRUE;
-#endif
-    wxCHECK_MSG( M_BMPHANDLERDATA->m_bitmap, FALSE,
+    return true;
+#else
+   wxCHECK_MSG( M_BMPHANDLERDATA->m_bitmap, false,
                  wxT("couldn't create bitmap") );
                  wxT("couldn't create bitmap") );
+#endif
 }
 
 void wxBitmap::InitStandardHandlers()
 }
 
 void wxBitmap::InitStandardHandlers()
wxWidgets (Impactor)