Fix minor typo in wxDV_VERT_RULES documentation.

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

diff --git a/src/gtk/bitmap.cpp b/src/gtk/bitmap.cpp
index a50e8a8e26085d9ed8b0557747489be173b17741..1d8a6b5767de404c7d61089e46ee8ba4970d1816 100644 (file)
--- a/src/gtk/bitmap.cpp
+++ b/src/gtk/bitmap.cpp
@@ -21,11 +21,13 @@
 #include "wx/rawbmp.h"
 
 #include "wx/gtk/private/object.h"
 #include "wx/rawbmp.h"
 
 #include "wx/gtk/private/object.h"

+#include "wx/gtk/private.h"

 
 #include <gtk/gtk.h>
 
 extern GtkWidget *wxGetRootWindow();
 
 
 #include <gtk/gtk.h>
 
 extern GtkWidget *wxGetRootWindow();
 

+#ifndef __WXGTK3__

 static void PixmapToPixbuf(GdkPixmap* pixmap, GdkPixbuf* pixbuf, int w, int h)
 {
     gdk_pixbuf_get_from_drawable(pixbuf, pixmap, NULL, 0, 0, 0, 0, w, h);
 static void PixmapToPixbuf(GdkPixmap* pixmap, GdkPixbuf* pixbuf, int w, int h)
 {
     gdk_pixbuf_get_from_drawable(pixbuf, pixmap, NULL, 0, 0, 0, 0, w, h);


@@ -67,6 +69,7 @@ static void MaskToAlpha(GdkPixmap* mask, GdkPixbuf* pixbuf, int w, int h)
     }
     g_object_unref(mask_pixbuf);
 }
     }
     g_object_unref(mask_pixbuf);
 }

+#endif

 
 //-----------------------------------------------------------------------------
 // wxMask
 
 //-----------------------------------------------------------------------------
 // wxMask


@@ -81,6 +84,21 @@ wxMask::wxMask()
 
 wxMask::wxMask(const wxMask& mask)
 {
 
 wxMask::wxMask(const wxMask& mask)
 {

+#ifdef __WXGTK3__
+    m_bitmap = NULL;
+    if (mask.m_bitmap)
+    {
+        const int w = cairo_image_surface_get_width(mask.m_bitmap);
+        const int h = cairo_image_surface_get_height(mask.m_bitmap);
+        m_bitmap = cairo_image_surface_create(CAIRO_FORMAT_A8, w, h);
+        const guchar* src = cairo_image_surface_get_data(mask.m_bitmap);
+        guchar* dst = cairo_image_surface_get_data(m_bitmap);
+        const int stride = cairo_image_surface_get_stride(m_bitmap);
+        wxASSERT(stride == cairo_image_surface_get_stride(mask.m_bitmap));
+        memcpy(dst, src, stride * h);
+        cairo_surface_mark_dirty(m_bitmap);
+    }
+#else

     if ( !mask.m_bitmap )
     {
         m_bitmap = NULL;
     if ( !mask.m_bitmap )
     {
         m_bitmap = NULL;


@@ -94,6 +112,7 @@ wxMask::wxMask(const wxMask& mask)
 
     wxGtkObject<GdkGC> gc(gdk_gc_new(m_bitmap));
     gdk_draw_drawable(m_bitmap, gc, mask.m_bitmap, 0, 0, 0, 0, -1, -1);
 
     wxGtkObject<GdkGC> gc(gdk_gc_new(m_bitmap));
     gdk_draw_drawable(m_bitmap, gc, mask.m_bitmap, 0, 0, 0, 0, -1, -1);

+#endif

 }
 
 wxMask::wxMask( const wxBitmap& bitmap, const wxColour& colour )
 }
 
 wxMask::wxMask( const wxBitmap& bitmap, const wxColour& colour )


@@ -116,17 +135,36 @@ wxMask::wxMask( const wxBitmap& bitmap )
     InitFromMonoBitmap(bitmap);
 }
 
     InitFromMonoBitmap(bitmap);
 }
 

+#ifdef __WXGTK3__
+wxMask::wxMask(cairo_surface_t* bitmap)
+#else
+wxMask::wxMask(GdkPixmap* bitmap)
+#endif
+{
+    m_bitmap = bitmap;
+}
+

 wxMask::~wxMask()
 {
     if (m_bitmap)
 wxMask::~wxMask()
 {
     if (m_bitmap)

+    {
+#ifdef __WXGTK3__
+        cairo_surface_destroy(m_bitmap);
+#else

         g_object_unref (m_bitmap);
         g_object_unref (m_bitmap);

+#endif
+    }

 }
 
 void wxMask::FreeData()
 {
     if (m_bitmap)
     {
 }
 
 void wxMask::FreeData()
 {
     if (m_bitmap)
     {

+#ifdef __WXGTK3__
+        cairo_surface_destroy(m_bitmap);
+#else

         g_object_unref (m_bitmap);
         g_object_unref (m_bitmap);

+#endif

         m_bitmap = NULL;
     }
 }
         m_bitmap = NULL;
     }
 }


@@ -136,6 +174,29 @@ bool wxMask::InitFromColour(const wxBitmap& bitmap, const wxColour& colour)
     const int w = bitmap.GetWidth();
     const int h = bitmap.GetHeight();
 
     const int w = bitmap.GetWidth();
     const int h = bitmap.GetHeight();
 

+#ifdef __WXGTK3__
+    m_bitmap = cairo_image_surface_create(CAIRO_FORMAT_A8, w, h);
+    GdkPixbuf* pixbuf = bitmap.GetPixbufNoMask();
+    const guchar* src = gdk_pixbuf_get_pixels(pixbuf);
+    guchar* dst = cairo_image_surface_get_data(m_bitmap);
+    const int stride_src = gdk_pixbuf_get_rowstride(pixbuf);
+    const int stride_dst = cairo_image_surface_get_stride(m_bitmap);
+    const int src_inc = gdk_pixbuf_get_n_channels(pixbuf);
+    const guchar r = colour.Red();
+    const guchar g = colour.Green();
+    const guchar b = colour.Blue();
+    for (int j = 0; j < h; j++, src += stride_src, dst += stride_dst)
+    {
+        const guchar* s = src;
+        for (int i = 0; i < w; i++, s += src_inc)
+        {
+            dst[i] = 0xff;
+            if (s[0] == r && s[1] == g && s[2] == b)
+                dst[i] = 0;
+        }
+    }
+    cairo_surface_mark_dirty(m_bitmap);
+#else

     // create mask as XBM format bitmap
 
     // one bit per pixel, each row starts on a byte boundary
     // create mask as XBM format bitmap
 
     // one bit per pixel, each row starts on a byte boundary


@@ -187,6 +248,7 @@ bool wxMask::InitFromColour(const wxBitmap& bitmap, const wxColour& colour)
     }
     m_bitmap = gdk_bitmap_create_from_data(wxGetRootWindow()->window, (char*)out, w, h);
     delete[] out;
     }
     m_bitmap = gdk_bitmap_create_from_data(wxGetRootWindow()->window, (char*)out, w, h);
     delete[] out;

+#endif

     return true;
 }
 
     return true;
 }
 


@@ -196,6 +258,9 @@ bool wxMask::InitFromMonoBitmap(const wxBitmap& bitmap)
 
     wxCHECK_MSG( bitmap.GetDepth() == 1, false, wxT("Cannot create mask from colour bitmap") );
 
 
     wxCHECK_MSG( bitmap.GetDepth() == 1, false, wxT("Cannot create mask from colour bitmap") );
 

+#ifdef __WXGTK3__
+    InitFromColour(bitmap, *wxBLACK);
+#else

     m_bitmap = gdk_pixmap_new( wxGetRootWindow()->window, bitmap.GetWidth(), bitmap.GetHeight(), 1 );
 
     if (!m_bitmap) return false;
     m_bitmap = gdk_pixmap_new( wxGetRootWindow()->window, bitmap.GetWidth(), bitmap.GetHeight(), 1 );
 
     if (!m_bitmap) return false;


@@ -203,11 +268,56 @@ bool wxMask::InitFromMonoBitmap(const wxBitmap& bitmap)
     wxGtkObject<GdkGC> gc(gdk_gc_new( m_bitmap ));
     gdk_gc_set_function(gc, GDK_COPY_INVERT);
     gdk_draw_drawable(m_bitmap, gc, bitmap.GetPixmap(), 0, 0, 0, 0, bitmap.GetWidth(), bitmap.GetHeight());
     wxGtkObject<GdkGC> gc(gdk_gc_new( m_bitmap ));
     gdk_gc_set_function(gc, GDK_COPY_INVERT);
     gdk_draw_drawable(m_bitmap, gc, bitmap.GetPixmap(), 0, 0, 0, 0, bitmap.GetWidth(), bitmap.GetHeight());

+#endif

 
     return true;
 }
 
 
     return true;
 }
 

-GdkBitmap *wxMask::GetBitmap() const
+wxBitmap wxMask::GetBitmap() const
+{
+    wxBitmap bitmap;
+    if (m_bitmap)
+    {
+#ifdef __WXGTK3__
+        cairo_surface_t* mask = m_bitmap;
+        const int w = cairo_image_surface_get_width(mask);
+        const int h = cairo_image_surface_get_height(mask);
+        GdkPixbuf* pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, false, 8, w, h);
+        const guchar* src = cairo_image_surface_get_data(mask);
+        guchar* dst = gdk_pixbuf_get_pixels(pixbuf);
+        const int stride_src = cairo_image_surface_get_stride(mask);
+        const int stride_dst = gdk_pixbuf_get_rowstride(pixbuf);
+        for (int j = 0; j < h; j++, src += stride_src, dst += stride_dst)
+        {
+            guchar* d = dst;
+            for (int i = 0; i < w; i++, d += 3)
+            {
+                d[0] = src[i];
+                d[1] = src[i];
+                d[2] = src[i];
+            }
+        }
+        bitmap = wxBitmap(pixbuf, 1);
+#else
+        GdkPixmap* mask = m_bitmap;
+        int w, h;
+        gdk_drawable_get_size(mask, &w, &h);
+        GdkPixmap* pixmap = gdk_pixmap_new(mask, w, h, -1);
+        GdkGC* gc = gdk_gc_new(pixmap);
+        gdk_gc_set_function(gc, GDK_COPY_INVERT);
+        gdk_draw_drawable(pixmap, gc, mask, 0, 0, 0, 0, w, h);
+        g_object_unref(gc);
+        bitmap = wxBitmap(pixmap);
+#endif
+    }
+    return bitmap;
+}
+
+#ifdef __WXGTK3__
+wxMask::operator cairo_surface_t*() const
+#else
+wxMask::operator GdkPixmap*() const
+#endif

 {
     return m_bitmap;
 }
 {
     return m_bitmap;
 }


@@ -224,15 +334,22 @@ public:
 
     virtual bool IsOk() const;
 
 
     virtual bool IsOk() const;
 

+#ifdef __WXGTK3__
+    GdkPixbuf* m_pixbufMask;
+    GdkPixbuf* m_pixbufNoMask;
+    cairo_surface_t* m_surface;
+#else

     GdkPixmap      *m_pixmap;
     GdkPixbuf      *m_pixbuf;
     GdkPixmap      *m_pixmap;
     GdkPixbuf      *m_pixbuf;

+#endif

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

+#ifndef __WXGTK3__

     bool m_alphaRequested;
     bool m_alphaRequested;

+#endif

 
 

-private:

     // We don't provide a copy ctor as copying m_pixmap and m_pixbuf properly
     // is expensive and we don't want to do it implicitly (and possibly
     // accidentally). wxBitmap::CloneGDIRefData() which does need to do it does
     // We don't provide a copy ctor as copying m_pixmap and m_pixbuf properly
     // is expensive and we don't want to do it implicitly (and possibly
     // accidentally). wxBitmap::CloneGDIRefData() which does need to do it does


@@ -242,23 +359,43 @@ private:
 
 wxBitmapRefData::wxBitmapRefData(int width, int height, int depth)
 {
 
 wxBitmapRefData::wxBitmapRefData(int width, int height, int depth)
 {

+#ifdef __WXGTK3__
+    m_pixbufMask = NULL;
+    m_pixbufNoMask = NULL;
+    m_surface = NULL;
+#else

     m_pixmap = NULL;
     m_pixbuf = NULL;
     m_pixmap = NULL;
     m_pixbuf = NULL;

+#endif

     m_mask = NULL;
     m_width = width;
     m_height = height;
     m_bpp = depth;
     m_mask = NULL;
     m_width = width;
     m_height = height;
     m_bpp = depth;

+#ifdef __WXGTK3__
+    if (m_bpp != 1 && m_bpp != 32)
+        m_bpp = 24;
+#else

     if (m_bpp < 0)
         m_bpp = gdk_drawable_get_depth(wxGetRootWindow()->window);
     m_alphaRequested = depth == 32;
     if (m_bpp < 0)
         m_bpp = gdk_drawable_get_depth(wxGetRootWindow()->window);
     m_alphaRequested = depth == 32;

+#endif

 }
 
 wxBitmapRefData::~wxBitmapRefData()
 {
 }
 
 wxBitmapRefData::~wxBitmapRefData()
 {

+#ifdef __WXGTK3__
+    if (m_pixbufMask)
+        g_object_unref(m_pixbufMask);
+    if (m_pixbufNoMask)
+        g_object_unref(m_pixbufNoMask);
+    if (m_surface)
+        cairo_surface_destroy(m_surface);
+#else

     if (m_pixmap)
         g_object_unref (m_pixmap);
     if (m_pixbuf)
         g_object_unref (m_pixbuf);
     if (m_pixmap)
         g_object_unref (m_pixmap);
     if (m_pixbuf)
         g_object_unref (m_pixbuf);

+#endif

     delete m_mask;
 }
 
     delete m_mask;
 }
 


@@ -285,7 +422,30 @@ wxBitmap::wxBitmap(const char bits[], int width, int height, int depth)
     wxASSERT(depth == 1);
     if (width > 0 && height > 0 && depth == 1)
     {
     wxASSERT(depth == 1);
     if (width > 0 && height > 0 && depth == 1)
     {

-        SetPixmap(gdk_bitmap_create_from_data(wxGetRootWindow()->window, bits, width, height));
+        m_refData = new wxBitmapRefData(width, height, 1);
+#ifdef __WXGTK3__
+        GdkPixbuf* pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, false, 8, width, height);
+        M_BMPDATA->m_pixbufNoMask = pixbuf;
+        const char* src = bits;
+        guchar* dst = gdk_pixbuf_get_pixels(pixbuf);
+        const int stride_src = (width + 7) / 8;
+        const int rowinc_dst = gdk_pixbuf_get_rowstride(pixbuf) - 3 * width;
+        for (int j = 0; j < width; j++, src += stride_src, dst += rowinc_dst)
+        {
+            for (int i = 0; i < height; i++)
+            {
+                guchar c = 0xff;
+                if (src[i >> 3] & (1 << (i & 7)))
+                    c = 0;
+                *dst++ = c;
+                *dst++ = c;
+                *dst++ = c;
+            }
+        }
+#else
+        M_BMPDATA->m_pixmap = gdk_bitmap_create_from_data(
+            wxGetRootWindow()->window, bits, width, height);
+#endif

     }
 }
 
     }
 }
 


@@ -293,18 +453,68 @@ wxBitmap::wxBitmap(const char* const* bits)
 {
     wxCHECK2_MSG(bits != NULL, return, wxT("invalid bitmap data"));
 
 {
     wxCHECK2_MSG(bits != NULL, return, wxT("invalid bitmap data"));
 

+#if wxUSE_IMAGE
+    *this = wxBitmap(wxImage(bits));
+#elif defined __WXGTK3__
+    GdkPixbuf* pixbuf = gdk_pixbuf_new_from_xpm_data(const_cast<const char**>(bits));
+    if (pixbuf)
+    {
+        m_refData = new wxBitmapRefData(
+            gdk_pixbuf_get_width(pixbuf), gdk_pixbuf_get_height(pixbuf),
+            gdk_pixbuf_get_n_channels(pixbuf) * 8);
+        M_BMPDATA->m_pixbufNoMask = pixbuf;
+        wxASSERT(M_BMPDATA->m_bpp == 32 || !gdk_pixbuf_get_has_alpha(M_BMPDATA->m_pixbufNoMask));
+    }
+#else

     GdkBitmap* mask = NULL;
     GdkBitmap* mask = NULL;

-    SetPixmap(gdk_pixmap_create_from_xpm_d(wxGetRootWindow()->window, &mask, NULL, const_cast<char**>(bits)));
-    if (!M_BMPDATA)
-        return;
+    GdkPixmap* pixmap = gdk_pixmap_create_from_xpm_d(wxGetRootWindow()->window, &mask, NULL, const_cast<char**>(bits));
+    if (pixmap)
+    {
+        int width, height;
+        gdk_drawable_get_size(pixmap, &width, &height);
+        m_refData = new wxBitmapRefData(width, height, -1);
+        M_BMPDATA->m_pixmap = pixmap;
+        if (mask)
+        {
+            M_BMPDATA->m_mask = new wxMask(mask);
+        }
+    }
+#endif
+}

 
 

-    if (M_BMPDATA->m_pixmap != NULL && mask != NULL)
+wxBitmap::wxBitmap(GdkPixbuf* pixbuf, int depth)
+{
+    if (pixbuf)

     {
     {

-        M_BMPDATA->m_mask = new wxMask;
-        M_BMPDATA->m_mask->m_bitmap = mask;
+        if (depth != 1)
+            depth = gdk_pixbuf_get_n_channels(pixbuf) * 8;
+        wxBitmapRefData* bmpData = new wxBitmapRefData(
+            gdk_pixbuf_get_width(pixbuf), gdk_pixbuf_get_height(pixbuf),
+            depth);
+        m_refData = bmpData;
+#ifdef __WXGTK3__
+        bmpData->m_pixbufNoMask = pixbuf;
+#else
+        bmpData->m_pixbuf = pixbuf;
+#endif

     }
 }
 
     }
 }
 

+#ifndef __WXGTK3__
+wxBitmap::wxBitmap(GdkPixmap* pixmap)
+{
+    if (pixmap)
+    {
+        int w, h;
+        gdk_drawable_get_size(pixmap, &w, &h);
+        wxBitmapRefData* bmpData =
+            new wxBitmapRefData(w, h, gdk_drawable_get_depth(pixmap));
+        m_refData = bmpData;
+        bmpData->m_pixmap = pixmap;
+    }
+}
+#endif
+

 wxBitmap::~wxBitmap()
 {
 }
 wxBitmap::~wxBitmap()
 {
 }


@@ -317,24 +527,110 @@ bool wxBitmap::Create( int width, int height, int depth )
     return true;
 }
 
     return true;
 }
 

-#if wxUSE_IMAGE
+#ifdef __WXGTK3__
+static void CopyImageData(
+    guchar* dst, int dstChannels, int dstStride,
+    const guchar* src, int srcChannels, int srcStride,
+    int w, int h)
+{
+    if (dstChannels == srcChannels)
+    {
+        if (dstStride == srcStride)
+            memcpy(dst, src, size_t(dstStride) * h);
+        else
+        {
+            const int stride = dstStride < srcStride ? dstStride : srcStride;
+            for (int j = 0; j < h; j++, src += srcStride, dst += dstStride)
+                memcpy(dst, src, stride);
+        }
+    }
+    else
+    {
+        for (int j = 0; j < h; j++, src += srcStride, dst += dstStride)
+        {
+            guchar* d = dst;
+            const guchar* s = src;
+            if (dstChannels == 4)
+            {
+                for (int i = 0; i < w; i++, d += 4, s += 3)
+                {
+                    d[0] = s[0];
+                    d[1] = s[1];
+                    d[2] = s[2];
+                    d[3] = 0xff;
+                }
+            }
+            else
+            {
+                for (int i = 0; i < w; i++, d += 3, s += 4)
+                {
+                    d[0] = s[0];
+                    d[1] = s[1];
+                    d[2] = s[2];
+                }
+            }
+        }
+    }
+}
+#endif

 
 

-bool wxBitmap::CreateFromImage(const wxImage& image, int depth)
+#if wxUSE_IMAGE
+#ifdef __WXGTK3__
+wxBitmap::wxBitmap(const wxImage& image, int depth)

 {
 {

-    UnRef();
+    wxCHECK_RET(image.IsOk(), "invalid image");

 
 

-    wxCHECK_MSG( image.IsOk(), false, wxT("invalid image") );
-    wxCHECK_MSG( depth == -1 || depth == 1, false, wxT("invalid bitmap depth") );
+    const int w = image.GetWidth();
+    const int h = image.GetHeight();
+    const guchar* alpha = image.GetAlpha();
+    if (depth < 0)
+        depth = alpha ? 32 : 24;
+    else if (depth != 1 && depth != 32)
+        depth = 24;
+    wxBitmapRefData* bmpData = new wxBitmapRefData(w, h, depth);
+    m_refData = bmpData;
+    GdkPixbuf* pixbuf_dst = gdk_pixbuf_new(GDK_COLORSPACE_RGB, depth == 32, 8, w, h);
+    bmpData->m_pixbufNoMask = pixbuf_dst;
+    wxASSERT(bmpData->m_bpp == 32 || !gdk_pixbuf_get_has_alpha(bmpData->m_pixbufNoMask));
+    const guchar* src = image.GetData();

 
 

-    if (image.GetWidth() <= 0 || image.GetHeight() <= 0)
-        return false;
+    guchar* dst = gdk_pixbuf_get_pixels(pixbuf_dst);
+    const int dstStride = gdk_pixbuf_get_rowstride(pixbuf_dst);
+    CopyImageData(dst, gdk_pixbuf_get_n_channels(pixbuf_dst), dstStride, src, 3, 3 * w, w, h);

 
 

-    // create pixbuf if image has alpha and requested depth is compatible
-    if (image.HasAlpha() && (depth == -1 || depth == 32))
-        return CreateFromImageAsPixbuf(image);
+    if (depth == 32 && alpha)
+    {
+        for (int j = 0; j < h; j++, dst += dstStride)
+            for (int i = 0; i < w; i++)
+                dst[i * 4 + 3] = *alpha++;
+    }
+    if (image.HasMask())
+    {
+        const guchar r = image.GetMaskRed();
+        const guchar g = image.GetMaskGreen();
+        const guchar b = image.GetMaskBlue();
+        cairo_surface_t* surface = cairo_image_surface_create(CAIRO_FORMAT_A8, w, h);
+        const int stride = cairo_image_surface_get_stride(surface);
+        dst = cairo_image_surface_get_data(surface);
+        memset(dst, 0xff, stride * h);
+        for (int j = 0; j < h; j++, dst += stride)
+            for (int i = 0; i < w; i++, src += 3)
+                if (src[0] == r && src[1] == g && src[2] == b)
+                    dst[i] = 0;
+        cairo_surface_mark_dirty(surface);
+        bmpData->m_mask = new wxMask(surface);
+    }
+}
+#else
+wxBitmap::wxBitmap(const wxImage& image, int depth)
+{
+    wxCHECK_RET(image.IsOk(), "invalid image");

 
 

-    // otherwise create pixmap, if alpha is present it will be converted to mask
-    return CreateFromImageAsPixmap(image, depth);
+    if (depth == 32 || (depth == -1 && image.HasAlpha()))
+        CreateFromImageAsPixbuf(image);
+    else
+        // otherwise create pixmap, if alpha is present it will be converted to mask
+        CreateFromImageAsPixmap(image, depth);

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


@@ -412,9 +708,7 @@ bool wxBitmap::CreateFromImageAsPixmap(const wxImage& image, int depth)
                 bit_index = (bit_index + 7) & ~7u;
             }
         }
                 bit_index = (bit_index + 7) & ~7u;
             }
         }

-        wxMask* mask = new wxMask;
-        mask->m_bitmap = gdk_bitmap_create_from_data(M_BMPDATA->m_pixmap, (char*)out, w, h);
-        SetMask(mask);
+        SetMask(new wxMask(gdk_bitmap_create_from_data(M_BMPDATA->m_pixmap, (char*)out, w, h)));

         delete[] out;
     }
     return IsOk();
         delete[] out;
     }
     return IsOk();


@@ -422,8 +716,6 @@ bool wxBitmap::CreateFromImageAsPixmap(const wxImage& image, int depth)
 
 bool wxBitmap::CreateFromImageAsPixbuf(const wxImage& image)
 {
 
 bool wxBitmap::CreateFromImageAsPixbuf(const wxImage& image)
 {

-    wxASSERT(image.HasAlpha());
-

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


@@ -441,20 +733,84 @@ bool wxBitmap::CreateFromImageAsPixbuf(const wxImage& image)
 
     for (int y = 0; y < height; y++, out += rowpad)
     {
 
     for (int y = 0; y < height; y++, out += rowpad)
     {

-        for (int x = 0; x < width; x++, alpha++, out += 4, in += 3)
+        for (int x = 0; x < width; x++, out += 4, in += 3)

         {
             out[0] = in[0];
             out[1] = in[1];
             out[2] = in[2];
         {
             out[0] = in[0];
             out[1] = in[1];
             out[2] = in[2];

-            out[3] = *alpha;
+            if (alpha)
+                out[3] = *alpha++;

         }
     }
 
     return true;
 }
         }
     }
 
     return true;
 }

+#endif

 
 wxImage wxBitmap::ConvertToImage() const
 {
 
 wxImage wxBitmap::ConvertToImage() const
 {

+#ifdef __WXGTK3__
+    wxImage image;
+    wxCHECK_MSG(IsOk(), image, "invalid bitmap");
+    wxBitmapRefData* bmpData = M_BMPDATA;
+    const int w = bmpData->m_width;
+    const int h = bmpData->m_height;
+    image.Create(w, h, false);
+    guchar* dst = image.GetData();
+    GdkPixbuf* pixbuf_src = NULL;
+    if (bmpData->m_pixbufNoMask)
+        pixbuf_src = bmpData->m_pixbufNoMask;
+    else if (bmpData->m_surface)
+    {
+        pixbuf_src = gdk_pixbuf_get_from_surface(bmpData->m_surface, 0, 0, w, h);
+        bmpData->m_pixbufNoMask = pixbuf_src;
+        wxASSERT(bmpData->m_bpp == 32 || !gdk_pixbuf_get_has_alpha(bmpData->m_pixbufNoMask));
+    }
+    if (pixbuf_src)
+    {
+        const guchar* src = gdk_pixbuf_get_pixels(pixbuf_src);
+        const int srcStride = gdk_pixbuf_get_rowstride(pixbuf_src);
+        const int srcChannels = gdk_pixbuf_get_n_channels(pixbuf_src);
+        CopyImageData(dst, 3, 3 * w, src, srcChannels, srcStride, w, h);
+
+        if (srcChannels == 4)
+        {
+            image.SetAlpha();
+            guchar* alpha = image.GetAlpha();
+            for (int j = 0; j < h; j++, src += srcStride)
+            {
+                const guchar* s = src;
+                for (int i = 0; i < w; i++, s += 4)
+                    *alpha++ = s[3];
+            }
+        }
+    }
+    cairo_surface_t* maskSurf = NULL;
+    if (bmpData->m_mask)
+        maskSurf = *bmpData->m_mask;
+    if (maskSurf)
+    {
+        const guchar r = 1;
+        const guchar g = 2;
+        const guchar b = 3;
+        image.SetMaskColour(r, g, b);
+        wxASSERT(cairo_image_surface_get_format(maskSurf) == CAIRO_FORMAT_A8);
+        const int stride = cairo_image_surface_get_stride(maskSurf);
+        const guchar* src = cairo_image_surface_get_data(maskSurf);
+        for (int j = 0; j < h; j++, src += stride)
+        {
+            for (int i = 0; i < w; i++, dst += 3)
+                if (src[i] == 0)
+                {
+                    dst[0] = r;
+                    dst[1] = g;
+                    dst[2] = b;
+                }
+                else if (dst[0] == r && dst[1] == g && dst[2] == b)
+                    dst[2]--;
+        }
+    }
+#else

     wxCHECK_MSG( IsOk(), wxNullImage, wxT("invalid bitmap") );
 
     const int w = GetWidth();
     wxCHECK_MSG( IsOk(), wxNullImage, wxT("invalid bitmap") );
 
     const int w = GetWidth();


@@ -527,7 +883,7 @@ wxImage wxBitmap::ConvertToImage() const
         const int MASK_BLUE_REPLACEMENT = 2;
 
         image.SetMaskColour(MASK_RED, MASK_GREEN, MASK_BLUE);
         const int MASK_BLUE_REPLACEMENT = 2;
 
         image.SetMaskColour(MASK_RED, MASK_GREEN, MASK_BLUE);

-        GdkImage* image_mask = gdk_drawable_get_image(GetMask()->GetBitmap(), 0, 0, w, h);
+        GdkImage* image_mask = gdk_drawable_get_image(*GetMask(), 0, 0, w, h);

 
         for (int y = 0; y < h; y++)
         {
 
         for (int y = 0; y < h; y++)
         {


@@ -549,6 +905,7 @@ wxImage wxBitmap::ConvertToImage() const
         }
         g_object_unref(image_mask);
     }
         }
         g_object_unref(image_mask);
     }

+#endif

 
     return image;
 }
 
     return image;
 }


@@ -598,6 +955,26 @@ bool wxBitmap::CopyFromIcon(const wxIcon& icon)
     return IsOk();
 }
 
     return IsOk();
 }
 

+#ifdef __WXGTK3__
+static cairo_surface_t* GetSubSurface(cairo_surface_t* surface, const wxRect& rect)
+{
+    cairo_surface_flush(surface);
+    const cairo_format_t format = cairo_image_surface_get_format(surface);
+    int x = rect.x;
+    if (format != CAIRO_FORMAT_A8)
+        x *= 4;
+    cairo_surface_t* subSurface = cairo_image_surface_create(format, rect.width, rect.height);
+    const int srcStride = cairo_image_surface_get_stride(surface);
+    const int dstStride = cairo_image_surface_get_stride(subSurface);
+    const guchar* src = cairo_image_surface_get_data(surface) + rect.y * srcStride + x;
+    guchar* dst = cairo_image_surface_get_data(subSurface);
+    for (int j = 0; j < rect.height; j++, src += srcStride, dst += dstStride)
+        memcpy(dst, src, dstStride);
+    cairo_surface_mark_dirty(subSurface);
+    return subSurface;
+}
+#endif
+

 wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const
 {
     wxBitmap ret;
 wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const
 {
     wxBitmap ret;


@@ -616,6 +993,25 @@ wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const
     wxBitmapRefData * const newRef = new wxBitmapRefData(w, h, bmpData->m_bpp);
     ret.m_refData = newRef;
 
     wxBitmapRefData * const newRef = new wxBitmapRefData(w, h, bmpData->m_bpp);
     ret.m_refData = newRef;
 

+#ifdef __WXGTK3__
+    if (bmpData->m_pixbufNoMask)
+    {
+        GdkPixbuf* pixbuf = gdk_pixbuf_new_subpixbuf(bmpData->m_pixbufNoMask, rect.x, rect.y, w, h);
+        newRef->m_pixbufNoMask = gdk_pixbuf_copy(pixbuf);
+        wxASSERT(newRef->m_bpp == 32 || !gdk_pixbuf_get_has_alpha(newRef->m_pixbufNoMask));
+        g_object_unref(pixbuf);
+    }
+    else if (bmpData->m_surface)
+        newRef->m_surface = GetSubSurface(bmpData->m_surface, rect);
+
+    cairo_surface_t* maskSurf = NULL;
+    if (bmpData->m_mask)
+        maskSurf = *bmpData->m_mask;
+    if (maskSurf)
+    {
+        newRef->m_mask = new wxMask(GetSubSurface(maskSurf, rect));
+    }
+#else

     if (bmpData->m_pixbuf)
     {
         GdkPixbuf* pixbuf =
     if (bmpData->m_pixbuf)
     {
         GdkPixbuf* pixbuf =


@@ -631,16 +1027,19 @@ wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const
             newRef->m_pixmap, gc, bmpData->m_pixmap, rect.x, rect.y, 0, 0, w, h);
         g_object_unref(gc);
     }
             newRef->m_pixmap, gc, bmpData->m_pixmap, rect.x, rect.y, 0, 0, w, h);
         g_object_unref(gc);
     }

-    if (bmpData->m_mask && bmpData->m_mask->m_bitmap)
+    GdkPixmap* mask = NULL;
+    if (bmpData->m_mask)
+        mask = *bmpData->m_mask;
+    if (mask)

     {
     {

-        GdkPixmap* sub_mask = gdk_pixmap_new(bmpData->m_mask->m_bitmap, w, h, 1);
-        newRef->m_mask = new wxMask;
-        newRef->m_mask->m_bitmap = sub_mask;
+        GdkPixmap* sub_mask = gdk_pixmap_new(mask, w, h, 1);
+        newRef->m_mask = new wxMask(sub_mask);

         GdkGC* gc = gdk_gc_new(sub_mask);
         gdk_draw_drawable(
         GdkGC* gc = gdk_gc_new(sub_mask);
         gdk_draw_drawable(

-            sub_mask, gc, bmpData->m_mask->m_bitmap, rect.x, rect.y, 0, 0, w, h);
+            sub_mask, gc, mask, rect.x, rect.y, 0, 0, w, h);

         g_object_unref(gc);
     }
         g_object_unref(gc);
     }

+#endif

 
     return ret;
 }
 
     return ret;
 }


@@ -664,7 +1063,7 @@ bool wxBitmap::SaveFile( const wxString &name, wxBitmapType type, const wxPalett
         default: break;
     }
     return type_name &&
         default: break;
     }
     return type_name &&

-        gdk_pixbuf_save(GetPixbuf(), name.fn_str(), type_name, NULL, NULL);
+        gdk_pixbuf_save(GetPixbuf(), wxGTK_CONV_FN(name), type_name, NULL, NULL);

 }
 
 bool wxBitmap::LoadFile( const wxString &name, wxBitmapType type )
 }
 
 bool wxBitmap::LoadFile( const wxString &name, wxBitmapType type )


@@ -678,10 +1077,7 @@ bool wxBitmap::LoadFile( const wxString &name, wxBitmapType type )
     {
         wxUnusedVar(type); // The type is detected automatically by GDK.
 
     {
         wxUnusedVar(type); // The type is detected automatically by GDK.
 

-        UnRef();
-        GdkPixbuf* pixbuf = gdk_pixbuf_new_from_file(name.fn_str(), NULL);
-        if (pixbuf)
-            SetPixbuf(pixbuf);
+        *this = wxBitmap(gdk_pixbuf_new_from_file(wxGTK_CONV_FN(name), NULL));

     }
 
     return IsOk();
     }
 
     return IsOk();


@@ -717,6 +1113,7 @@ void wxBitmap::SetDepth( int depth )
     M_BMPDATA->m_bpp = depth;
 }
 
     M_BMPDATA->m_bpp = depth;
 }
 

+#ifndef __WXGTK3__

 void wxBitmap::SetPixmap( GdkPixmap *pixmap )
 {
     UnRef();
 void wxBitmap::SetPixmap( GdkPixmap *pixmap )
 {
     UnRef();


@@ -742,16 +1139,20 @@ GdkPixmap *wxBitmap::GetPixmap() const
 
     if (bmpData->m_pixbuf)
     {
 
     if (bmpData->m_pixbuf)
     {

+        GdkPixmap* pixmap = NULL;

         GdkPixmap** mask_pixmap = NULL;
         if (gdk_pixbuf_get_has_alpha(bmpData->m_pixbuf))
         {
             // make new mask from alpha
         GdkPixmap** mask_pixmap = NULL;
         if (gdk_pixbuf_get_has_alpha(bmpData->m_pixbuf))
         {
             // make new mask from alpha

-            delete bmpData->m_mask;
-            bmpData->m_mask = new wxMask;
-            mask_pixmap = &bmpData->m_mask->m_bitmap;
+            mask_pixmap = &pixmap;

         }
         gdk_pixbuf_render_pixmap_and_mask(
             bmpData->m_pixbuf, &bmpData->m_pixmap, mask_pixmap, 128);
         }
         gdk_pixbuf_render_pixmap_and_mask(
             bmpData->m_pixbuf, &bmpData->m_pixmap, mask_pixmap, 128);

+        if (pixmap)
+        {
+            delete bmpData->m_mask;
+            bmpData->m_mask = new wxMask(pixmap);
+        }

     }
     else
     {
     }
     else
     {


@@ -767,12 +1168,185 @@ bool wxBitmap::HasPixmap() const
 
     return M_BMPDATA->m_pixmap != NULL;
 }
 
     return M_BMPDATA->m_pixmap != NULL;
 }

+#endif
+
+#ifdef __WXGTK3__
+GdkPixbuf* wxBitmap::GetPixbufNoMask() const
+{
+    wxCHECK_MSG(IsOk(), NULL, "invalid bitmap");
+
+    wxBitmapRefData* bmpData = M_BMPDATA;
+    GdkPixbuf* pixbuf = bmpData->m_pixbufNoMask;
+    if (pixbuf)
+        return pixbuf;
+
+    const int w = bmpData->m_width;
+    const int h = bmpData->m_height;
+    if (bmpData->m_surface)
+        pixbuf = gdk_pixbuf_get_from_surface(bmpData->m_surface, 0, 0, w, h);
+    else
+        pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, bmpData->m_bpp == 32, 8, w, h);
+    bmpData->m_pixbufNoMask = pixbuf;
+    wxASSERT(bmpData->m_bpp == 32 || !gdk_pixbuf_get_has_alpha(bmpData->m_pixbufNoMask));
+
+    return pixbuf;
+}
+
+// helper to set up a simulated depth 1 surface
+static void SetSourceSurface1(const wxBitmapRefData* bmpData, cairo_t* cr, int x, int y, const wxColour* fg, const wxColour* bg)
+{
+    GdkPixbuf* pixbuf = gdk_pixbuf_copy(bmpData->m_pixbufNoMask);
+    const int w = bmpData->m_width;
+    const int h = bmpData->m_height;
+    const int stride = gdk_pixbuf_get_rowstride(pixbuf);
+    const int channels = gdk_pixbuf_get_n_channels(pixbuf);
+    guchar* dst = gdk_pixbuf_get_pixels(pixbuf);
+    guchar fg_r = 0, fg_g = 0, fg_b = 0;
+    if (fg && fg->IsOk())
+    {
+        fg_r = fg->Red();
+        fg_g = fg->Green();
+        fg_b = fg->Blue();
+    }
+    guchar bg_r = 255, bg_g = 255, bg_b = 255;
+    if (bg && bg->IsOk())
+    {
+        bg_r = bg->Red();
+        bg_g = bg->Green();
+        bg_b = bg->Blue();
+    }
+    for (int j = 0; j < h; j++, dst += stride)
+    {
+        guchar* d = dst;
+        for (int i = 0; i < w; i++, d += channels)
+            if (d[0])
+            {
+                d[0] = bg_r;
+                d[1] = bg_g;
+                d[2] = bg_b;
+            }
+            else
+            {
+                d[0] = fg_r;
+                d[1] = fg_g;
+                d[2] = fg_b;
+            }
+    }
+    gdk_cairo_set_source_pixbuf(cr, pixbuf, x, y);
+    g_object_unref(pixbuf);
+}
+
+void wxBitmap::SetSourceSurface(cairo_t* cr, int x, int y, const wxColour* fg, const wxColour* bg) const
+{
+    wxBitmapRefData* bmpData = M_BMPDATA;
+    if (bmpData->m_surface)
+    {
+        cairo_set_source_surface(cr, bmpData->m_surface, x, y);
+        return;
+    }
+    wxCHECK_RET(bmpData->m_pixbufNoMask, "no bitmap data");
+    if (bmpData->m_bpp == 1)
+        SetSourceSurface1(bmpData, cr, x, y, fg, bg);
+    else
+    {
+        gdk_cairo_set_source_pixbuf(cr, bmpData->m_pixbufNoMask, x, y);
+        cairo_pattern_get_surface(cairo_get_source(cr), &bmpData->m_surface);
+        cairo_surface_reference(bmpData->m_surface);
+    }
+}
+
+cairo_t* wxBitmap::CairoCreate() const
+{
+    wxCHECK_MSG(IsOk(), NULL, "invalid bitmap");
+
+    wxBitmapRefData* bmpData = M_BMPDATA;
+    cairo_t* cr;
+    if (bmpData->m_surface)
+        cr = cairo_create(bmpData->m_surface);
+    else
+    {
+        GdkPixbuf* pixbuf = bmpData->m_pixbufNoMask;
+        const bool useAlpha = bmpData->m_bpp == 32 || (pixbuf && gdk_pixbuf_get_has_alpha(pixbuf));
+        bmpData->m_surface = cairo_image_surface_create(
+            useAlpha ? CAIRO_FORMAT_ARGB32 : CAIRO_FORMAT_RGB24,
+            bmpData->m_width, bmpData->m_height);
+        cr = cairo_create(bmpData->m_surface);
+        if (pixbuf)
+        {
+            gdk_cairo_set_source_pixbuf(cr, pixbuf, 0, 0);
+            cairo_paint(cr);
+            cairo_set_source_rgb(cr, 0, 0, 0);
+        }
+    }
+    if (bmpData->m_pixbufNoMask)
+    {
+        g_object_unref(bmpData->m_pixbufNoMask);
+        bmpData->m_pixbufNoMask = NULL;
+    }
+    if (bmpData->m_pixbufMask)
+    {
+        g_object_unref(bmpData->m_pixbufMask);
+        bmpData->m_pixbufMask = NULL;
+    }
+    wxASSERT(cr && cairo_status(cr) == 0);
+    return cr;
+}
+
+void wxBitmap::Draw(cairo_t* cr, int x, int y, bool useMask, const wxColour* fg, const wxColour* bg) const
+{
+    wxCHECK_RET(IsOk(), "invalid bitmap");
+
+    wxBitmapRefData* bmpData = M_BMPDATA;
+    SetSourceSurface(cr, x, y, fg, bg);
+    cairo_pattern_set_filter(cairo_get_source(cr), CAIRO_FILTER_NEAREST);
+    cairo_surface_t* mask = NULL;
+    if (useMask && bmpData->m_mask)
+        mask = *bmpData->m_mask;
+    if (mask)
+        cairo_mask_surface(cr, mask, x, y);
+    else
+        cairo_paint(cr);
+}
+#endif

 
 GdkPixbuf *wxBitmap::GetPixbuf() const
 {
     wxCHECK_MSG( IsOk(), NULL, wxT("invalid bitmap") );
 
     wxBitmapRefData* bmpData = M_BMPDATA;
 
 GdkPixbuf *wxBitmap::GetPixbuf() const
 {
     wxCHECK_MSG( IsOk(), NULL, wxT("invalid bitmap") );
 
     wxBitmapRefData* bmpData = M_BMPDATA;

+#ifdef __WXGTK3__
+    if (bmpData->m_pixbufMask)
+        return bmpData->m_pixbufMask;
+
+    if (bmpData->m_pixbufNoMask == NULL)
+        GetPixbufNoMask();
+    cairo_surface_t* mask = NULL;
+    if (bmpData->m_mask)
+        mask = *bmpData->m_mask;
+    if (mask == NULL)
+        return bmpData->m_pixbufNoMask;
+
+    const int w = bmpData->m_width;
+    const int h = bmpData->m_height;
+    bmpData->m_pixbufMask = gdk_pixbuf_new(GDK_COLORSPACE_RGB, true, 8, w, h);
+
+    guchar* dst = gdk_pixbuf_get_pixels(bmpData->m_pixbufMask);
+    const int dstStride = gdk_pixbuf_get_rowstride(bmpData->m_pixbufMask);
+    CopyImageData(dst, 4, dstStride,
+        gdk_pixbuf_get_pixels(bmpData->m_pixbufNoMask),
+        gdk_pixbuf_get_n_channels(bmpData->m_pixbufNoMask),
+        gdk_pixbuf_get_rowstride(bmpData->m_pixbufNoMask),
+        w, h);
+
+    const guchar* src = cairo_image_surface_get_data(mask);
+    const int srcStride = cairo_image_surface_get_stride(mask);
+    for (int j = 0; j < h; j++, src += srcStride, dst += dstStride)
+        for (int i = 0; i < w; i++)
+            if (src[i] == 0)
+                dst[i * 4 + 3] = 0;
+
+    return bmpData->m_pixbufMask;
+#else

     if (bmpData->m_pixbuf)
         return bmpData->m_pixbuf;
 
     if (bmpData->m_pixbuf)
         return bmpData->m_pixbuf;
 


@@ -780,7 +1354,7 @@ GdkPixbuf *wxBitmap::GetPixbuf() const
     const int h = bmpData->m_height;
     GdkPixmap* mask = NULL;
     if (bmpData->m_mask)
     const int h = bmpData->m_height;
     GdkPixmap* mask = NULL;
     if (bmpData->m_mask)

-        mask = bmpData->m_mask->m_bitmap;
+        mask = *bmpData->m_mask;

     const bool useAlpha = bmpData->m_alphaRequested || mask;
     bmpData->m_pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, useAlpha, 8, w, h);
     if (bmpData->m_pixmap)
     const bool useAlpha = bmpData->m_alphaRequested || mask;
     bmpData->m_pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, useAlpha, 8, w, h);
     if (bmpData->m_pixmap)


@@ -788,8 +1362,10 @@ GdkPixbuf *wxBitmap::GetPixbuf() const
     if (mask)
         MaskToAlpha(mask, bmpData->m_pixbuf, w, h);
     return bmpData->m_pixbuf;
     if (mask)
         MaskToAlpha(mask, bmpData->m_pixbuf, w, h);
     return bmpData->m_pixbuf;

+#endif

 }
 
 }
 

+#ifndef __WXGTK3__

 bool wxBitmap::HasPixbuf() const
 {
     wxCHECK_MSG( IsOk(), false, wxT("invalid bitmap") );
 bool wxBitmap::HasPixbuf() const
 {
     wxCHECK_MSG( IsOk(), false, wxT("invalid bitmap") );


@@ -797,22 +1373,6 @@ bool wxBitmap::HasPixbuf() const
     return M_BMPDATA->m_pixbuf != NULL;
 }
 
     return M_BMPDATA->m_pixbuf != NULL;
 }
 

-void wxBitmap::SetPixbuf(GdkPixbuf* pixbuf)
-{
-    UnRef();
-
-    if (!pixbuf)
-        return;
-
-    int depth = -1;
-    if (gdk_pixbuf_get_has_alpha(pixbuf))
-        depth = 32;
-    m_refData = new wxBitmapRefData(
-        gdk_pixbuf_get_width(pixbuf), gdk_pixbuf_get_height(pixbuf), depth);
-
-    M_BMPDATA->m_pixbuf = pixbuf;
-}
-

 void wxBitmap::PurgeOtherRepresentations(wxBitmap::Representation keep)
 {
     if (keep == Pixmap && HasPixbuf())
 void wxBitmap::PurgeOtherRepresentations(wxBitmap::Representation keep)
 {
     if (keep == Pixmap && HasPixbuf())


@@ -826,11 +1386,33 @@ void wxBitmap::PurgeOtherRepresentations(wxBitmap::Representation keep)
         M_BMPDATA->m_pixmap = NULL;
     }
 }
         M_BMPDATA->m_pixmap = NULL;
     }
 }

+#endif

 
 #ifdef wxHAS_RAW_BITMAP
 void *wxBitmap::GetRawData(wxPixelDataBase& data, int bpp)
 {
     void* bits = NULL;
 
 #ifdef wxHAS_RAW_BITMAP
 void *wxBitmap::GetRawData(wxPixelDataBase& data, int bpp)
 {
     void* bits = NULL;

+#ifdef __WXGTK3__
+    GdkPixbuf* pixbuf = GetPixbufNoMask();
+    if ((bpp == 32) == (gdk_pixbuf_get_has_alpha(pixbuf) != 0))
+    {
+        bits = gdk_pixbuf_get_pixels(pixbuf);
+        wxBitmapRefData* bmpData = M_BMPDATA;
+        data.m_width = bmpData->m_width;
+        data.m_height = bmpData->m_height;
+        data.m_stride = gdk_pixbuf_get_rowstride(pixbuf);
+        if (bmpData->m_pixbufMask)
+        {
+            g_object_unref(bmpData->m_pixbufMask);
+            bmpData->m_pixbufMask = NULL;
+        }
+        if (bmpData->m_surface)
+        {
+            cairo_surface_destroy(bmpData->m_surface);
+            bmpData->m_surface = NULL;
+        }
+    }
+#else

     GdkPixbuf *pixbuf = GetPixbuf();
     const bool hasAlpha = HasAlpha();
 
     GdkPixbuf *pixbuf = GetPixbuf();
     const bool hasAlpha = HasAlpha();
 


@@ -842,6 +1424,7 @@ void *wxBitmap::GetRawData(wxPixelDataBase& data, int bpp)
         data.m_stride = gdk_pixbuf_get_rowstride( pixbuf );
         bits = gdk_pixbuf_get_pixels(pixbuf);
     }
         data.m_stride = gdk_pixbuf_get_rowstride( pixbuf );
         bits = gdk_pixbuf_get_pixels(pixbuf);
     }

+#endif

     return bits;
 }
 
     return bits;
 }
 


@@ -853,8 +1436,12 @@ void wxBitmap::UngetRawData(wxPixelDataBase& WXUNUSED(data))
 bool wxBitmap::HasAlpha() const
 {
     const wxBitmapRefData* bmpData = M_BMPDATA;
 bool wxBitmap::HasAlpha() const
 {
     const wxBitmapRefData* bmpData = M_BMPDATA;

+#ifdef __WXGTK3__
+    return bmpData && bmpData->m_bpp == 32;
+#else

     return bmpData && (bmpData->m_alphaRequested ||
         (bmpData->m_pixbuf && gdk_pixbuf_get_has_alpha(bmpData->m_pixbuf)));
     return bmpData && (bmpData->m_alphaRequested ||
         (bmpData->m_pixbuf && gdk_pixbuf_get_has_alpha(bmpData->m_pixbuf)));

+#endif

 }
 
 wxGDIRefData* wxBitmap::CreateGDIRefData() const
 }
 
 wxGDIRefData* wxBitmap::CreateGDIRefData() const


@@ -868,6 +1455,25 @@ wxGDIRefData* wxBitmap::CloneGDIRefData(const wxGDIRefData* data) const
     wxBitmapRefData * const newRef = new wxBitmapRefData(oldRef->m_width,
                                                          oldRef->m_height,
                                                          oldRef->m_bpp);
     wxBitmapRefData * const newRef = new wxBitmapRefData(oldRef->m_width,
                                                          oldRef->m_height,
                                                          oldRef->m_bpp);

+#ifdef __WXGTK3__
+    if (oldRef->m_pixbufNoMask)
+        newRef->m_pixbufNoMask = gdk_pixbuf_copy(oldRef->m_pixbufNoMask);
+    if (oldRef->m_surface)
+    {
+        const int w = oldRef->m_width;
+        const int h = oldRef->m_height;
+        cairo_surface_t* surface = cairo_image_surface_create(
+            cairo_image_surface_get_format(oldRef->m_surface), w, h);
+        newRef->m_surface = surface;
+        cairo_surface_flush(oldRef->m_surface);
+        const guchar* src = cairo_image_surface_get_data(oldRef->m_surface);
+        guchar* dst = cairo_image_surface_get_data(surface);
+        const int stride = cairo_image_surface_get_stride(surface);
+        wxASSERT(stride == cairo_image_surface_get_stride(oldRef->m_surface));
+        memcpy(dst, src, stride * h);
+        cairo_surface_mark_dirty(surface);
+    }
+#else

     if (oldRef->m_pixmap != NULL)
     {
         newRef->m_pixmap = gdk_pixmap_new(
     if (oldRef->m_pixmap != NULL)
     {
         newRef->m_pixmap = gdk_pixmap_new(


@@ -882,6 +1488,7 @@ wxGDIRefData* wxBitmap::CloneGDIRefData(const wxGDIRefData* data) const
     {
         newRef->m_pixbuf = gdk_pixbuf_copy(oldRef->m_pixbuf);
     }
     {
         newRef->m_pixbuf = gdk_pixbuf_copy(oldRef->m_pixbuf);
     }

+#endif

     if (oldRef->m_mask != NULL)
     {
         newRef->m_mask = new wxMask(*oldRef->m_mask);
     if (oldRef->m_mask != NULL)
     {
         newRef->m_mask = new wxMask(*oldRef->m_mask);