corrected off by 1 error in cMB2WC() call (thanks valgrind)

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

diff --git a/src/gtk/bitmap.cpp b/src/gtk/bitmap.cpp
index d459bdbce717368ab18fdbc7b4f5ff8e1792b9a4..e5f2b669d15636cd21817378bbd05095efeac93d 100644 (file)
--- a/src/gtk/bitmap.cpp
+++ b/src/gtk/bitmap.cpp
@@ -304,180 +304,67 @@ wxBitmap wxBitmap::Rescale(int clipx, int clipy, int clipwidth, int clipheight,
 
     wxCHECK_MSG(Ok(), bmp, wxT("invalid bitmap"));
 
 
     wxCHECK_MSG(Ok(), bmp, wxT("invalid bitmap"));
 

-    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);
 

-    // scale pixbuf if available and it has alpha or there is no mask
-    if (M_BMPDATA->m_pixbuf != NULL && (
-        M_BMPDATA->m_mask == NULL || gdk_pixbuf_get_has_alpha(M_BMPDATA->m_pixbuf)))
-    {
-        bmp.SetPixbuf(gdk_pixbuf_new(GDK_COLORSPACE_RGB,
-                                     gdk_pixbuf_get_has_alpha(M_BMPDATA->m_pixbuf),
-                                     8, width, height), M_BMPDATA->m_bpp);
-        gdk_pixbuf_scale(M_BMPDATA->m_pixbuf, bmp.GetPixbuf(),
-                         0, 0, width, height,
-                         clipx, clipy,
-                         (double)newx/GetWidth(), (double)newy/GetHeight(),
-                         GDK_INTERP_BILINEAR);
-    }
-    else
-    {
-        GdkImage* img = gdk_drawable_get_image(
-            M_BMPDATA->m_pixmap, 0, 0, M_BMPDATA->m_width, M_BMPDATA->m_height);
-
-        wxCHECK_MSG(img, bmp, wxT("couldn't create image"));
-
-        GdkGC *gc = NULL;
-        GdkPixmap *dstpix = NULL;
-        char *dst = NULL;
-        long dstbyteperline = 0;
-
-        if (GetDepth() != 1)
-        {
-            bmp.Create(width, height, gdk_drawable_get_depth(M_BMPDATA->m_pixmap));
-            dstpix = bmp.GetPixmap();
-            gc = gdk_gc_new( dstpix );
-        }
-        else
-        {
-            dstbyteperline = (width + 7) / 8;
-            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;
-        // prepare accel-tables
-        int *tablex = (int *)calloc(width,sizeof(int));
-        int *tabley = (int *)calloc(height,sizeof(int));
-
-        // accel table filled with clipped values
-        for (int x = 0; x < width; x++)
-            tablex[x] = (int) (scx * (x+clipx));
-        for (int y = 0; y < height; y++)
-            tabley[y] = (int) (scy * (y+clipy));
-
-        // Main rescaling routine starts here
-        for (int h = 0; h < height; h++)
-        {
-            char outbyte = 0;
-            int old_x = -1;
-            guint32 old_pixval = 0;
-
-            for (int w = 0; w < width; w++)
-            {
-                guint32 pixval;
-                int x = tablex[w];
-                if (x == old_x)
-                    pixval = old_pixval;
-                else
-                {
-                    pixval = gdk_image_get_pixel( img, x, tabley[h] );
-                    old_pixval = pixval;
-                    old_x = x;
-                }
-
-                if ( dst )
-                {
-                    if (pixval)
-                    {
-                        char bit=1;
-                        char shift = bit << (w % 8);
-                        outbyte |= shift;
-                    }
-
-                    if ((w+1)%8==0)
-                    {
-                        dst[h*dstbyteperline+w/8] = outbyte;
-                        outbyte = 0;
-                    }
-                }
-                else
-                {
-                    GdkColor col;
-                    col.pixel = pixval;
-                    gdk_gc_set_foreground( gc, &col );
-                    gdk_draw_point( dstpix, gc, w, h);
-                }
-            }
-
-            // do not forget the last byte
-            if ( dst && (width % 8 != 0) )
-                dst[h*dstbyteperline+width/8] = outbyte;
-        }
+    const double scale_x = double(newx) / M_BMPDATA->m_width;
+    const double scale_y = double(newy) / M_BMPDATA->m_height;

 
 

-        g_object_unref (img);
-        if (gc) g_object_unref (gc);
+    // Converting to pixbuf, scaling with gdk_pixbuf_scale, and converting
+    // back, is faster than scaling pixmap ourselves.

 
 

-        if ( dst )
-        {
-            bmp = wxBitmap(dst, width, height, 1);
-            free( dst );
-        }
+    // use pixbuf if already available,
+    // otherwise create temporary pixbuf from pixmap
+    GdkPixbuf* pixbuf = M_BMPDATA->m_pixbuf;
+    if (pixbuf)
+        g_object_ref(pixbuf);
+    else
+        pixbuf = gdk_pixbuf_get_from_drawable(
+            NULL, M_BMPDATA->m_pixmap, NULL,
+            0, 0, 0, 0, M_BMPDATA->m_width, M_BMPDATA->m_height);

 
 

-        if (GetMask())
-        {
-            dstbyteperline = (width + 7) / 8;
-            dst = (char*) malloc(dstbyteperline*height);
-            img = gdk_drawable_get_image(GetMask()->GetBitmap(), 0, 0, GetWidth(), GetHeight());
+    // new pixbuf for scaled wxBitmap
+    GdkPixbuf* pixbuf_scaled = gdk_pixbuf_new(
+        GDK_COLORSPACE_RGB, gdk_pixbuf_get_has_alpha(pixbuf), 8, width, height);

 
 

-            for (int h = 0; h < height; h++)
-            {
-                char outbyte = 0;
-                int old_x = -1;
-                guint32 old_pixval = 0;
+    // GDK_INTERP_NEAREST is the lowest-quality method for continuous-tone
+    // images, but the only one which preserves sharp edges
+    gdk_pixbuf_scale(
+        pixbuf, pixbuf_scaled,
+        0, 0, width, height, -clipx, -clipy, scale_x, scale_y,
+        GDK_INTERP_NEAREST);

 
 

-                for (int w = 0; w < width; w++)
-                {
-                    guint32 pixval;
-                    int x = tablex[w];
-                    if (x == old_x)
-                        pixval = old_pixval;
-                    else
-                    {
-                        pixval = gdk_image_get_pixel( img, x, tabley[h] );
-                        old_pixval = pixval;
-                        old_x = x;
-                    }
+    g_object_unref(pixbuf);
+    bmp.SetPixbuf(pixbuf_scaled, M_BMPDATA->m_bpp);

 
 

-                    if (pixval)
-                    {
-                        char bit=1;
-                        char shift = bit << (w % 8);
-                        outbyte |= shift;
-                    }
+    if (M_BMPDATA->m_mask)
+    {
+        pixbuf = gdk_pixbuf_get_from_drawable(
+            NULL, M_BMPDATA->m_mask->m_bitmap, NULL,
+            0, 0, 0, 0, M_BMPDATA->m_width, M_BMPDATA->m_height);

 
 

-                    if ((w+1)%8 == 0)
-                    {
-                        dst[h*dstbyteperline+w/8] = outbyte;
-                        outbyte = 0;
-                    }
-                }
+        pixbuf_scaled = gdk_pixbuf_new(
+            GDK_COLORSPACE_RGB, false, 8, width, height);

 
 

-                // do not forget the last byte
-                if (width % 8 != 0)
-                    dst[h*dstbyteperline+width/8] = outbyte;
-            }
-            wxMask* mask = new wxMask;
-            mask->m_bitmap = gdk_bitmap_create_from_data( wxGetRootWindow()->window, (gchar *) dst, width, height );
-            bmp.SetMask(mask);
+        gdk_pixbuf_scale(
+            pixbuf, pixbuf_scaled,
+            0, 0, width, height, -clipx, -clipy, scale_x, scale_y,
+            GDK_INTERP_NEAREST);

 
 

-            free( dst );
-            g_object_unref (img);
-        }
+        g_object_unref(pixbuf);

 
 

-        free( tablex );
-        free( tabley );
+        // use existing functionality to create mask from scaled pixbuf
+        wxBitmap maskbmp;
+        maskbmp.SetPixbuf(pixbuf_scaled);
+        bmp.SetMask(new wxMask(maskbmp, *wxBLACK));

     }
     }

-

     return bmp;
 }
 
     return bmp;
 }
 

+#if wxUSE_IMAGE
+

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


@@ -708,10 +595,7 @@ wxImage wxBitmap::ConvertToImage() const
     return image;
 }
 
     return image;
 }
 

-bool wxBitmap::operator == ( const wxBitmap& bmp ) const
-{
-    return m_refData == bmp.m_refData;
-}
+#endif // wxUSE_IMAGE

 
 bool wxBitmap::IsOk() const
 {
 
 bool wxBitmap::IsOk() const
 {


@@ -812,9 +696,13 @@ bool wxBitmap::SaveFile( const wxString &name, wxBitmapType type, const wxPalett
 {
     wxCHECK_MSG( Ok(), false, wxT("invalid bitmap") );
 
 {
     wxCHECK_MSG( Ok(), false, wxT("invalid bitmap") );
 

+#if wxUSE_IMAGE

     // Try to save the bitmap via wxImage handlers:
     wxImage image = ConvertToImage();
     return image.Ok() && image.SaveFile(name, type);
     // Try to save the bitmap via wxImage handlers:
     wxImage image = ConvertToImage();
     return image.Ok() && image.SaveFile(name, type);

+#else // !wxUSE_IMAGE
+    return false;
+#endif // wxUSE_IMAGE

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


@@ -832,12 +720,14 @@ bool wxBitmap::LoadFile( const wxString &name, wxBitmapType type )
             M_BMPDATA->m_mask->m_bitmap = mask;
         }
     }
             M_BMPDATA->m_mask->m_bitmap = mask;
         }
     }

+#if wxUSE_IMAGE

     else // try if wxImage can load it
     {
         wxImage image;
         if (image.LoadFile(name, type) && image.Ok())
             CreateFromImage(image, -1);
     }
     else // try if wxImage can load it
     {
         wxImage image;
         if (image.LoadFile(name, type) && image.Ok())
             CreateFromImage(image, -1);
     }

+#endif // wxUSE_IMAGE

 
     return Ok();
 }
 
     return Ok();
 }


@@ -906,7 +796,7 @@ GdkPixmap *wxBitmap::GetPixmap() const
         gdk_pixbuf_render_pixmap_and_mask(M_BMPDATA->m_pixbuf,
                                           &M_BMPDATA->m_pixmap,
                                           pmask,
         gdk_pixbuf_render_pixmap_and_mask(M_BMPDATA->m_pixbuf,
                                           &M_BMPDATA->m_pixmap,
                                           pmask,

-                                          wxIMAGE_ALPHA_THRESHOLD);
+                                          0x80 /* alpha threshold */);

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


@@ -997,9 +887,6 @@ void wxBitmap::SetPixbuf(GdkPixbuf* pixbuf, int depth)
 
 void wxBitmap::PurgeOtherRepresentations(wxBitmap::Representation keep)
 {
 
 void wxBitmap::PurgeOtherRepresentations(wxBitmap::Representation keep)
 {

-    // AllocExclusive should not be needed for this internal function
-    wxASSERT(m_refData->GetRefCount() == 1);
-

     if (keep == Pixmap && HasPixbuf())
     {
         g_object_unref (M_BMPDATA->m_pixbuf);
     if (keep == Pixmap && HasPixbuf())
     {
         g_object_unref (M_BMPDATA->m_pixbuf);


@@ -1040,19 +927,6 @@ bool wxBitmap::HasAlpha() const
         gdk_pixbuf_get_has_alpha(M_BMPDATA->m_pixbuf);
 }
 
         gdk_pixbuf_get_has_alpha(M_BMPDATA->m_pixbuf);
 }
 

-void wxBitmap::UseAlpha()
-{
-    GdkPixbuf* pixbuf = GetPixbuf();
-    // add alpha if necessary
-    if (!gdk_pixbuf_get_has_alpha(pixbuf))
-    {
-        M_BMPDATA->m_pixbuf = NULL;
-        AllocExclusive();
-        M_BMPDATA->m_pixbuf = gdk_pixbuf_add_alpha(pixbuf, false, 0, 0, 0);
-        g_object_unref(pixbuf);
-    }
-}
-

 wxObjectRefData* wxBitmap::CreateRefData() const
 {
     return new wxBitmapRefData;
 wxObjectRefData* wxBitmap::CreateRefData() const
 {
     return new wxBitmapRefData;