reSWIGged

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

diff --git a/src/gtk/bitmap.cpp b/src/gtk/bitmap.cpp
index ea76fd0e340a0045a4b7a742c66dae2df37c1348..48300626d3ac25facd0413d21d165fc978888df3 100644 (file)
--- a/src/gtk/bitmap.cpp
+++ b/src/gtk/bitmap.cpp
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        bitmap.cpp
+// Name:        src/gtk/bitmap.cpp

 // Purpose:
 // Author:      Robert Roebling
 // RCS-ID:      $Id$
 // Purpose:
 // Author:      Robert Roebling
 // RCS-ID:      $Id$


@@ -7,39 +7,30 @@
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // 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/defs.h"
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #include "wx/defs.h"
 

-#include "wx/palette.h"

 #include "wx/bitmap.h"
 #include "wx/bitmap.h"

+#include "wx/palette.h"

 #include "wx/icon.h"
 #include "wx/filefn.h"
 #include "wx/image.h"
 #include "wx/dcmemory.h"
 #include "wx/app.h"
 
 #include "wx/icon.h"
 #include "wx/filefn.h"
 #include "wx/image.h"
 #include "wx/dcmemory.h"
 #include "wx/app.h"
 

-#ifdef __WXGTK20__
+#include "wx/rawbmp.h"

     // need this to get gdk_image_new_bitmap()
     #define GDK_ENABLE_BROKEN
     // need this to get gdk_image_new_bitmap()
     #define GDK_ENABLE_BROKEN

-#endif

 
 #include <gdk/gdk.h>
 #include <gtk/gtk.h>
 #include <gdk/gdkx.h>
 
 
 #include <gdk/gdk.h>
 #include <gtk/gtk.h>
 #include <gdk/gdkx.h>
 

-#ifdef __WXGTK20__
-    #include <gdk/gdkimage.h>
-#else // GTK+ 1.2
-    #include <gdk/gdkrgb.h>
-#endif // GTK+ 2.0/1.2
+#include <gdk/gdkimage.h>

 
 

-#include <math.h>
+#include "wx/math.h"

 
 extern void gdk_wx_draw_bitmap     (GdkDrawable  *drawable,
                           GdkGC               *gc,
 
 extern void gdk_wx_draw_bitmap     (GdkDrawable  *drawable,
                           GdkGC               *gc,


@@ -74,11 +65,13 @@ wxMask::wxMask( const wxBitmap& bitmap, const wxColour& colour )
     Create( bitmap, colour );
 }
 
     Create( bitmap, colour );
 }
 

+#if wxUSE_PALETTE

 wxMask::wxMask( const wxBitmap& bitmap, int paletteIndex )
 {
     m_bitmap = (GdkBitmap *) NULL;
     Create( bitmap, paletteIndex );
 }
 wxMask::wxMask( const wxBitmap& bitmap, int paletteIndex )
 {
     m_bitmap = (GdkBitmap *) NULL;
     Create( bitmap, paletteIndex );
 }

+#endif // wxUSE_PALETTE

 
 wxMask::wxMask( const wxBitmap& bitmap )
 {
 
 wxMask::wxMask( const wxBitmap& bitmap )
 {


@@ -102,7 +95,7 @@ bool wxMask::Create( const wxBitmap& bitmap,
     }
 
     wxImage image = bitmap.ConvertToImage();
     }
 
     wxImage image = bitmap.ConvertToImage();

-    if (!image.Ok()) return FALSE;
+    if (!image.Ok()) return false;

 
     m_bitmap = gdk_pixmap_new( wxGetRootWindow()->window, image.GetWidth(), image.GetHeight(), 1 );
     GdkGC *gc = gdk_gc_new( m_bitmap );
 
     m_bitmap = gdk_pixmap_new( wxGetRootWindow()->window, image.GetWidth(), image.GetHeight(), 1 );
     GdkGC *gc = gdk_gc_new( m_bitmap );


@@ -182,20 +175,22 @@ bool wxMask::Create( const wxBitmap& bitmap,
 
     gdk_gc_unref( gc );
 
 
     gdk_gc_unref( gc );
 

-    return TRUE;
+    return true;

 }
 
 }
 

+#if wxUSE_PALETTE

 bool wxMask::Create( const wxBitmap& bitmap, int paletteIndex )
 {
     unsigned char r,g,b;
     wxPalette *pal = bitmap.GetPalette();
 
 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);
 
     return Create(bitmap, wxColour(r, g, b));
 }
 
     pal->GetRGB(paletteIndex, &r, &g, &b);
 
     return Create(bitmap, wxColour(r, g, b));
 }

+#endif // wxUSE_PALETTE

 
 bool wxMask::Create( const wxBitmap& bitmap )
 {
 
 bool wxMask::Create( const wxBitmap& bitmap )
 {


@@ -205,13 +200,13 @@ bool wxMask::Create( const wxBitmap& bitmap )
         m_bitmap = (GdkBitmap*) NULL;
     }
 
         m_bitmap = (GdkBitmap*) 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_bitmap = gdk_pixmap_new( wxGetRootWindow()->window, bitmap.GetWidth(), bitmap.GetHeight(), 1 );
 
 
     m_bitmap = gdk_pixmap_new( wxGetRootWindow()->window, bitmap.GetWidth(), bitmap.GetHeight(), 1 );
 

-    if (!m_bitmap) return FALSE;
+    if (!m_bitmap) return false;

 
     GdkGC *gc = gdk_gc_new( m_bitmap );
 
 
     GdkGC *gc = gdk_gc_new( m_bitmap );
 


@@ -219,7 +214,7 @@ bool wxMask::Create( const wxBitmap& bitmap )
 
     gdk_gc_unref( gc );
 
 
     gdk_gc_unref( gc );
 

-    return TRUE;
+    return true;

 }
 
 GdkBitmap *wxMask::GetBitmap() const
 }
 
 GdkBitmap *wxMask::GetBitmap() const


@@ -239,9 +234,7 @@ public:
 
     GdkPixmap      *m_pixmap;
     GdkBitmap      *m_bitmap;
 
     GdkPixmap      *m_pixmap;
     GdkBitmap      *m_bitmap;

-#ifdef __WXGTK20__

     GdkPixbuf      *m_pixbuf;
     GdkPixbuf      *m_pixbuf;

-#endif

     wxMask         *m_mask;
     int             m_width;
     int             m_height;
     wxMask         *m_mask;
     int             m_width;
     int             m_height;


@@ -253,9 +246,7 @@ wxBitmapRefData::wxBitmapRefData()
 {
     m_pixmap = (GdkPixmap *) NULL;
     m_bitmap = (GdkBitmap *) NULL;
 {
     m_pixmap = (GdkPixmap *) NULL;
     m_bitmap = (GdkBitmap *) NULL;

-#ifdef __WXGTK20__

     m_pixbuf = (GdkPixbuf *) NULL;
     m_pixbuf = (GdkPixbuf *) NULL;

-#endif

     m_mask = (wxMask *) NULL;
     m_width = 0;
     m_height = 0;
     m_mask = (wxMask *) NULL;
     m_width = 0;
     m_height = 0;


@@ -269,12 +260,12 @@ wxBitmapRefData::~wxBitmapRefData()
         gdk_pixmap_unref( m_pixmap );
     if (m_bitmap)
         gdk_bitmap_unref( m_bitmap );
         gdk_pixmap_unref( m_pixmap );
     if (m_bitmap)
         gdk_bitmap_unref( m_bitmap );

-#ifdef __WXGTK20__

     if (m_pixbuf)
         gdk_pixbuf_unref( m_pixbuf );
     if (m_pixbuf)
         gdk_pixbuf_unref( m_pixbuf );

-#endif

     delete m_mask;
     delete m_mask;

+#if wxUSE_PALETTE

     delete m_palette;
     delete m_palette;

+#endif // wxUSE_PALETTE

 }
 
 //-----------------------------------------------------------------------------
 }
 
 //-----------------------------------------------------------------------------


@@ -306,8 +297,8 @@ bool wxBitmap::Create( int width, int height, int depth )
     if (depth == -1)
         depth = visual->depth;
 
     if (depth == -1)
         depth = visual->depth;
 

-    wxCHECK_MSG( (depth == visual->depth) || (depth == 1), FALSE,
-                    wxT("invalid bitmap depth") )
+    wxCHECK_MSG( (depth == visual->depth) || (depth == 1) || (depth == 32), false,
+                    wxT("invalid bitmap depth") );

 
     m_refData = new wxBitmapRefData();
     M_BMPDATA->m_mask = (wxMask *) NULL;
 
     m_refData = new wxBitmapRefData();
     M_BMPDATA->m_mask = (wxMask *) NULL;


@@ -318,6 +309,12 @@ bool wxBitmap::Create( int width, int height, int depth )
         M_BMPDATA->m_bitmap = gdk_pixmap_new( wxGetRootWindow()->window, width, height, 1 );
         M_BMPDATA->m_bpp = 1;
     }
         M_BMPDATA->m_bitmap = gdk_pixmap_new( wxGetRootWindow()->window, width, height, 1 );
         M_BMPDATA->m_bpp = 1;
     }

+    else if (depth == 32)
+    {
+        M_BMPDATA->m_pixbuf = gdk_pixbuf_new( GDK_COLORSPACE_RGB, true,
+                                              8, width, height);
+        M_BMPDATA->m_bpp = 32;
+    }

     else
     {
         M_BMPDATA->m_pixmap = gdk_pixmap_new( wxGetRootWindow()->window, width, height, depth );
     else
     {
         M_BMPDATA->m_pixmap = gdk_pixmap_new( wxGetRootWindow()->window, width, height, depth );


@@ -331,7 +328,7 @@ bool wxBitmap::CreateFromXpm( const char **bits )
 {
     UnRef();
 
 {
     UnRef();
 

-    wxCHECK_MSG( bits != NULL, FALSE, wxT("invalid bitmap data") )
+    wxCHECK_MSG( bits != NULL, false, wxT("invalid bitmap data") );

 
     GdkVisual *visual = wxTheApp->GetGdkVisual();
 
 
     GdkVisual *visual = wxTheApp->GetGdkVisual();
 


@@ -341,7 +338,7 @@ bool wxBitmap::CreateFromXpm( const char **bits )
 
     M_BMPDATA->m_pixmap = gdk_pixmap_create_from_xpm_d( wxGetRootWindow()->window, &mask, NULL, (gchar **) bits );
 
 
     M_BMPDATA->m_pixmap = gdk_pixmap_create_from_xpm_d( wxGetRootWindow()->window, &mask, NULL, (gchar **) bits );
 

-    wxCHECK_MSG( M_BMPDATA->m_pixmap, FALSE, wxT("couldn't create pixmap") );
+    wxCHECK_MSG( M_BMPDATA->m_pixmap, false, wxT("couldn't create pixmap") );

 
     if (mask)
     {
 
     if (mask)
     {


@@ -353,7 +350,7 @@ bool wxBitmap::CreateFromXpm( const char **bits )
 
     M_BMPDATA->m_bpp = visual->depth;  // Can we get a different depth from create_from_xpm_d() ?
 
 
     M_BMPDATA->m_bpp = visual->depth;  // Can we get a different depth from create_from_xpm_d() ?
 

-    return TRUE;
+    return true;

 }
 
 wxBitmap wxBitmap::Rescale( int clipx, int clipy, int clipwidth, int clipheight, int newx, int newy )
 }
 
 wxBitmap wxBitmap::Rescale( int clipx, int clipy, int clipwidth, int clipheight, int newx, int newy )


@@ -362,15 +359,14 @@ wxBitmap wxBitmap::Rescale( int clipx, int clipy, int clipwidth, int clipheight,
 
     if (newy==M_BMPDATA->m_width && newy==M_BMPDATA->m_height)
         return *this;
 
     if (newy==M_BMPDATA->m_width && newy==M_BMPDATA->m_height)
         return *this;

-    
+

     int width = wxMax(newx, 1);
     int height = wxMax(newy, 1);
     width = wxMin(width, clipwidth);
     height = wxMin(height, clipheight);
     int width = wxMax(newx, 1);
     int height = wxMax(newy, 1);
     width = wxMin(width, clipwidth);
     height = wxMin(height, clipheight);

-        
+

     wxBitmap bmp;
 
     wxBitmap bmp;
 

-#ifdef __WXGTK20__

     if (HasPixbuf())
     {
         bmp.SetWidth(width);
     if (HasPixbuf())
     {
         bmp.SetWidth(width);


@@ -381,12 +377,11 @@ wxBitmap wxBitmap::Rescale( int clipx, int clipy, int clipwidth, int clipheight,
                                      8, width, height));
         gdk_pixbuf_scale(GetPixbuf(), bmp.GetPixbuf(),
                          0, 0, width, height,
                                      8, width, height));
         gdk_pixbuf_scale(GetPixbuf(), bmp.GetPixbuf(),
                          0, 0, width, height,

-                         clipx, clipy, 
+                         clipx, clipy,

                          (double)newx/GetWidth(), (double)newy/GetHeight(),
                          GDK_INTERP_BILINEAR);
     }
     else
                          (double)newx/GetWidth(), (double)newy/GetHeight(),
                          GDK_INTERP_BILINEAR);
     }
     else

-#endif // __WXGTK20__

     {
         GdkImage *img = (GdkImage*) NULL;
         if (GetPixmap())
     {
         GdkImage *img = (GdkImage*) NULL;
         if (GetPixmap())


@@ -400,7 +395,7 @@ wxBitmap wxBitmap::Rescale( int clipx, int clipy, int clipwidth, int clipheight,
 
         int bpp = -1;
 
 
         int bpp = -1;
 

-        
+

         GdkGC *gc = NULL;
         GdkPixmap *dstpix = NULL;
         if (GetPixmap())
         GdkGC *gc = NULL;
         GdkPixmap *dstpix = NULL;
         if (GetPixmap())


@@ -417,7 +412,7 @@ wxBitmap wxBitmap::Rescale( int clipx, int clipy, int clipwidth, int clipheight,
 
         char *dst = NULL;
         long dstbyteperline = 0;
 
         char *dst = NULL;
         long dstbyteperline = 0;

-        
+

         if (GetBitmap())
         {
             bpp = 1;
         if (GetBitmap())
         {
             bpp = 1;


@@ -426,7 +421,7 @@ wxBitmap wxBitmap::Rescale( int clipx, int clipy, int clipwidth, int clipheight,
                 dstbyteperline++;
             dst = (char*) malloc(dstbyteperline*height);
         }
                 dstbyteperline++;
             dst = (char*) malloc(dstbyteperline*height);
         }

-                 
+

         // be careful to use the right scaling factor
         float scx = (float)M_BMPDATA->m_width/(float)newx;
         float scy = (float)M_BMPDATA->m_height/(float)newy;
         // be careful to use the right scaling factor
         float scx = (float)M_BMPDATA->m_width/(float)newx;
         float scy = (float)M_BMPDATA->m_height/(float)newy;


@@ -459,16 +454,16 @@ wxBitmap wxBitmap::Rescale( int clipx, int clipy, int clipwidth, int clipheight,
                     old_pixval = pixval;
                     old_x = x;
                 }
                     old_pixval = pixval;
                     old_x = x;
                 }

-                    
-                if (bpp == 1)
+
+                if ( dst )

                 {
                     if (!pixval)
                     {
                         char bit=1;
                 {
                     if (!pixval)
                     {
                         char bit=1;

-                        char shift = bit << w % 8;
+                        char shift = bit << (w % 8);

                         outbyte |= shift;
                     }
                         outbyte |= shift;
                     }

-                    
+

                     if ((w+1)%8==0)
                     {
                         dst[h*dstbyteperline+w/8] = outbyte;
                     if ((w+1)%8==0)
                     {
                         dst[h*dstbyteperline+w/8] = outbyte;


@@ -483,21 +478,21 @@ wxBitmap wxBitmap::Rescale( int clipx, int clipy, int clipwidth, int clipheight,
                     gdk_draw_point( dstpix, gc, w, h);
                 }
             }
                     gdk_draw_point( dstpix, gc, w, h);
                 }
             }

-        
+

             // do not forget the last byte
             // do not forget the last byte

-            if ((bpp == 1) && (width % 8 != 0))
+            if ( dst && (width % 8 != 0) )

                 dst[h*dstbyteperline+width/8] = outbyte;
         }
                 dst[h*dstbyteperline+width/8] = outbyte;
         }

-        
+

         gdk_image_destroy( img );
         if (gc) gdk_gc_unref( gc );
 
         gdk_image_destroy( img );
         if (gc) gdk_gc_unref( gc );
 

-        if (bpp == 1)
+        if ( dst )

         {
             bmp = wxBitmap( (const char *)dst, width, height, 1 );
             free( dst );
         }
         {
             bmp = wxBitmap( (const char *)dst, width, height, 1 );
             free( dst );
         }

-        
+

         if (GetMask())
         {
             dstbyteperline = width/8;
         if (GetMask())
         {
             dstbyteperline = width/8;


@@ -511,7 +506,7 @@ wxBitmap wxBitmap::Rescale( int clipx, int clipy, int clipwidth, int clipheight,
                 char outbyte = 0;
                 int old_x = -1;
                 guint32 old_pixval = 0;
                 char outbyte = 0;
                 int old_x = -1;
                 guint32 old_pixval = 0;

-        
+

                 for (int w = 0; w < width; w++)
                 {
                     guint32 pixval;
                 for (int w = 0; w < width; w++)
                 {
                     guint32 pixval;


@@ -524,21 +519,21 @@ wxBitmap wxBitmap::Rescale( int clipx, int clipy, int clipwidth, int clipheight,
                         old_pixval = pixval;
                         old_x = x;
                     }
                         old_pixval = pixval;
                         old_x = x;
                     }

-                    
+

                     if (pixval)
                     {
                         char bit=1;
                     if (pixval)
                     {
                         char bit=1;

-                        char shift = bit << w % 8;
+                        char shift = bit << (w % 8);

                         outbyte |= shift;
                     }
                         outbyte |= shift;
                     }

-                    
+

                     if ((w+1)%8 == 0)
                     {
                         dst[h*dstbyteperline+w/8] = outbyte;
                         outbyte = 0;
                     }
                 }
                     if ((w+1)%8 == 0)
                     {
                         dst[h*dstbyteperline+w/8] = outbyte;
                         outbyte = 0;
                     }
                 }

-            
+

                 // do not forget the last byte
                 if (width % 8 != 0)
                     dst[h*dstbyteperline+width/8] = outbyte;
                 // do not forget the last byte
                 if (width % 8 != 0)
                     dst[h*dstbyteperline+width/8] = outbyte;


@@ -554,20 +549,20 @@ wxBitmap wxBitmap::Rescale( int clipx, int clipy, int clipwidth, int clipheight,
         free( tablex );
         free( tabley );
     }
         free( tablex );
         free( tabley );
     }

-    
-    return bmp; 
+
+    return bmp;

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

-    wxCHECK_MSG( image.Ok(), FALSE, wxT("invalid image") )
-    wxCHECK_MSG( depth == -1 || depth == 1, FALSE, wxT("invalid bitmap depth") )
+    wxCHECK_MSG( image.Ok(), false, wxT("invalid image") );
+    wxCHECK_MSG( depth == -1 || depth == 1, false, wxT("invalid bitmap depth") );

 
     if (image.GetWidth() <= 0 || image.GetHeight() <= 0)
         return false;
 
     if (image.GetWidth() <= 0 || image.GetHeight() <= 0)
         return false;

-    
+

     m_refData = new wxBitmapRefData();
 
     if (depth == 1)
     m_refData = new wxBitmapRefData();
 
     if (depth == 1)


@@ -576,10 +571,9 @@ bool wxBitmap::CreateFromImage(const wxImage& image, int depth)
     }
     else
     {
     }
     else
     {

-#ifdef __WXGTK20__

         if (image.HasAlpha())
             return CreateFromImageAsPixbuf(image);
         if (image.HasAlpha())
             return CreateFromImageAsPixbuf(image);

-#endif
+

         return CreateFromImageAsPixmap(image);
     }
 }
         return CreateFromImageAsPixmap(image);
     }
 }


@@ -590,7 +584,7 @@ bool wxBitmap::CreateFromImageAsBitmap(const wxImage& img)
     // convert alpha channel to mask, if it is present:
     wxImage image(img);
     image.ConvertAlphaToMask();
     // convert alpha channel to mask, if it is present:
     wxImage image(img);
     image.ConvertAlphaToMask();

-    
+

     int width = image.GetWidth();
     int height = image.GetHeight();
 
     int width = image.GetWidth();
     int height = image.GetHeight();
 


@@ -683,14 +677,14 @@ bool wxBitmap::CreateFromImageAsBitmap(const wxImage& img)
 
     return true;
 }
 
     return true;
 }

-    
+

 // conversion to colour bitmap:
 bool wxBitmap::CreateFromImageAsPixmap(const wxImage& img)
 {
     // convert alpha channel to mask, if it is present:
     wxImage image(img);
     image.ConvertAlphaToMask();
 // conversion to colour bitmap:
 bool wxBitmap::CreateFromImageAsPixmap(const wxImage& img)
 {
     // convert alpha channel to mask, if it is present:
     wxImage image(img);
     image.ConvertAlphaToMask();

-    
+

     int width = image.GetWidth();
     int height = image.GetHeight();
 
     int width = image.GetWidth();
     int height = image.GetHeight();
 


@@ -719,12 +713,12 @@ bool wxBitmap::CreateFromImageAsPixmap(const wxImage& img)
     if (!image.HasMask() && (bpp > 12))
 #endif
     {
     if (!image.HasMask() && (bpp > 12))
 #endif
     {

-        static bool s_hasInitialized = FALSE;
+        static bool s_hasInitialized = false;

 
         if (!s_hasInitialized)
         {
             gdk_rgb_init();
 
         if (!s_hasInitialized)
         {
             gdk_rgb_init();

-            s_hasInitialized = TRUE;
+            s_hasInitialized = true;

         }
 
         GdkGC *gc = gdk_gc_new( GetPixmap() );
         }
 
         GdkGC *gc = gdk_gc_new( GetPixmap() );


@@ -738,7 +732,7 @@ bool wxBitmap::CreateFromImageAsPixmap(const wxImage& img)
                             width*3 );
 
         gdk_gc_unref( gc );
                             width*3 );
 
         gdk_gc_unref( gc );

-        return TRUE;
+        return true;

     }
 
     // Create picture image
     }
 
     // Create picture image


@@ -893,6 +887,7 @@ bool wxBitmap::CreateFromImageAsPixmap(const wxImage& img)
                         case GBR: pixel = (g << 16) | (b << 8) | r; break;
                     }
                     gdk_image_put_pixel( data_image, x, y, pixel );
                         case GBR: pixel = (g << 16) | (b << 8) | r; break;
                     }
                     gdk_image_put_pixel( data_image, x, y, pixel );

+                    break;

                 }
                 default: break;
             }
                 }
                 default: break;
             }


@@ -923,7 +918,6 @@ bool wxBitmap::CreateFromImageAsPixmap(const wxImage& img)
     return true;
 }
 
     return true;
 }
 

-#ifdef __WXGTK20__

 bool wxBitmap::CreateFromImageAsPixbuf(const wxImage& image)
 {
     int width = image.GetWidth();
 bool wxBitmap::CreateFromImageAsPixbuf(const wxImage& image)
 {
     int width = image.GetWidth();


@@ -940,17 +934,17 @@ bool wxBitmap::CreateFromImageAsPixbuf(const wxImage& image)
     wxASSERT( gdk_pixbuf_get_n_channels(pixbuf) == 4 );
     wxASSERT( gdk_pixbuf_get_width(pixbuf) == width );
     wxASSERT( gdk_pixbuf_get_height(pixbuf) == height );
     wxASSERT( gdk_pixbuf_get_n_channels(pixbuf) == 4 );
     wxASSERT( gdk_pixbuf_get_width(pixbuf) == width );
     wxASSERT( gdk_pixbuf_get_height(pixbuf) == height );

-    
+

     M_BMPDATA->m_pixbuf = pixbuf;
     SetHeight(height);
     SetWidth(width);
     SetDepth(wxTheApp->GetGdkVisual()->depth);
     M_BMPDATA->m_pixbuf = pixbuf;
     SetHeight(height);
     SetWidth(width);
     SetDepth(wxTheApp->GetGdkVisual()->depth);

- 
+

     // Copy the data:
     unsigned char *in = image.GetData();
     unsigned char *out = gdk_pixbuf_get_pixels(pixbuf);
     unsigned char *alpha = image.GetAlpha();
     // Copy the data:
     unsigned char *in = image.GetData();
     unsigned char *out = gdk_pixbuf_get_pixels(pixbuf);
     unsigned char *alpha = image.GetAlpha();

-    
+

     int rowinc = gdk_pixbuf_get_rowstride(pixbuf) - 4 * width;
 
     for (int y = 0; y < height; y++, out += rowinc)
     int rowinc = gdk_pixbuf_get_rowstride(pixbuf) - 4 * width;
 
     for (int y = 0; y < height; y++, out += rowinc)


@@ -963,17 +957,16 @@ bool wxBitmap::CreateFromImageAsPixbuf(const wxImage& image)
             out[3] = *alpha;
         }
     }
             out[3] = *alpha;
         }
     }

-    
+

     return true;
 }
     return true;
 }

-#endif // __WXGTK20__

 
 wxImage wxBitmap::ConvertToImage() const
 {
     wxImage image;
 
     wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
 
 wxImage wxBitmap::ConvertToImage() const
 {
     wxImage image;
 
     wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );

-    
+

     image.Create(GetWidth(), GetHeight());
     unsigned char *data = image.GetData();
 
     image.Create(GetWidth(), GetHeight());
     unsigned char *data = image.GetData();
 


@@ -983,15 +976,14 @@ wxImage wxBitmap::ConvertToImage() const
         return wxNullImage;
     }
 
         return wxNullImage;
     }
 

-#ifdef __WXGTK20__

     if (HasPixbuf())
     {
         GdkPixbuf *pixbuf = GetPixbuf();
         wxASSERT( gdk_pixbuf_get_has_alpha(pixbuf) );
     if (HasPixbuf())
     {
         GdkPixbuf *pixbuf = GetPixbuf();
         wxASSERT( gdk_pixbuf_get_has_alpha(pixbuf) );

-        
+

         int w = GetWidth();
         int h = GetHeight();
         int w = GetWidth();
         int h = GetHeight();

-        
+

         image.SetAlpha();
 
         unsigned char *alpha = image.GetAlpha();
         image.SetAlpha();
 
         unsigned char *alpha = image.GetAlpha();


@@ -1011,7 +1003,6 @@ wxImage wxBitmap::ConvertToImage() const
         }
     }
     else
         }
     }
     else

-#endif // __WXGTK20__

     {
         // the colour used as transparent one in wxImage and the one it is
         // replaced with when it really occurs in the bitmap
     {
         // the colour used as transparent one in wxImage and the one it is
         // replaced with when it really occurs in the bitmap


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


@@ -1152,13 +1143,7 @@ wxImage wxBitmap::ConvertToImage() const
     return image;
 }
 
     return image;
 }
 

-wxBitmap::wxBitmap( const wxBitmap& bmp )
-        : wxGDIObject()
-{
-    Ref( bmp );
-}
-
-wxBitmap::wxBitmap( const wxString &filename, int type )
+wxBitmap::wxBitmap( const wxString &filename, wxBitmapType type )

 {
     LoadFile( filename, type );
 }
 {
     LoadFile( filename, type );
 }


@@ -1189,14 +1174,6 @@ 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;


@@ -1209,12 +1186,10 @@ bool wxBitmap::operator != ( const wxBitmap& bmp ) const
 
 bool wxBitmap::Ok() const
 {
 
 bool wxBitmap::Ok() const
 {

-    return (m_refData != NULL) && 
+    return (m_refData != NULL) &&

            (
            (

-#ifdef __WXGTK20__

               M_BMPDATA->m_pixbuf ||
               M_BMPDATA->m_pixbuf ||

-#endif
-              M_BMPDATA->m_bitmap || M_BMPDATA->m_pixmap 
+              M_BMPDATA->m_bitmap || M_BMPDATA->m_pixmap

            );
 }
 
            );
 }
 


@@ -1258,7 +1233,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


@@ -1271,19 +1246,17 @@ wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const
     wxBitmap ret( rect.width, rect.height, M_BMPDATA->m_bpp );
     wxASSERT_MSG( ret.Ok(), wxT("GetSubBitmap error") );
 
     wxBitmap ret( rect.width, rect.height, M_BMPDATA->m_bpp );
     wxASSERT_MSG( ret.Ok(), wxT("GetSubBitmap error") );
 

-#ifdef __WXGTK20__

     if (HasPixbuf())
     {
         GdkPixbuf *pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB,
                                            gdk_pixbuf_get_has_alpha(GetPixbuf()),
     if (HasPixbuf())
     {
         GdkPixbuf *pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB,
                                            gdk_pixbuf_get_has_alpha(GetPixbuf()),

-                                           8, GetWidth(), GetHeight());
+                                           8, rect.width, rect.height);

         ret.SetPixbuf(pixbuf);
         gdk_pixbuf_copy_area(GetPixbuf(),
                              rect.x, rect.y, rect.width, rect.height,
                              pixbuf, 0, 0);
     }
     else
         ret.SetPixbuf(pixbuf);
         gdk_pixbuf_copy_area(GetPixbuf(),
                              rect.x, rect.y, rect.width, rect.height,
                              pixbuf, 0, 0);
     }
     else

-#endif // __WXGTK20__

     {
         if (ret.GetPixmap())
         {
     {
         if (ret.GetPixmap())
         {


@@ -1324,9 +1297,9 @@ wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const
     return ret;
 }
 
     return ret;
 }
 

-bool wxBitmap::SaveFile( const wxString &name, int type, wxPalette *WXUNUSED(palette) )
+bool wxBitmap::SaveFile( const wxString &name, wxBitmapType type, const wxPalette *WXUNUSED(palette) ) const

 {
 {

-    wxCHECK_MSG( Ok(), FALSE, wxT("invalid bitmap") );
+    wxCHECK_MSG( Ok(), false, wxT("invalid bitmap") );

 
     // Try to save the bitmap via wxImage handlers:
     {
 
     // Try to save the bitmap via wxImage handlers:
     {


@@ -1334,15 +1307,15 @@ bool wxBitmap::SaveFile( const wxString &name, int type, wxPalette *WXUNUSED(pal
         if (image.Ok()) return image.SaveFile( name, type );
     }
 
         if (image.Ok()) return image.SaveFile( name, type );
     }
 

-    return FALSE;
+    return false;

 }
 
 }
 

-bool wxBitmap::LoadFile( const wxString &name, int type )
+bool wxBitmap::LoadFile( const wxString &name, wxBitmapType type )

 {
     UnRef();
 
     if (!wxFileExists(name))
 {
     UnRef();
 
     if (!wxFileExists(name))

-        return FALSE;
+        return false;

 
     GdkVisual *visual = wxTheApp->GetGdkVisual();
 
 
     GdkVisual *visual = wxTheApp->GetGdkVisual();
 


@@ -1374,14 +1347,15 @@ bool wxBitmap::LoadFile( const wxString &name, int type )
     {
         wxImage image;
         if ( !image.LoadFile( name, type ) || !image.Ok() )
     {
         wxImage image;
         if ( !image.LoadFile( name, type ) || !image.Ok() )

-            return FALSE;
+            return false;

 
         *this = wxBitmap(image);
     }
 
 
         *this = wxBitmap(image);
     }
 

-    return TRUE;
+    return true;

 }
 
 }
 

+#if wxUSE_PALETTE

 wxPalette *wxBitmap::GetPalette() const
 {
     if (!Ok())
 wxPalette *wxBitmap::GetPalette() const
 {
     if (!Ok())


@@ -1390,6 +1364,12 @@ wxPalette *wxBitmap::GetPalette() const
     return M_BMPDATA->m_palette;
 }
 
     return M_BMPDATA->m_palette;
 }
 

+void wxBitmap::SetPalette(const wxPalette& WXUNUSED(palette))
+{
+    // TODO
+}
+#endif // wxUSE_PALETTE
+

 void wxBitmap::SetHeight( int height )
 {
     if (!m_refData)
 void wxBitmap::SetHeight( int height )
 {
     if (!m_refData)


@@ -1420,9 +1400,7 @@ void wxBitmap::SetPixmap( GdkPixmap *pixmap )
         m_refData = new wxBitmapRefData();
 
     M_BMPDATA->m_pixmap = pixmap;
         m_refData = new wxBitmapRefData();
 
     M_BMPDATA->m_pixmap = pixmap;

-#ifdef __WXGTK20__

     PurgeOtherRepresentations(Pixmap);
     PurgeOtherRepresentations(Pixmap);

-#endif

 }
 
 void wxBitmap::SetBitmap( GdkPixmap *bitmap )
 }
 
 void wxBitmap::SetBitmap( GdkPixmap *bitmap )


@@ -1431,25 +1409,23 @@ void wxBitmap::SetBitmap( GdkPixmap *bitmap )
         m_refData = new wxBitmapRefData();
 
     M_BMPDATA->m_bitmap = bitmap;
         m_refData = new wxBitmapRefData();
 
     M_BMPDATA->m_bitmap = bitmap;

-#ifdef __WXGTK20__

     PurgeOtherRepresentations(Pixmap);
     PurgeOtherRepresentations(Pixmap);

-#endif

 }
 
 GdkPixmap *wxBitmap::GetPixmap() const
 {
     wxCHECK_MSG( Ok(), (GdkPixmap *) NULL, wxT("invalid bitmap") );
 
 }
 
 GdkPixmap *wxBitmap::GetPixmap() const
 {
     wxCHECK_MSG( Ok(), (GdkPixmap *) NULL, wxT("invalid bitmap") );
 

-#ifdef __WXGTK20__

     // create the pixmap on the fly if we use Pixbuf representation:
     if (HasPixbuf() && !HasPixmap())
     {
     // create the pixmap on the fly if we use Pixbuf representation:
     if (HasPixbuf() && !HasPixmap())
     {

+        delete M_BMPDATA->m_mask;
+        M_BMPDATA->m_mask = new wxMask();

         gdk_pixbuf_render_pixmap_and_mask(M_BMPDATA->m_pixbuf,
                                           &M_BMPDATA->m_pixmap,
         gdk_pixbuf_render_pixmap_and_mask(M_BMPDATA->m_pixbuf,
                                           &M_BMPDATA->m_pixmap,

-                                          NULL /*mask*/,
+                                          &M_BMPDATA->m_mask->m_bitmap,

                                           128 /*threshold*/);
     }
                                           128 /*threshold*/);
     }

-#endif // __WXGTK20__

 
     return M_BMPDATA->m_pixmap;
 }
 
     return M_BMPDATA->m_pixmap;
 }


@@ -1468,7 +1444,6 @@ GdkBitmap *wxBitmap::GetBitmap() const
     return M_BMPDATA->m_bitmap;
 }
 
     return M_BMPDATA->m_bitmap;
 }
 

-#ifdef __WXGTK20__

 GdkPixbuf *wxBitmap::GetPixbuf() const
 {
     wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") );
 GdkPixbuf *wxBitmap::GetPixbuf() const
 {
     wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") );


@@ -1477,18 +1452,18 @@ GdkPixbuf *wxBitmap::GetPixbuf() const
     {
         int width = GetWidth();
         int height = GetHeight();
     {
         int width = GetWidth();
         int height = GetHeight();

-        
+

         GdkPixbuf *pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB,
                                            GetMask() != NULL,
                                            8, width, height);
         GdkPixbuf *pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB,
                                            GetMask() != NULL,
                                            8, width, height);

-        M_BMPDATA->m_pixbuf = 
+        M_BMPDATA->m_pixbuf =

             gdk_pixbuf_get_from_drawable(pixbuf, M_BMPDATA->m_pixmap, NULL,
                                          0, 0, 0, 0, width, height);
             gdk_pixbuf_get_from_drawable(pixbuf, M_BMPDATA->m_pixmap, NULL,
                                          0, 0, 0, 0, width, height);

-        
+

         // apply the mask to created pixbuf:
         if (M_BMPDATA->m_pixbuf && M_BMPDATA->m_mask)
         {
         // apply the mask to created pixbuf:
         if (M_BMPDATA->m_pixbuf && M_BMPDATA->m_mask)
         {

-            GdkPixbuf *pmask = 
+            GdkPixbuf *pmask =

                 gdk_pixbuf_get_from_drawable(NULL,
                                              M_BMPDATA->m_mask->GetBitmap(),
                                              NULL,
                 gdk_pixbuf_get_from_drawable(NULL,
                                              M_BMPDATA->m_mask->GetBitmap(),
                                              NULL,


@@ -1509,7 +1484,7 @@ GdkPixbuf *wxBitmap::GetPixbuf() const
                             bmp[3] = 0;
                     }
                 }
                             bmp[3] = 0;
                     }
                 }

-                    
+

                 gdk_pixbuf_unref(pmask);
             }
         }
                 gdk_pixbuf_unref(pmask);
             }
         }


@@ -1548,4 +1523,88 @@ void wxBitmap::PurgeOtherRepresentations(wxBitmap::Representation keep)
     }
 }
 
     }
 }
 

-#endif // __WXGTK20__
+void *wxBitmap::GetRawData(wxPixelDataBase& data, int bpp)
+{
+    if (bpp != 32)
+        return NULL;
+
+    GdkPixbuf *pixbuf = GetPixbuf();
+    if (!pixbuf)
+        return NULL;
+
+#if 0
+    if (gdk_pixbuf_get_has_alpha( pixbuf ))
+        wxPrintf( wxT("Has alpha\n") );
+    else
+        wxPrintf( wxT("No alpha.\n") );
+#endif
+
+    data.m_height = gdk_pixbuf_get_height( pixbuf );
+    data.m_width = gdk_pixbuf_get_width( pixbuf );
+    data.m_stride = gdk_pixbuf_get_rowstride( pixbuf );
+
+    return gdk_pixbuf_get_pixels( pixbuf );
+}
+
+void wxBitmap::UngetRawData(wxPixelDataBase& WXUNUSED(data))
+{
+}
+
+
+bool wxBitmap::HasAlpha() const
+{
+    return HasPixbuf();
+}
+
+void wxBitmap::UseAlpha()
+{
+    GetPixbuf();
+}
+
+//-----------------------------------------------------------------------------
+// wxBitmapHandler
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler,wxBitmapHandlerBase)
+
+wxBitmapHandler::~wxBitmapHandler()
+{
+}
+
+bool wxBitmapHandler::Create(wxBitmap * WXUNUSED(bitmap),
+                             void * WXUNUSED(data),
+                             long WXUNUSED(type),
+                             int WXUNUSED(width),
+                             int WXUNUSED(height),
+                             int WXUNUSED(depth))
+{
+    wxFAIL_MSG( _T("not implemented") );
+
+    return false;
+}
+
+bool wxBitmapHandler::LoadFile(wxBitmap * WXUNUSED(bitmap),
+                               const wxString& WXUNUSED(name),
+                               long WXUNUSED(flags),
+                               int WXUNUSED(desiredWidth),
+                               int WXUNUSED(desiredHeight))
+{
+    wxFAIL_MSG( _T("not implemented") );
+
+    return false;
+}
+
+bool wxBitmapHandler::SaveFile(const wxBitmap * WXUNUSED(bitmap),
+                               const wxString& WXUNUSED(name),
+                               int WXUNUSED(type),
+                               const wxPalette * WXUNUSED(palette))
+{
+    wxFAIL_MSG( _T("not implemented") );
+
+    return false;
+}
+
+/* static */ void wxBitmap::InitStandardHandlers()
+{
+    // TODO: Insert handler based on GdkPixbufs handler later
+}