API: image: Remove ability to set image from a pixmap

gtk/gtk.symbols

@@ -1646,7 +1646,6 @@ gtk_image_get_icon_name
 gtk_image_get_icon_set
 gtk_image_get_pixbuf
 gtk_image_get_pixel_size
-gtk_image_get_pixmap
 gtk_image_get_stock
 gtk_image_get_gicon
 gtk_image_get_storage_type
@@ -1657,7 +1656,6 @@ gtk_image_new_from_file
 gtk_image_new_from_icon_name
 gtk_image_new_from_icon_set
 gtk_image_new_from_pixbuf
-gtk_image_new_from_pixmap
 gtk_image_new_from_stock
 gtk_image_new_from_gicon
 gtk_image_set_from_animation
@@ -1665,7 +1663,6 @@ gtk_image_set_from_file
 gtk_image_set_from_icon_name
 gtk_image_set_from_icon_set
 gtk_image_set_from_pixbuf
-gtk_image_set_from_pixmap
 gtk_image_set_from_stock
 gtk_image_set_from_gicon
 gtk_image_set_pixel_size

gtk/gtkimage.c

@@ -132,11 +132,9 @@ struct _GtkImagePrivate
 {
   GtkIconSize           icon_size;      /* Only used with GTK_IMAGE_STOCK, GTK_IMAGE_ICON_SET, GTK_IMAGE_ICON_NAME */
   GtkImageType          storage_type;
-  GdkBitmap            *mask;           /* Only used with GTK_IMAGE_PIXMAP, GTK_IMAGE_IMAGE */
 
   union
   {
-    GtkImagePixmapData     pixmap;
     GtkImagePixbufData     pixbuf;
     GtkImageStockData      stock;
     GtkImageIconSetData    icon_set;
@@ -190,8 +188,6 @@ enum
 {
   PROP_0,
   PROP_PIXBUF,
-  PROP_PIXMAP,
-  PROP_MASK,
   PROP_FILE,
   PROP_STOCK,
   PROP_ICON_SET,
@@ -238,22 +234,6 @@ gtk_image_class_init (GtkImageClass *class)
                                                         GDK_TYPE_PIXBUF,
                                                         GTK_PARAM_READWRITE));
 
-  g_object_class_install_property (gobject_class,
-                                   PROP_PIXMAP,
-                                   g_param_spec_object ("pixmap",
-                                                        P_("Pixmap"),
-                                                        P_("A GdkPixmap to display"),
-                                                        GDK_TYPE_PIXMAP,
-                                                        GTK_PARAM_READWRITE));
-
-  g_object_class_install_property (gobject_class,
-                                   PROP_MASK,
-                                   g_param_spec_object ("mask",
-                                                        P_("Mask"),
-                                                        P_("Mask bitmap to use with GdkPixmap"),
-                                                        GDK_TYPE_PIXMAP,
-                                                        GTK_PARAM_READWRITE));
-  
   g_object_class_install_property (gobject_class,
                                    PROP_FILE,
                                    g_param_spec_string ("file",
@@ -372,7 +352,6 @@ gtk_image_init (GtkImage *image)
 
   priv->storage_type = GTK_IMAGE_EMPTY;
   priv->icon_size = DEFAULT_ICON_SIZE;
-  priv->mask = NULL;
 
   priv->pixel_size = -1;
 
@@ -404,30 +383,6 @@ gtk_image_set_property (GObject      *object,
       gtk_image_set_from_pixbuf (image,
                                  g_value_get_object (value));
       break;
-    case PROP_PIXMAP:
-      gtk_image_set_from_pixmap (image,
-                                 g_value_get_object (value),
-                                 priv->mask);
-      break;
-    case PROP_MASK:
-      if (priv->storage_type == GTK_IMAGE_PIXMAP)
-        gtk_image_set_from_pixmap (image,
-                                   priv->data.pixmap.pixmap,
-                                   g_value_get_object (value));
-      else
-        {
-          GdkBitmap *mask;
-
-          mask = g_value_get_object (value);
-
-          if (mask)
-            g_object_ref (mask);
-
-          gtk_image_clear (image);
-
-          priv->mask = mask;
-        }
-      break;
     case PROP_FILE:
       gtk_image_set_from_file (image, g_value_get_string (value));
       break;
@@ -506,16 +461,6 @@ gtk_image_get_property (GObject     *object,
         g_value_set_object (value,
                             gtk_image_get_pixbuf (image));
       break;
-    case PROP_PIXMAP:
-      if (priv->storage_type != GTK_IMAGE_PIXMAP)
-        g_value_set_object (value, NULL);
-      else
-        g_value_set_object (value,
-                            priv->data.pixmap.pixmap);
-      break;
-    case PROP_MASK:
-      g_value_set_object (value, priv->mask);
-      break;
     case PROP_FILE:
       g_value_set_string (value, priv->filename);
       break;
@@ -571,32 +516,6 @@ gtk_image_get_property (GObject     *object,
 }
 
 
-/**
- * gtk_image_new_from_pixmap:
- * @pixmap: (allow-none): a #GdkPixmap, or %NULL
- * @mask: (allow-none): a #GdkBitmap, or %NULL
- *
- * Creates a #GtkImage widget displaying @pixmap with a @mask.
- * A #GdkPixmap is a server-side image buffer in the pixel format of the
- * current display. The #GtkImage does not assume a reference to the
- * pixmap or mask; you still need to unref them if you own references.
- * #GtkImage will add its own reference rather than adopting yours.
- * 
- * Return value: a new #GtkImage
- **/
-GtkWidget*
-gtk_image_new_from_pixmap (GdkPixmap *pixmap,
-                           GdkBitmap *mask)
-{
-  GtkImage *image;
-
-  image = g_object_new (GTK_TYPE_IMAGE, NULL);
-
-  gtk_image_set_from_pixmap (image, pixmap, mask);
-
-  return GTK_WIDGET (image);
-}
-
 /**
  * gtk_image_new_from_file:
  * @filename: a filename
@@ -802,61 +721,6 @@ gtk_image_new_from_gicon (GIcon *icon,
   return GTK_WIDGET (image);
 }
 
-/**
- * gtk_image_set_from_pixmap:
- * @image: a #GtkImage
- * @pixmap: (allow-none): a #GdkPixmap or %NULL
- * @mask: (allow-none): a #GdkBitmap or %NULL
- *
- * See gtk_image_new_from_pixmap() for details.
- **/
-void
-gtk_image_set_from_pixmap (GtkImage  *image,
-                           GdkPixmap *pixmap,
-                           GdkBitmap *mask)
-{
-  GtkImagePrivate *priv;
-
-  g_return_if_fail (GTK_IS_IMAGE (image));
-  g_return_if_fail (pixmap == NULL ||
-                    GDK_IS_PIXMAP (pixmap));
-  g_return_if_fail (mask == NULL ||
-                    GDK_IS_PIXMAP (mask));
-
-  priv = image->priv;
-
-  g_object_freeze_notify (G_OBJECT (image));
-  
-  if (pixmap)
-    g_object_ref (pixmap);
-
-  if (mask)
-    g_object_ref (mask);
-
-  gtk_image_clear (image);
-
-  priv->mask = mask;
-
-  if (pixmap)
-    {
-      int width;
-      int height;
-
-      priv->storage_type = GTK_IMAGE_PIXMAP;
-
-      priv->data.pixmap.pixmap = pixmap;
-
-      gdk_drawable_get_size (GDK_DRAWABLE (pixmap), &width, &height);
-
-      gtk_image_update_size (image, width, height);
-    }
-
-  g_object_notify (G_OBJECT (image), "pixmap");
-  g_object_notify (G_OBJECT (image), "mask");
-  
-  g_object_thaw_notify (G_OBJECT (image));
-}
-
 /**
  * gtk_image_set_from_file:
  * @image: a #GtkImage
@@ -1206,41 +1070,6 @@ gtk_image_get_storage_type (GtkImage *image)
   return image->priv->storage_type;
 }
 
-/**
- * gtk_image_get_pixmap:
- * @image: a #GtkImage
- * @pixmap: (out) (transfer none) (allow-none): location to store the
- *     pixmap, or %NULL
- * @mask: (out) (transfer none) (allow-none): location to store the
- *     mask, or %NULL
- *
- * Gets the pixmap and mask being displayed by the #GtkImage.
- * The storage type of the image must be %GTK_IMAGE_EMPTY or
- * %GTK_IMAGE_PIXMAP (see gtk_image_get_storage_type()).
- * The caller of this function does not own a reference to the
- * returned pixmap and mask.
- **/
-void
-gtk_image_get_pixmap (GtkImage   *image,
-                      GdkPixmap **pixmap,
-                      GdkBitmap **mask)
-{
-  GtkImagePrivate *priv;
-
-  g_return_if_fail (GTK_IS_IMAGE (image));
-
-  priv = image->priv;
-
-  g_return_if_fail (priv->storage_type == GTK_IMAGE_PIXMAP ||
-                    priv->storage_type == GTK_IMAGE_EMPTY);
-
-  if (pixmap)
-    *pixmap = priv->data.pixmap.pixmap;
-
-  if (mask)
-    *mask = priv->mask;
-}
-
 /**
  * gtk_image_get_pixbuf:
  * @image: a #GtkImage
@@ -1797,10 +1626,9 @@ gtk_image_expose (GtkWidget      *widget,
       GtkAllocation allocation;
       GtkMisc *misc;
       GdkRectangle area, image_bound;
-      gint x, y, mask_x, mask_y;
+      gint x, y;
       gint xpad, ypad;
       gfloat xalign, yalign;
-      GdkBitmap *mask;
       GdkPixbuf *pixbuf;
       GtkStateType state;
       gboolean needs_state_transform;
@@ -1829,41 +1657,16 @@ gtk_image_expose (GtkWidget      *widget,
 
       x = floor (allocation.x + xpad + ((allocation.width - priv->required_width) * xalign));
       y = floor (allocation.y + ypad + ((allocation.height - priv->required_height) * yalign));
-      mask_x = x;
-      mask_y = y;
       
       image_bound.x = x;
       image_bound.y = y;      
       image_bound.width = 0;
       image_bound.height = 0;      
 
-      mask = NULL;
-      pixbuf = NULL;
       needs_state_transform = gtk_widget_get_state (widget) != GTK_STATE_NORMAL;
       
       switch (priv->storage_type)
         {
-        case GTK_IMAGE_PIXMAP:
-          mask = priv->mask;
-          gdk_drawable_get_size (priv->data.pixmap.pixmap,
-                                 &image_bound.width,
-                                 &image_bound.height);
-	  if (rectangle_intersect_even (&area, &image_bound) &&
-	      needs_state_transform)
-            {
-              pixbuf = gdk_pixbuf_get_from_drawable (NULL,
-                                                     priv->data.pixmap.pixmap,
-                                                     gtk_widget_get_colormap (widget),
-                                                     image_bound.x - x, image_bound.y - y,
-						     0, 0,
-                                                     image_bound.width,
-                                                     image_bound.height);
-
-	      x = image_bound.x;
-	      y = image_bound.y;
-            }
-	  
-          break;
 
         case GTK_IMAGE_PIXBUF:
           image_bound.width = gdk_pixbuf_get_width (priv->data.pixbuf.pixbuf);
@@ -1992,13 +1795,15 @@ gtk_image_expose (GtkWidget      *widget,
 	  
         case GTK_IMAGE_EMPTY:
           g_assert_not_reached ();
+          pixbuf = NULL;
           break;
         }
 
-      if (rectangle_intersect_even (&area, &image_bound))
+      if (pixbuf &&
-        {
+          rectangle_intersect_even (&area, &image_bound))
-          if (pixbuf)
         {
+          cairo_t *cr;
+
           if (needs_state_transform)
             {
               GtkIconSource *source;
@@ -2029,60 +1834,13 @@ gtk_image_expose (GtkWidget      *widget,
               pixbuf = rendered;
             }
 
-              if (pixbuf)
+          cr = gdk_cairo_create (gtk_widget_get_window (widget));
-                {
-                  cairo_t *cr = gdk_cairo_create (gtk_widget_get_window (widget));
           gdk_cairo_set_source_pixbuf (cr, pixbuf, x, y);
           gdk_cairo_rectangle (cr, &image_bound);
           cairo_fill (cr);
           cairo_destroy (cr);
-                }
-            }
-          else
-            {
-              cairo_t *cr;
-              cairo_pattern_t *mask_pattern;
-
-              switch (priv->storage_type)
-                {
-                case GTK_IMAGE_PIXMAP:
-                  cr = gdk_cairo_create (gtk_widget_get_window (widget));
-
-                  if (mask)
-                    {
-                      /* hack to get the mask pattern */
-                      gdk_cairo_set_source_pixmap (cr, mask, mask_x, mask_y);
-                      mask_pattern = cairo_get_source (cr);
-                      cairo_pattern_reference (mask_pattern);
-
-                      gdk_cairo_set_source_pixmap (cr, priv->data.pixmap.pixmap, x, y);
-                      gdk_cairo_rectangle (cr, &image_bound);
-                      cairo_clip (cr);
-                      cairo_mask (cr, mask_pattern);
-                    }
-                  else 
-                    {
-                      gdk_cairo_set_source_pixmap (cr, priv->data.pixmap.pixmap, x, y);
-                      gdk_cairo_rectangle (cr, &image_bound);
-                      cairo_fill (cr);
-                    }
-
-                  cairo_destroy (cr);
-                  break;
-                case GTK_IMAGE_PIXBUF:
-                case GTK_IMAGE_STOCK:
-                case GTK_IMAGE_ICON_SET:
-                case GTK_IMAGE_ANIMATION:
-		case GTK_IMAGE_ICON_NAME:
-                case GTK_IMAGE_EMPTY:
-		case GTK_IMAGE_GICON:
-                  g_assert_not_reached ();
-                  break;
-                }
-            }
         } /* if rectangle intersects */      
 
-      if (pixbuf)
       g_object_unref (pixbuf);
 
     } /* if widget is drawable */
@@ -2100,13 +1858,6 @@ gtk_image_reset (GtkImage *image)
   if (priv->storage_type != GTK_IMAGE_EMPTY)
     g_object_notify (G_OBJECT (image), "storage-type");
 
-  if (priv->mask)
-    {
-      g_object_unref (priv->mask);
-      priv->mask = NULL;
-      g_object_notify (G_OBJECT (image), "mask");
-    }
-
   if (priv->icon_size != DEFAULT_ICON_SIZE)
     {
       priv->icon_size = DEFAULT_ICON_SIZE;
@@ -2115,15 +1866,6 @@ gtk_image_reset (GtkImage *image)
   
   switch (priv->storage_type)
     {
-    case GTK_IMAGE_PIXMAP:
-
-      if (priv->data.pixmap.pixmap)
-        g_object_unref (priv->data.pixmap.pixmap);
-      priv->data.pixmap.pixmap = NULL;
-      
-      g_object_notify (G_OBJECT (image), "pixmap");
-      
-      break;
 
     case GTK_IMAGE_PIXBUF:
 

gtk/gtkimage.h

@@ -50,8 +50,6 @@ typedef struct _GtkImage              GtkImage;
 typedef struct _GtkImagePrivate       GtkImagePrivate;
 typedef struct _GtkImageClass         GtkImageClass;
 
-typedef struct _GtkImagePixmapData  GtkImagePixmapData;
-typedef struct _GtkImageImageData   GtkImageImageData;
 typedef struct _GtkImagePixbufData  GtkImagePixbufData;
 typedef struct _GtkImageStockData   GtkImageStockData;
 typedef struct _GtkImageIconSetData GtkImageIconSetData;
@@ -59,11 +57,6 @@ typedef struct _GtkImageAnimationData GtkImageAnimationData;
 typedef struct _GtkImageIconNameData  GtkImageIconNameData;
 typedef struct _GtkImageGIconData     GtkImageGIconData;
 
-struct _GtkImagePixmapData
-{
-  GdkPixmap *pixmap;
-};
-
 struct _GtkImagePixbufData
 {
   GdkPixbuf *pixbuf;
@@ -103,7 +96,6 @@ struct _GtkImageGIconData
 /**
  * GtkImageType:
  * @GTK_IMAGE_EMPTY: there is no image displayed by the widget
- * @GTK_IMAGE_PIXMAP: the widget contains a #GdkPixmap
  * @GTK_IMAGE_PIXBUF: the widget contains a #GdkPixbuf
  * @GTK_IMAGE_STOCK: the widget contains a stock icon name (see
  *  <xref linkend="gtk3-Stock-Items"/>)
@@ -125,7 +117,6 @@ struct _GtkImageGIconData
 typedef enum
 {
   GTK_IMAGE_EMPTY,
-  GTK_IMAGE_PIXMAP,
   GTK_IMAGE_PIXBUF,
   GTK_IMAGE_STOCK,
   GTK_IMAGE_ICON_SET,
@@ -162,8 +153,6 @@ struct _GtkImageClass
 GType      gtk_image_get_type (void) G_GNUC_CONST;
 
 GtkWidget* gtk_image_new                (void);
-GtkWidget* gtk_image_new_from_pixmap    (GdkPixmap       *pixmap,
-                                         GdkBitmap       *mask);
 GtkWidget* gtk_image_new_from_file      (const gchar     *filename);
 GtkWidget* gtk_image_new_from_pixbuf    (GdkPixbuf       *pixbuf);
 GtkWidget* gtk_image_new_from_stock     (const gchar     *stock_id,
@@ -177,9 +166,6 @@ GtkWidget* gtk_image_new_from_gicon     (GIcon           *icon,
 					 GtkIconSize      size);
 
 void gtk_image_clear              (GtkImage        *image);
-void gtk_image_set_from_pixmap    (GtkImage        *image,
-                                   GdkPixmap       *pixmap,
-                                   GdkBitmap       *mask);
 void gtk_image_set_from_file      (GtkImage        *image,
                                    const gchar     *filename);
 void gtk_image_set_from_pixbuf    (GtkImage        *image,
@@ -203,9 +189,6 @@ void gtk_image_set_pixel_size     (GtkImage        *image,
 
 GtkImageType gtk_image_get_storage_type (GtkImage   *image);
 
-void       gtk_image_get_pixmap   (GtkImage         *image,
-                                   GdkPixmap       **pixmap,
-                                   GdkBitmap       **mask);
 GdkPixbuf* gtk_image_get_pixbuf   (GtkImage         *image);
 void       gtk_image_get_stock    (GtkImage         *image,
                                    gchar           **stock_id,

modules/other/gail/gailimage.c

@@ -207,13 +207,6 @@ gail_image_get_image_size (AtkImage *image,
   image_type = gtk_image_get_storage_type(gtk_image);
  
   switch(image_type) {
-    case GTK_IMAGE_PIXMAP:
-    {	
-      GdkPixmap *pixmap;
-      gtk_image_get_pixmap(gtk_image, &pixmap, NULL);
-      gdk_drawable_get_size (pixmap, width, height);
-      break;
-    }
     case GTK_IMAGE_PIXBUF:
     {
       GdkPixbuf *pixbuf;