X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/4c620d190086830fcfce44cebadc4cbce2b6363d..e6514d0ea0ea262dd6a2f59e86c416b68e0fb742:/src/x11/bitmap.cpp

diff --git a/src/x11/bitmap.cpp b/src/x11/bitmap.cpp
index 6a58cb709c..ba6ebacd0e 100644
--- 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:
@@ -9,17 +9,18 @@
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-#pragma implementation "bitmap.h"
-#endif
+// for compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.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"
@@ -41,7 +42,6 @@ bool wxGetImageFromDrawable(GR_DRAW_ID drawable, int srcX, int srcY, int width,
 #include "wx/wfstream.h"
 #endif
 #endif
-#include "wx/math.h"
 
 //-----------------------------------------------------------------------------
 // wxMask
@@ -92,7 +92,7 @@ bool wxMask::Create( const wxBitmap& bitmap,
     m_display = bitmap.GetDisplay();
 
     wxImage image = bitmap.ConvertToImage();
-    if (!image.Ok()) return FALSE;
+    if (!image.Ok()) return false;
 
     m_display = bitmap.GetDisplay();
 
@@ -118,21 +118,21 @@ bool wxMask::Create( const wxBitmap& bitmap,
 
     if (bpp == 15)
     {
-        red = red & 0xf8;
-        green = green & 0xf8;
-        blue = blue & 0xf8;
+        red &= 0xf8;
+        green &= 0xf8;
+        blue &= 0xf8;
     } else
     if (bpp == 16)
     {
-        red = red & 0xf8;
-        green = green & 0xfc;
-        blue = blue & 0xf8;
+        red &= 0xf8;
+        green &= 0xfc;
+        blue &= 0xf8;
     } 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) );
@@ -168,9 +168,9 @@ bool wxMask::Create( const wxBitmap& bitmap,
 
     XFreeGC( xdisplay, gc );
 
-    return TRUE;
+    return true;
 #else
-    return FALSE;
+    return false;
 #endif
     // wxUSE_NANOX
 }
@@ -180,7 +180,7 @@ bool wxMask::Create( const wxBitmap& bitmap, int paletteIndex )
     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);
 
@@ -196,9 +196,9 @@ bool wxMask::Create( const wxBitmap& bitmap )
         m_bitmap = NULL;
     }
 
-    if (!bitmap.Ok()) return FALSE;
+    if (!bitmap.Ok()) 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();
 
@@ -207,7 +207,7 @@ bool wxMask::Create( const wxBitmap& bitmap )
 
     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 );
 
@@ -216,9 +216,9 @@ bool wxMask::Create( const wxBitmap& bitmap )
 
     XFreeGC( (Display*) m_display, gc );
 
-    return TRUE;
+    return true;
 #else
-    return FALSE;
+    return false;
 #endif
     // wxUSE_NANOX
 }
@@ -231,11 +231,15 @@ class wxBitmapRefData: public wxObjectRefData
 {
 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;
+    Pixmap          m_pixmap;
+    Pixmap          m_bitmap;
+    Display        *m_display;
     wxMask         *m_mask;
     int             m_width;
     int             m_height;
@@ -245,22 +249,67 @@ public:
 
 wxBitmapRefData::wxBitmapRefData()
 {
-    m_pixmap = NULL;
-    m_bitmap = NULL;
+    m_pixmap = 0;
+    m_bitmap = 0;
     m_display = NULL;
-    m_mask = (wxMask *) NULL;
+    m_mask = NULL;
     m_width = 0;
     m_height = 0;
     m_bpp = 0;
     m_palette = (wxPalette *) 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()
 {
-    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;
 }
 
 //-----------------------------------------------------------------------------
@@ -313,54 +362,14 @@ 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_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();
@@ -371,7 +380,7 @@ bool wxBitmap::Create(void *data, wxBitmapType type,
         wxLogWarning(wxT("no data bitmap handler for type %ld defined."),
                      (long)type);
 
-        return FALSE;
+        return false;
     }
 
     return handler->Create(this, data, type, width, height, depth);
@@ -387,13 +396,12 @@ bool wxBitmap::Create(WXPixmap pixmap)
 
     // make a copy of the Pixmap
     Window root;
-    Pixmap copy;
     int x, y;
     unsigned width, height, border, depth;
 
     XGetGeometry( xdisplay, (Drawable)xpixmap, &root, &x, &y,
                   &width, &height, &border, &depth );
-    copy = XCreatePixmap( xdisplay, xroot, width, height, 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 );
@@ -403,11 +411,11 @@ bool wxBitmap::Create(WXPixmap pixmap)
     wxBitmapRefData* ref = new wxBitmapRefData();
 
     if( depth == 1 )
-        ref->m_bitmap = (WXPixmap)copy;
+        ref->m_bitmap = copy;
     else
-        ref->m_pixmap = (WXPixmap)copy;
+        ref->m_pixmap = copy;
 
-    ref->m_display = (WXDisplay*)xdisplay;
+    ref->m_display = xdisplay;
     ref->m_width = width;
     ref->m_height = height;
     ref->m_bpp = depth;
@@ -417,11 +425,19 @@ bool wxBitmap::Create(WXPixmap pixmap)
     return true;
 }
 
-bool wxBitmap::CreateFromXpm( const char **bits )
+wxBitmap::wxBitmap(const char* const* bits)
+{
+    Create(bits, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0);
+}
+
+wxObjectRefData *wxBitmap::CreateRefData() const
 {
-    wxCHECK_MSG( bits, FALSE, wxT("NULL pointer in wxBitmap::CreateFromXpm") );
+    return new wxBitmapRefData;
+}
 
-    return Create(bits, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0);
+wxObjectRefData *wxBitmap::CloneRefData(const wxObjectRefData *data) const
+{
+    return new wxBitmapRefData(*wx_static_cast(const wxBitmapRefData *, data));
 }
 
 bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
@@ -430,14 +446,14 @@ bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
     if (!image.Ok())
     {
         wxASSERT_MSG(image.Ok(), wxT("Invalid wxImage passed to wxBitmap::CreateFromImage."));
-        return FALSE;
+        return false;
     }
 
     int w = image.GetWidth();
     int h = image.GetHeight();
 
     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
@@ -471,7 +487,7 @@ bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
         maskGC = GrNewGC();
         maskPixmap = GrNewPixmap(w, h, 0);
         if (!maskPixmap)
-            hasMask = FALSE;
+            hasMask = false;
         else
         {
             wxMask* mask = new wxMask;
@@ -529,14 +545,14 @@ bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
     if (hasMask)
         GrDestroyGC(maskGC);
 
-    return TRUE;
+    return true;
 #else
     // !wxUSE_NANOX
 
     UnRef();
 
-    wxCHECK_MSG( image.Ok(), FALSE, wxT("invalid image") )
-    wxCHECK_MSG( depth == -1, FALSE, wxT("invalid bitmap depth") )
+    wxCHECK_MSG( image.Ok(), false, wxT("invalid image") );
+    wxCHECK_MSG( depth == -1, false, wxT("invalid bitmap depth") );
 
     m_refData = new wxBitmapRefData();
 
@@ -572,15 +588,16 @@ bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
         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())
+        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 );
@@ -588,7 +605,7 @@ bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
             if (mask_image->data == NULL)
             {
                 wxLogError( wxT("Out of memory.") ); // TODO clean
-                return FALSE;
+                return false;
             }
 
             wxMask *mask = new wxMask();
@@ -630,8 +647,6 @@ bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
         unsigned char *colorCube =
             wxTheApp->GetVisualInfo(M_BMPDATA->m_display)->m_colorCube;
 
-        bool hasMask = image.HasMask();
-
         int index = 0;
         for (int y = 0; y < height; y++)
         {
@@ -747,7 +762,7 @@ bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
         }
     }
 
-    return TRUE;
+    return true;
 #endif
     // wxUSE_NANOX
 }
@@ -816,7 +831,7 @@ wxImage wxBitmap::ConvertToImage() const
     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())
     {
@@ -866,15 +881,15 @@ wxImage wxBitmap::ConvertToImage() const
             }
             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)
             {
-                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
             {
@@ -903,11 +918,6 @@ wxImage wxBitmap::ConvertToImage() const
     // wxUSE_NANOX
 }
 
-wxBitmap::wxBitmap( const wxBitmap& bmp )
-{
-    Ref( bmp );
-}
-
 wxBitmap::wxBitmap( const wxString &filename, wxBitmapType type )
 {
     LoadFile( filename, type );
@@ -917,32 +927,14 @@ 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(bits, wxBITMAP_TYPE_XBM_DATA, width, height, depth);
 }
 
 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
+bool wxBitmap::IsOk() const
 {
     return (m_refData != NULL);
 }
@@ -979,6 +971,7 @@ void wxBitmap::SetMask( wxMask *mask )
 {
     wxCHECK_RET( Ok(), wxT("invalid bitmap") );
 
+    AllocExclusive();
     if (M_BMPDATA->m_mask) delete M_BMPDATA->m_mask;
 
     M_BMPDATA->m_mask = mask;
@@ -987,7 +980,7 @@ void wxBitmap::SetMask( wxMask *mask )
 bool wxBitmap::CopyFromIcon(const wxIcon& icon)
 {
     *this = icon;
-    return TRUE;
+    return true;
 }
 
 wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const
@@ -1038,7 +1031,7 @@ wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const
 bool wxBitmap::SaveFile( const wxString &name, wxBitmapType type,
                          const wxPalette *palette ) const
 {
-    wxCHECK_MSG( Ok(), FALSE, wxT("invalid bitmap") );
+    wxCHECK_MSG( Ok(), false, wxT("invalid bitmap") );
 
     wxBitmapHandler *handler = FindHandler(type);
 
@@ -1048,7 +1041,7 @@ bool wxBitmap::SaveFile( const wxString &name, wxBitmapType type,
         wxImage image(this->ConvertToImage());
         if (image.Ok()) return image.SaveFile( name, type );
 
-        return FALSE;
+        return false;
     }
 
     return handler->SaveFile(this, name, type, palette);
@@ -1058,7 +1051,7 @@ bool wxBitmap::LoadFile( const wxString &name, wxBitmapType type )
 {
     UnRef();
 
-    if (!wxFileExists(name)) return FALSE;
+    if (!wxFileExists(name)) return false;
 
     wxBitmapHandler *handler = FindHandler(type);
 
@@ -1066,14 +1059,14 @@ bool wxBitmap::LoadFile( const wxString &name, wxBitmapType type )
     {
         wxImage image;
         if (!image.LoadFile( name, type ))
-            return FALSE;
+            return false;
 
         if (image.Ok())
         {
             *this = wxBitmap(image);
-            return TRUE;
+            return true;
         }
-        else return FALSE;
+        else return false;
     }
 
     return handler->LoadFile(this, name, type, -1, -1);
@@ -1085,6 +1078,7 @@ void wxBitmap::SetPalette(const wxPalette& palette)
     wxCHECK_RET(GetDepth() > 1 && GetDepth() <= 8,
                 wxT("cannot set palette for bitmap of this depth"));
 
+    AllocExclusive();
     delete M_BMPDATA->m_palette;
     M_BMPDATA->m_palette = NULL;
 
@@ -1102,21 +1096,21 @@ wxPalette *wxBitmap::GetPalette() const
 
 void wxBitmap::SetHeight( int height )
 {
-    if (!m_refData) m_refData = new wxBitmapRefData();
+    AllocExclusive();
 
     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 )
 {
-    if (!m_refData) m_refData = new wxBitmapRefData();
+    AllocExclusive();
 
     M_BMPDATA->m_bpp = depth;
 }
@@ -1125,35 +1119,36 @@ void wxBitmap::SetPixmap( WXPixmap pixmap )
 {
     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();
 
-    M_BMPDATA->m_bitmap = bitmap;
+    M_BMPDATA->m_bitmap = (Pixmap)bitmap;
 }
 
 WXPixmap wxBitmap::GetPixmap() const
 {
     wxCHECK_MSG( Ok(), (WXPixmap) NULL, wxT("invalid bitmap") );
 
-    return M_BMPDATA->m_pixmap;
+    return (WXPixmap)M_BMPDATA->m_pixmap;
 }
 
 WXPixmap wxBitmap::GetBitmap() const
 {
     wxCHECK_MSG( Ok(), (WXPixmap) NULL, wxT("invalid bitmap") );
 
-    return M_BMPDATA->m_bitmap;
+    return (WXPixmap)M_BMPDATA->m_bitmap;
 }
 
 WXPixmap wxBitmap::GetDrawable() const
 {
     wxCHECK_MSG( Ok(), (WXPixmap) NULL, wxT("invalid bitmap") );
 
-    return M_BMPDATA->m_bpp == 1 ? M_BMPDATA->m_bitmap : M_BMPDATA->m_pixmap;
+    return (WXPixmap)(M_BMPDATA->m_bpp == 1 ? M_BMPDATA->m_bitmap
+                                            : M_BMPDATA->m_pixmap);
 }
 
 WXDisplay *wxBitmap::GetDisplay() const
@@ -1177,14 +1172,14 @@ bool wxGetImageFromDrawable(GR_DRAW_ID drawable, int srcX, int srcY, int width,
 
     if (sinfo.pixtype == MWPF_PALETTE) {
         if(!(palette = (GR_PALETTE*) malloc(sizeof(GR_PALETTE)))) {
-            return FALSE;
+            return false;
         }
         GrGetSystemPalette(palette);
     }
 
     if(!(pixels = (GR_PIXELVAL*) malloc(sizeof(GR_PIXELVAL) * width * height)))
     {
-        return FALSE;
+        return false;
     }
 
     image.Create(width, height);
@@ -1242,7 +1237,7 @@ bool wxGetImageFromDrawable(GR_DRAW_ID drawable, int srcX, int srcY, int width,
     free(pixels);
     if(palette) free(palette);
 
-    return TRUE;
+    return true;
 }
 
 #if 0
@@ -1304,7 +1299,7 @@ int GrGetPixelColor(GR_SCREEN_INFO* sinfo, GR_PALETTE* palette, GR_PIXELVAL pixe
 // Bitmap handlers
 // ============================================================================
 
-IMPLEMENT_ABSTRACT_CLASS(wxBitmapHandler, wxBitmapHandlerBase);
+IMPLEMENT_ABSTRACT_CLASS(wxBitmapHandler, wxBitmapHandlerBase)
 
 #define M_BMPHANDLERDATA ((wxBitmapRefData *)bitmap->GetRefData())
 
@@ -1333,16 +1328,16 @@ public:
     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; }
+    virtual bool Create(wxBitmap *WXUNUSED(bitmap), const void* WXUNUSED(data), long WXUNUSED(flags),
+                        int WXUNUSED(width), int WXUNUSED(height), int WXUNUSED(depth) = 1)
+        { return false; }
 };
 
-IMPLEMENT_DYNAMIC_CLASS(wxXPMFileHandler, wxBitmapHandler);
+IMPLEMENT_DYNAMIC_CLASS(wxXPMFileHandler, wxBitmapHandler)
 
 bool wxXPMFileHandler::LoadFile(wxBitmap *bitmap, const wxString& name,
-                                long flags, int desiredWidth,
-                                int desiredHeight)
+                                long WXUNUSED(flags), int WXUNUSED(desiredWidth),
+                                int WXUNUSED(desiredHeight))
 {
 #if wxHAVE_LIB_XPM
     if (!bitmap->GetRefData())
@@ -1364,7 +1359,7 @@ bool wxXPMFileHandler::LoadFile(wxBitmap *bitmap, const wxString& name,
     Pixmap mask = 0;
 
     int ErrorStatus = XpmReadFileToPixmap( xdisplay, xroot,
-                                           (char*) name.c_str(),
+                                           (char*) ((const char*) name.c_str()),
                                            &pixmap, &mask, &xpmAttr);
 
     if (ErrorStatus == XpmSuccess)
@@ -1376,7 +1371,7 @@ bool wxXPMFileHandler::LoadFile(wxBitmap *bitmap, const wxString& name,
 
         XpmFreeAttributes(&xpmAttr);
 
-        M_BMPHANDLERDATA->m_bitmap = (WXPixmap) pixmap;
+        M_BMPHANDLERDATA->m_bitmap = (Pixmap) pixmap;
 
         if (mask)
         {
@@ -1389,10 +1384,10 @@ bool wxXPMFileHandler::LoadFile(wxBitmap *bitmap, const wxString& name,
     {
         UnRef();
 
-        return FALSE;
+        return false;
     }
 
-    return TRUE;
+    return true;
 #elif wxUSE_STREAMS
     wxXPMDecoder decoder;
     wxFileInputStream stream(name);
@@ -1402,9 +1397,9 @@ bool wxXPMFileHandler::LoadFile(wxBitmap *bitmap, const wxString& name,
         return image.Ok() && bitmap->CreateFromImage(image);
     }
 
-    return FALSE;
+    return false;
 #else // !wxHAVE_LIB_XPM && !wxUSE_STREAMS
-    return FALSE;
+    return false;
 #endif // wxHAVE_LIB_XPM / wxUSE_STREAMS
 }
 
@@ -1415,7 +1410,7 @@ bool wxXPMFileHandler::SaveFile(const wxBitmap *bitmap, const wxString& name,
     wxImage image(bitmap->ConvertToImage());
     if (image.Ok()) return image.SaveFile( name, (wxBitmapType)type );
 
-    return FALSE;
+    return false;
 }
 
 #endif // wxHAVE_LIB_XPM || wxUSE_STREAMS
@@ -1435,26 +1430,31 @@ public:
         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),
+                          long 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),
+                          int WXUNUSED(type),
+                          const wxPalette *WXUNUSED(palette) = NULL)
+        { return false; }
 
-    virtual bool Create(wxBitmap *bitmap, void *data, long flags,
+    virtual bool Create(wxBitmap *bitmap, const void* data, long flags,
                         int width, int height, int depth = 1);
 };
 
-IMPLEMENT_DYNAMIC_CLASS(wxXPMDataHandler, wxBitmapHandler);
+IMPLEMENT_DYNAMIC_CLASS(wxXPMDataHandler, wxBitmapHandler)
 
-bool wxXPMDataHandler::Create(wxBitmap *bitmap, void *bits,
+bool wxXPMDataHandler::Create(wxBitmap *bitmap, const void* bits,
                               long WXUNUSED(flags),
-                              int width, int height, int WXUNUSED(depth))
+                              int WXUNUSED(width), int WXUNUSED(height), int WXUNUSED(depth))
 {
 #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() );
@@ -1496,7 +1496,7 @@ bool wxXPMDataHandler::Create(wxBitmap *bitmap, void *bits,
 
         XpmFreeAttributes(&xpmAttr);
 
-        M_BMPHANDLERDATA->m_pixmap = (WXPixmap) pixmap;
+        M_BMPHANDLERDATA->m_pixmap = (Pixmap) pixmap;
 
         if (mask)
         {
@@ -1504,13 +1504,13 @@ bool wxXPMDataHandler::Create(wxBitmap *bitmap, void *bits,
             M_BMPHANDLERDATA->m_mask->SetBitmap( (WXPixmap) mask );
             M_BMPHANDLERDATA->m_mask->SetDisplay( xdisplay );
         }
-        return TRUE;
+        return true;
     }
     else
     {
         bitmap->UnRef();
 
-        return FALSE;
+        return false;
     }
 #else // !wxHAVE_LIB_XPM
     wxXPMDecoder decoder;
@@ -1536,23 +1536,28 @@ public:
         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),
+                          long 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),
+                          int WXUNUSED(type),
+                          const wxPalette *WXUNUSED(palette) = NULL)
+        { return false; }
 
-    virtual bool Create(wxBitmap *bitmap, void *data, long flags,
+    virtual bool Create(wxBitmap *bitmap, const void* data, long flags,
                         int width, int height, int depth = 1);
 };
 
-IMPLEMENT_DYNAMIC_CLASS(wxXBMDataHandler, wxBitmapHandler);
+IMPLEMENT_DYNAMIC_CLASS(wxXBMDataHandler, wxBitmapHandler)
 
-bool wxXBMDataHandler::Create( wxBitmap *bitmap, void *bits,
+bool wxXBMDataHandler::Create( wxBitmap *bitmap, const void* bits,
                                long WXUNUSED(flags),
-                               int width, int height, int depth)
+                               int width, int height, int WXUNUSED(depth))
 {
 #if !wxUSE_NANOX
     if (!bitmap->GetRefData())
@@ -1567,15 +1572,15 @@ bool wxXBMDataHandler::Create( wxBitmap *bitmap, void *bits,
 
     M_BMPHANDLERDATA->m_mask = (wxMask *) NULL;
     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;
 
-    return TRUE;
+    return true;
 #else
-   wxCHECK_MSG( M_BMPHANDLERDATA->m_bitmap, FALSE,
+   wxCHECK_MSG( M_BMPHANDLERDATA->m_bitmap, false,
                  wxT("couldn't create bitmap") );
 #endif
 }