Back to previous call with -1 replacement.

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

diff --git a/src/x11/bitmap.cpp b/src/x11/bitmap.cpp
index 1dc3b18684c8119a75f1cb8b4770c2b558329e38..7e42116984e8ac6625a55de63e9977b3f159181e 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"


@@ -41,7 +42,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


@@ -92,7 +92,7 @@ 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.Ok()) return false;

 
     m_display = bitmap.GetDisplay();
 
 
     m_display = bitmap.GetDisplay();
 


@@ -118,21 +118,21 @@ bool wxMask::Create( const wxBitmap& bitmap,
 
     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) );


@@ -168,9 +168,9 @@ bool wxMask::Create( const wxBitmap& bitmap,
 
     XFreeGC( xdisplay, gc );
 
 
     XFreeGC( xdisplay, gc );
 

-    return TRUE;
+    return true;

 #else
 #else

-    return FALSE;
+    return false;

 #endif
     // wxUSE_NANOX
 }
 #endif
     // wxUSE_NANOX
 }


@@ -180,7 +180,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,9 +196,9 @@ bool wxMask::Create( const wxBitmap& bitmap )
         m_bitmap = NULL;
     }
 
         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();
 
 
     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 );
 
 
     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 );
 
 
     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 );
 
 
     XFreeGC( (Display*) m_display, gc );
 

-    return TRUE;
+    return true;

 #else
 #else

-    return FALSE;
+    return false;

 #endif
     // wxUSE_NANOX
 }
 #endif
     // wxUSE_NANOX
 }


@@ -231,7 +231,7 @@ class wxBitmapRefData: public wxObjectRefData
 {
 public:
     wxBitmapRefData();
 {
 public:
     wxBitmapRefData();

-    ~wxBitmapRefData();
+    virtual ~wxBitmapRefData();

 
     WXPixmap        m_pixmap;
     WXPixmap        m_bitmap;
 
     WXPixmap        m_pixmap;
     WXPixmap        m_bitmap;


@@ -271,25 +271,27 @@ 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;
+
+    int xscreen = DefaultScreen( dpy );
+    Window xroot = RootWindow( dpy, xscreen );
+    Visual* xvisual = DefaultVisual( dpy, xscreen );

 
 

-    XImage* ximage = XCreateImage( (Display*)xdisplay, xvisual, depth,
+    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,
+    ximage = XGetSubImage( dpy, (Pixmap)xpixmap,

                            x, y, width, height,
                            AllPlanes, ZPixmap, ximage, 0, 0 );
 
                            x, y, width, height,
                            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;
 }


@@ -311,7 +313,7 @@ bool wxBitmap::Create( int width, int height, int depth )
 {
     UnRef();
 
 {
     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();
 


@@ -326,7 +328,7 @@ bool wxBitmap::Create( int width, int height, int depth )
     if (depth == -1) depth = bpp;
 
     wxCHECK_MSG( (depth == bpp) ||
     if (depth == -1) depth = bpp;
 
     wxCHECK_MSG( (depth == bpp) ||

-                 (depth == 1), FALSE, wxT("invalid bitmap depth") )
+                 (depth == 1), false, wxT("invalid bitmap depth") );

 
     M_BMPDATA->m_mask = (wxMask *) NULL;
     M_BMPDATA->m_width = width;
 
     M_BMPDATA->m_mask = (wxMask *) NULL;
     M_BMPDATA->m_width = width;


@@ -358,7 +360,7 @@ bool wxBitmap::Create( int width, int height, int depth )
     return Ok();
 }
 
     return Ok();
 }
 

-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,10 +368,10 @@ 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);


@@ -415,11 +417,9 @@ bool wxBitmap::Create(WXPixmap pixmap)
     return true;
 }
 
     return true;
 }
 

-bool wxBitmap::CreateFromXpm( const char **bits )
+wxBitmap::wxBitmap(const char* const* bits)

 {
 {

-    wxCHECK_MSG( bits, FALSE, _T("NULL pointer in wxBitmap::CreateFromXpm") );
-
-    return Create(bits, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0);
+    Create(bits, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0);

 }
 
 bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
 }
 
 bool wxBitmap::CreateFromImage( const wxImage& image, int depth )


@@ -427,15 +427,15 @@ bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
 #if wxUSE_NANOX
     if (!image.Ok())
     {
 #if wxUSE_NANOX
     if (!image.Ok())
     {

-        wxASSERT_MSG(image.Ok(), "Invalid wxImage passed to wxBitmap::CreateFromImage.");
-        return FALSE;
+        wxASSERT_MSG(image.Ok(), wxT("Invalid wxImage passed to wxBitmap::CreateFromImage."));
+        return false;

     }
 
     int w = image.GetWidth();
     int h = image.GetHeight();
 
     if (!Create(w, h, depth))
     }
 
     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
 
     // Unfortunately the mask has to be screen-depth since
     // 1-bpp bitmaps don't seem to be supported


@@ -469,7 +469,7 @@ bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
         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;


@@ -527,14 +527,14 @@ bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
     if (hasMask)
         GrDestroyGC(maskGC);
 
     if (hasMask)
         GrDestroyGC(maskGC);
 

-    return TRUE;
+    return true;

 #else
     // !wxUSE_NANOX
 
     UnRef();
 
 #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();
 
 
     m_refData = new wxBitmapRefData();
 


@@ -558,7 +558,7 @@ bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
 
     if (depth == 1)
     {
 
     if (depth == 1)
     {

-        wxFAIL_MSG( "mono images later" );
+        wxFAIL_MSG( wxT("mono images later") );

     }
     else
     {
     }
     else
     {


@@ -570,7 +570,7 @@ bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
         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 = (WXPixmap) XCreatePixmap( xdisplay, xroot, width, height, depth );


@@ -586,7 +586,7 @@ bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
             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();
             }
 
             wxMask *mask = new wxMask();


@@ -623,7 +623,7 @@ 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" );
+        wxASSERT_MSG( data, wxT("No image data") );

 
         unsigned char *colorCube =
             wxTheApp->GetVisualInfo(M_BMPDATA->m_display)->m_colorCube;
 
         unsigned char *colorCube =
             wxTheApp->GetVisualInfo(M_BMPDATA->m_display)->m_colorCube;


@@ -745,7 +745,7 @@ bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
         }
     }
 
         }
     }
 

-    return TRUE;
+    return true;

 #endif
     // wxUSE_NANOX
 }
 #endif
     // wxUSE_NANOX
 }


@@ -814,7 +814,7 @@ 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())
     {


@@ -864,15 +864,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
             {


@@ -901,11 +901,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 );


@@ -915,21 +910,13 @@ 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;


@@ -940,7 +927,7 @@ bool wxBitmap::operator != ( const wxBitmap& bmp ) const
     return m_refData != bmp.m_refData;
 }
 
     return m_refData != bmp.m_refData;
 }
 

-bool wxBitmap::Ok() const
+bool wxBitmap::IsOk() const

 {
     return (m_refData != NULL);
 }
 {
     return (m_refData != NULL);
 }


@@ -985,7 +972,7 @@ 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


@@ -1036,7 +1023,7 @@ 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( Ok(), false, wxT("invalid bitmap") );

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


@@ -1046,7 +1033,7 @@ bool wxBitmap::SaveFile( const wxString &name, wxBitmapType type,
         wxImage image(this->ConvertToImage());
         if (image.Ok()) return image.SaveFile( name, type );
 
         wxImage image(this->ConvertToImage());
         if (image.Ok()) return image.SaveFile( name, type );
 

-        return FALSE;
+        return false;

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


@@ -1056,7 +1043,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);
 


@@ -1064,14 +1051,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())
         {
             *this = wxBitmap(image);
 
         if (image.Ok())
         {
             *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);


@@ -1175,14 +1162,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)))) {
 
     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)))
     {
         }
         GrGetSystemPalette(palette);
     }
 
     if(!(pixels = (GR_PIXELVAL*) malloc(sizeof(GR_PIXELVAL) * width * height)))
     {

-        return FALSE;
+        return false;

     }
 
     image.Create(width, height);
     }
 
     image.Create(width, height);


@@ -1240,7 +1227,7 @@ bool wxGetImageFromDrawable(GR_DRAW_ID drawable, int srcX, int srcY, int width,
     free(pixels);
     if(palette) free(palette);
 
     free(pixels);
     if(palette) free(palette);
 

-    return TRUE;
+    return true;

 }
 
 #if 0
 }
 
 #if 0


@@ -1302,7 +1289,7 @@ int GrGetPixelColor(GR_SCREEN_INFO* sinfo, GR_PALETTE* palette, GR_PIXELVAL pixe
 // Bitmap handlers
 // ============================================================================
 
 // Bitmap handlers
 // ============================================================================
 

-IMPLEMENT_ABSTRACT_CLASS(wxBitmapHandler, wxBitmapHandlerBase);
+IMPLEMENT_ABSTRACT_CLASS(wxBitmapHandler, wxBitmapHandlerBase)

 
 #define M_BMPHANDLERDATA ((wxBitmapRefData *)bitmap->GetRefData())
 
 
 #define M_BMPHANDLERDATA ((wxBitmapRefData *)bitmap->GetRefData())
 


@@ -1316,13 +1303,13 @@ IMPLEMENT_ABSTRACT_CLASS(wxBitmapHandler, wxBitmapHandlerBase);
 
 class wxXPMFileHandler : public wxBitmapHandler
 {
 
 class wxXPMFileHandler : public wxBitmapHandler
 {

-    DECLARE_DYNAMIC_CLASS(wxXPMFileHandler);
+    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, long flags,


@@ -1331,16 +1318,16 @@ public:
     virtual bool SaveFile(const wxBitmap *bitmap, const wxString& name,
                           int type, const wxPalette *palette = NULL);
 
     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,
 
 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())
 {
 #if wxHAVE_LIB_XPM
     if (!bitmap->GetRefData())


@@ -1387,10 +1374,10 @@ bool wxXPMFileHandler::LoadFile(wxBitmap *bitmap, const wxString& name,
     {
         UnRef();
 
     {
         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);


@@ -1400,9 +1387,9 @@ bool wxXPMFileHandler::LoadFile(wxBitmap *bitmap, const wxString& name,
         return image.Ok() && bitmap->CreateFromImage(image);
     }
 
         return image.Ok() && bitmap->CreateFromImage(image);
     }
 

-    return FALSE;
+    return false;

 #else // !wxHAVE_LIB_XPM && !wxUSE_STREAMS
 #else // !wxHAVE_LIB_XPM && !wxUSE_STREAMS

-    return FALSE;
+    return false;

 #endif // wxHAVE_LIB_XPM / wxUSE_STREAMS
 }
 
 #endif // wxHAVE_LIB_XPM / wxUSE_STREAMS
 }
 


@@ -1413,7 +1400,7 @@ bool wxXPMFileHandler::SaveFile(const wxBitmap *bitmap, const wxString& name,
     wxImage image(bitmap->ConvertToImage());
     if (image.Ok()) return image.SaveFile( name, (wxBitmapType)type );
 
     wxImage image(bitmap->ConvertToImage());
     if (image.Ok()) return image.SaveFile( name, (wxBitmapType)type );
 

-    return FALSE;
+    return false;

 }
 
 #endif // wxHAVE_LIB_XPM || wxUSE_STREAMS
 }
 
 #endif // wxHAVE_LIB_XPM || wxUSE_STREAMS


@@ -1424,35 +1411,40 @@ 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),
+                          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);
 };
 
                         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),
                               long WXUNUSED(flags),

-                              int width, int height, int WXUNUSED(depth))
+                              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() );
 
     if (!bitmap->GetRefData())
         bitmap->SetRefData( new wxBitmapRefData() );


@@ -1502,13 +1494,13 @@ bool wxXPMDataHandler::Create(wxBitmap *bitmap, void *bits,
             M_BMPHANDLERDATA->m_mask->SetBitmap( (WXPixmap) mask );
             M_BMPHANDLERDATA->m_mask->SetDisplay( xdisplay );
         }
             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 // !wxHAVE_LIB_XPM
     wxXPMDecoder decoder;
     }
 #else // !wxHAVE_LIB_XPM
     wxXPMDecoder decoder;


@@ -1529,28 +1521,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),
+                          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);
 };
 
                         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),
                                long WXUNUSED(flags),

-                               int width, int height, int depth)
+                               int width, int height, int WXUNUSED(depth))

 {
 #if !wxUSE_NANOX
     if (!bitmap->GetRefData())
 {
 #if !wxUSE_NANOX
     if (!bitmap->GetRefData())


@@ -1571,10 +1568,11 @@ bool wxXBMDataHandler::Create( wxBitmap *bitmap, void *bits,
     M_BMPHANDLERDATA->m_height = height;
     M_BMPHANDLERDATA->m_bpp = 1;
 
     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()