AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity

iconhelper: Don't inherit from GObject

Browse Source 
It's not a GtkCssGadget anymore, it doesn't have any properties or
signals either and it's not public. Further, its lifetime is very clear
the way it's being used inside GTK+.
This commit is contained in:
Timm Bäder 2017-09-30 17:26:42 +02:00
parent 773973db78
commit a32725bc9a
4 changed files with 197 additions and 259 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
gtk/gtkcellrendererpixbuf.c
View File

@ -387,20 +387,20 @@ gtk_cell_renderer_pixbuf_new (void)
return g_object_new (GTK_TYPE_CELL_RENDERER_PIXBUF, NULL); return g_object_new (GTK_TYPE_CELL_RENDERER_PIXBUF, NULL);
} }
static GtkIconHelper * static void
create_icon_helper (GtkCellRendererPixbuf *cellpixbuf, create_icon_helper (GtkIconHelper *icon_helper,
GtkCellRendererPixbuf *cellpixbuf,
GtkWidget *widget) GtkWidget *widget)
{ {
GtkCellRendererPixbufPrivate *priv = cellpixbuf->priv; GtkCellRendererPixbufPrivate *priv = cellpixbuf->priv;
GtkIconHelper *helper;
helper = gtk_icon_helper_new (gtk_style_context_get_node (gtk_widget_get_style_context (widget)), widget); gtk_icon_helper_init (icon_helper,
_gtk_icon_helper_set_force_scale_pixbuf (helper, TRUE); gtk_style_context_get_node (gtk_widget_get_style_context (widget)),
_gtk_icon_helper_set_definition (helper, priv->image_def); widget);
_gtk_icon_helper_set_force_scale_pixbuf (icon_helper, TRUE);
_gtk_icon_helper_set_definition (icon_helper, priv->image_def);
if (gtk_image_definition_get_storage_type (priv->image_def) != GTK_IMAGE_PIXBUF) if (gtk_image_definition_get_storage_type (priv->image_def) != GTK_IMAGE_PIXBUF)
_gtk_icon_helper_set_icon_size (helper, priv->icon_size); _gtk_icon_helper_set_icon_size (icon_helper, priv->icon_size);
return helper;
} }
static void static void
@ -420,18 +420,18 @@ gtk_cell_renderer_pixbuf_get_size (GtkCellRenderer *cell,
gint calc_height; gint calc_height;
gint xpad, ypad; gint xpad, ypad;
GtkStyleContext *context; GtkStyleContext *context;
GtkIconHelper *icon_helper; GtkIconHelper icon_helper;
context = gtk_widget_get_style_context (widget); context = gtk_widget_get_style_context (widget);
gtk_style_context_save (context); gtk_style_context_save (context);
gtk_style_context_add_class (context, GTK_STYLE_CLASS_IMAGE); gtk_style_context_add_class (context, GTK_STYLE_CLASS_IMAGE);
icon_helper = create_icon_helper (cellpixbuf, widget); create_icon_helper (&icon_helper, cellpixbuf, widget);
if (!_gtk_icon_helper_get_is_empty (icon_helper)) if (!_gtk_icon_helper_get_is_empty (&icon_helper))
_gtk_icon_helper_get_size (icon_helper, _gtk_icon_helper_get_size (&icon_helper,
&pixbuf_width, &pixbuf_height); &pixbuf_width, &pixbuf_height);
g_object_unref (icon_helper); gtk_icon_helper_destroy (&icon_helper);
gtk_style_context_restore (context); gtk_style_context_restore (context);
if (priv->pixbuf_expander_open) if (priv->pixbuf_expander_open)
@ -497,7 +497,7 @@ gtk_cell_renderer_pixbuf_snapshot (GtkCellRenderer *cell,
GdkRectangle draw_rect; GdkRectangle draw_rect;
gboolean is_expander; gboolean is_expander;
gint xpad, ypad; gint xpad, ypad;
GtkIconHelper *icon_helper = NULL; GtkIconHelper icon_helper;
gtk_cell_renderer_pixbuf_get_size (cell, widget, (GdkRectangle *) cell_area, gtk_cell_renderer_pixbuf_get_size (cell, widget, (GdkRectangle *) cell_area,
&pix_rect.x, &pix_rect.x,
@ -528,24 +528,28 @@ gtk_cell_renderer_pixbuf_snapshot (GtkCellRenderer *cell,
if (is_expanded && priv->pixbuf_expander_open != NULL) if (is_expanded && priv->pixbuf_expander_open != NULL)
{ {
icon_helper = gtk_icon_helper_new (gtk_style_context_get_node (context), widget); gtk_icon_helper_init (&icon_helper, gtk_style_context_get_node (context), widget);
_gtk_icon_helper_set_pixbuf (icon_helper, priv->pixbuf_expander_open); _gtk_icon_helper_set_pixbuf (&icon_helper, priv->pixbuf_expander_open);
} }
else if (!is_expanded && priv->pixbuf_expander_closed != NULL) else if (!is_expanded && priv->pixbuf_expander_closed != NULL)
{ {
icon_helper = gtk_icon_helper_new (gtk_style_context_get_node (context), widget); gtk_icon_helper_init (&icon_helper, gtk_style_context_get_node (context), widget);
_gtk_icon_helper_set_pixbuf (icon_helper, priv->pixbuf_expander_closed); _gtk_icon_helper_set_pixbuf (&icon_helper, priv->pixbuf_expander_closed);
}
else
{
create_icon_helper (&icon_helper, cellpixbuf, widget);
} }
} }
else
if (icon_helper == NULL) {
icon_helper = create_icon_helper (cellpixbuf, widget); create_icon_helper (&icon_helper, cellpixbuf, widget);
}
gtk_snapshot_offset (snapshot, pix_rect.x, pix_rect.y); gtk_snapshot_offset (snapshot, pix_rect.x, pix_rect.y);
gtk_icon_helper_snapshot (icon_helper, snapshot); gtk_icon_helper_snapshot (&icon_helper, snapshot);
gtk_snapshot_offset (snapshot, - pix_rect.x, - pix_rect.y); gtk_snapshot_offset (snapshot, - pix_rect.x, - pix_rect.y);
g_object_unref (icon_helper); gtk_icon_helper_destroy (&icon_helper);
gtk_style_context_restore (context); gtk_style_context_restore (context);
} }

268
gtk/gtkiconhelper.c
View File

@ -34,51 +34,31 @@
#include "gtksnapshot.h" #include "gtksnapshot.h"
#include "gtkwidgetprivate.h" #include "gtkwidgetprivate.h"
struct _GtkIconHelperPrivate {
GtkImageDefinition *def;
GtkIconSize icon_size;
gint pixel_size;
guint use_fallback : 1;
guint force_scale_pixbuf : 1;
guint rendered_surface_is_symbolic : 1;
GtkWidget *owner;
GtkCssNode *node;
cairo_surface_t *rendered_surface;
GskTexture *texture;
};
G_DEFINE_TYPE_WITH_PRIVATE (GtkIconHelper, gtk_icon_helper, G_TYPE_OBJECT)
void void
gtk_icon_helper_invalidate (GtkIconHelper *self) gtk_icon_helper_invalidate (GtkIconHelper *self)
{ {
g_clear_object (&self->priv->texture); g_clear_object (&self->texture);
if (self->priv->rendered_surface != NULL) if (self->rendered_surface != NULL)
{ {
cairo_surface_destroy (self->priv->rendered_surface); cairo_surface_destroy (self->rendered_surface);
self->priv->rendered_surface = NULL; self->rendered_surface = NULL;
self->priv->rendered_surface_is_symbolic = FALSE; self->rendered_surface_is_symbolic = FALSE;
} }
if (!GTK_IS_CSS_TRANSIENT_NODE (self->priv->node)) if (!GTK_IS_CSS_TRANSIENT_NODE (self->node))
gtk_widget_queue_resize (self->priv->owner); gtk_widget_queue_resize (self->owner);
} }
void void
gtk_icon_helper_invalidate_for_change (GtkIconHelper *self, gtk_icon_helper_invalidate_for_change (GtkIconHelper *self,
GtkCssStyleChange *change) GtkCssStyleChange *change)
{ {
GtkIconHelperPrivate *priv = self->priv;
if (change == NULL || if (change == NULL ||
((gtk_css_style_change_affects (change, GTK_CSS_AFFECTS_SYMBOLIC_ICON) && ((gtk_css_style_change_affects (change, GTK_CSS_AFFECTS_SYMBOLIC_ICON) &&
priv->rendered_surface_is_symbolic) || self->rendered_surface_is_symbolic) ||
(gtk_css_style_change_affects (change, GTK_CSS_AFFECTS_ICON) && (gtk_css_style_change_affects (change, GTK_CSS_AFFECTS_ICON) &&
!priv->rendered_surface_is_symbolic))) !self->rendered_surface_is_symbolic)))
{ {
gtk_icon_helper_invalidate (self); gtk_icon_helper_invalidate (self);
} }
@ -93,8 +73,8 @@ gtk_icon_helper_take_definition (GtkIconHelper *self,
if (def == NULL) if (def == NULL)
return; return;
gtk_image_definition_unref (self->priv->def); gtk_image_definition_unref (self->def);
self->priv->def = def; self->def = def;
gtk_icon_helper_invalidate (self); gtk_icon_helper_invalidate (self);
} }
@ -102,50 +82,41 @@ gtk_icon_helper_take_definition (GtkIconHelper *self,
void void
_gtk_icon_helper_clear (GtkIconHelper *self) _gtk_icon_helper_clear (GtkIconHelper *self)
{ {
g_clear_object (&self->priv->texture); g_clear_object (&self->texture);
g_clear_pointer (&self->priv->rendered_surface, cairo_surface_destroy); g_clear_pointer (&self->rendered_surface, cairo_surface_destroy);
gtk_image_definition_unref (self->priv->def); gtk_image_definition_unref (self->def);
self->priv->def = gtk_image_definition_new_empty (); self->def = gtk_image_definition_new_empty ();
self->priv->icon_size = GTK_ICON_SIZE_INVALID; self->icon_size = GTK_ICON_SIZE_INVALID;
gtk_icon_helper_invalidate (self); gtk_icon_helper_invalidate (self);
} }
static void void
gtk_icon_helper_finalize (GObject *object) gtk_icon_helper_destroy (GtkIconHelper *self)
{ {
GtkIconHelper *self = GTK_ICON_HELPER (object);
GtkWidget *widget;
widget = self->priv->owner;
g_signal_handlers_disconnect_by_func (widget, G_CALLBACK (gtk_icon_helper_invalidate), self);
_gtk_icon_helper_clear (self); _gtk_icon_helper_clear (self);
gtk_image_definition_unref (self->priv->def); g_signal_handlers_disconnect_by_func (self->owner, G_CALLBACK (gtk_icon_helper_invalidate), self);
gtk_image_definition_unref (self->def);
G_OBJECT_CLASS (gtk_icon_helper_parent_class)->finalize (object);
} }
static void void
gtk_icon_helper_class_init (GtkIconHelperClass *klass) gtk_icon_helper_init (GtkIconHelper *self,
GtkCssNode *css_node,
GtkWidget *owner)
{ {
GObjectClass *object_class = G_OBJECT_CLASS (klass); memset (self, 0, sizeof (GtkIconHelper));
self->def = gtk_image_definition_new_empty ();
object_class->finalize = gtk_icon_helper_finalize; self->icon_size = GTK_ICON_SIZE_INVALID;
} self->pixel_size = -1;
self->rendered_surface_is_symbolic = FALSE;
static void self->node = css_node;
gtk_icon_helper_init (GtkIconHelper *self) self->owner = owner;
{ g_signal_connect_swapped (owner, "direction-changed", G_CALLBACK (gtk_icon_helper_invalidate), self);
self->priv = gtk_icon_helper_get_instance_private (self); g_signal_connect_swapped (owner, "notify::scale-factor", G_CALLBACK (gtk_icon_helper_invalidate), self);
self->priv->def = gtk_image_definition_new_empty ();
self->priv->icon_size = GTK_ICON_SIZE_INVALID;
self->priv->pixel_size = -1;
self->priv->rendered_surface_is_symbolic = FALSE;
} }
static void static void
@ -155,19 +126,19 @@ ensure_icon_size (GtkIconHelper *self,
{ {
gint width, height; gint width, height;
if (self->priv->pixel_size != -1) if (self->pixel_size != -1)
{ {
width = height = self->priv->pixel_size; width = height = self->pixel_size;
} }
else if (!gtk_icon_size_lookup (self->priv->icon_size, &width, &height)) else if (!gtk_icon_size_lookup (self->icon_size, &width, &height))
{ {
if (self->priv->icon_size == GTK_ICON_SIZE_INVALID) if (self->icon_size == GTK_ICON_SIZE_INVALID)
{ {
width = height = 0; width = height = 0;
} }
else else
{ {
g_warning ("Invalid icon size %d", self->priv->icon_size); g_warning ("Invalid icon size %d", self->icon_size);
width = height = 24; width = height = 24;
} }
} }
@ -186,7 +157,7 @@ get_icon_lookup_flags (GtkIconHelper *self,
flags = GTK_ICON_LOOKUP_USE_BUILTIN; flags = GTK_ICON_LOOKUP_USE_BUILTIN;
if (self->priv->pixel_size != -1 || self->priv->force_scale_pixbuf) if (self->pixel_size != -1 || self->force_scale_pixbuf)
flags |= GTK_ICON_LOOKUP_FORCE_SIZE; flags |= GTK_ICON_LOOKUP_FORCE_SIZE;
icon_style = _gtk_css_icon_style_value_get (gtk_css_style_get_value (style, GTK_CSS_PROPERTY_ICON_STYLE)); icon_style = _gtk_css_icon_style_value_get (gtk_css_style_get_value (style, GTK_CSS_PROPERTY_ICON_STYLE));
@ -263,9 +234,9 @@ get_pixbuf_size (GtkIconHelper *self,
scale_pixmap = FALSE; scale_pixmap = FALSE;
if (self->priv->force_scale_pixbuf && if (self->force_scale_pixbuf &&
(self->priv->pixel_size != -1 || (self->pixel_size != -1 ||
self->priv->icon_size != GTK_ICON_SIZE_INVALID)) self->icon_size != GTK_ICON_SIZE_INVALID))
{ {
ensure_icon_size (self, &width, &height); ensure_icon_size (self, &width, &height);
@ -321,7 +292,7 @@ ensure_surface_from_pixbuf (GtkIconHelper *self,
else else
pixbuf = g_object_ref (orig_pixbuf); pixbuf = g_object_ref (orig_pixbuf);
surface = gdk_cairo_surface_create_from_pixbuf (pixbuf, scale, _gtk_widget_get_window (self->priv->owner)); surface = gdk_cairo_surface_create_from_pixbuf (pixbuf, scale, _gtk_widget_get_window (self->owner));
g_object_unref (pixbuf); g_object_unref (pixbuf);
return surface; return surface;
@ -334,7 +305,6 @@ ensure_surface_for_gicon (GtkIconHelper *self,
gint scale, gint scale,
GIcon *gicon) GIcon *gicon)
{ {
GtkIconHelperPrivate *priv = self->priv;
GtkIconTheme *icon_theme; GtkIconTheme *icon_theme;
gint width, height; gint width, height;
GtkIconInfo *info; GtkIconInfo *info;
@ -396,11 +366,11 @@ ensure_surface_for_gicon (GtkIconHelper *self,
symbolic = FALSE; symbolic = FALSE;
} }
surface = gdk_cairo_surface_create_from_pixbuf (destination, scale, _gtk_widget_get_window (priv->owner)); surface = gdk_cairo_surface_create_from_pixbuf (destination, scale, _gtk_widget_get_window (self->owner));
if (symbolic) if (symbolic)
{ {
priv->rendered_surface_is_symbolic = TRUE; self->rendered_surface_is_symbolic = TRUE;
} }
g_object_unref (destination); g_object_unref (destination);
@ -412,32 +382,31 @@ static cairo_surface_t *
gtk_icon_helper_load_surface (GtkIconHelper *self, gtk_icon_helper_load_surface (GtkIconHelper *self,
int scale) int scale)
{ {
GtkIconHelperPrivate *priv = gtk_icon_helper_get_instance_private (self);
cairo_surface_t *surface; cairo_surface_t *surface;
GIcon *gicon; GIcon *gicon;
switch (gtk_image_definition_get_storage_type (self->priv->def)) switch (gtk_image_definition_get_storage_type (self->def))
{ {
case GTK_IMAGE_SURFACE: case GTK_IMAGE_SURFACE:
surface = ensure_surface_from_surface (self, gtk_image_definition_get_surface (self->priv->def)); surface = ensure_surface_from_surface (self, gtk_image_definition_get_surface (self->def));
break; break;
case GTK_IMAGE_PIXBUF: case GTK_IMAGE_PIXBUF:
surface = ensure_surface_from_pixbuf (self, surface = ensure_surface_from_pixbuf (self,
gtk_css_node_get_style (priv->node), gtk_css_node_get_style (self->node),
scale, scale,
gtk_image_definition_get_pixbuf (self->priv->def), gtk_image_definition_get_pixbuf (self->def),
gtk_image_definition_get_scale (self->priv->def)); gtk_image_definition_get_scale (self->def));
break; break;
case GTK_IMAGE_ICON_NAME: case GTK_IMAGE_ICON_NAME:
if (self->priv->use_fallback) if (self->use_fallback)
gicon = g_themed_icon_new_with_default_fallbacks (gtk_image_definition_get_icon_name (self->priv->def)); gicon = g_themed_icon_new_with_default_fallbacks (gtk_image_definition_get_icon_name (self->def));
else else
gicon = g_themed_icon_new (gtk_image_definition_get_icon_name (self->priv->def)); gicon = g_themed_icon_new (gtk_image_definition_get_icon_name (self->def));
surface = ensure_surface_for_gicon (self, surface = ensure_surface_for_gicon (self,
gtk_css_node_get_style (priv->node), gtk_css_node_get_style (self->node),
gtk_widget_get_direction (priv->owner), gtk_widget_get_direction (self->owner),
scale, scale,
gicon); gicon);
g_object_unref (gicon); g_object_unref (gicon);
@ -445,10 +414,10 @@ gtk_icon_helper_load_surface (GtkIconHelper *self,
case GTK_IMAGE_GICON: case GTK_IMAGE_GICON:
surface = ensure_surface_for_gicon (self, surface = ensure_surface_for_gicon (self,
gtk_css_node_get_style (priv->node), gtk_css_node_get_style (self->node),
gtk_widget_get_direction (priv->owner), gtk_widget_get_direction (self->owner),
scale, scale,
gtk_image_definition_get_gicon (priv->def)); gtk_image_definition_get_gicon (self->def));
break; break;
case GTK_IMAGE_ANIMATION: case GTK_IMAGE_ANIMATION:
@ -467,12 +436,12 @@ gtk_icon_helper_ensure_surface (GtkIconHelper *self)
{ {
int scale; int scale;
if (self->priv->rendered_surface) if (self->rendered_surface)
return; return;
scale = gtk_widget_get_scale_factor (self->priv->owner); scale = gtk_widget_get_scale_factor (self->owner);
self->priv->rendered_surface = gtk_icon_helper_load_surface (self, scale); self->rendered_surface = gtk_icon_helper_load_surface (self, scale);
} }
static void static void
@ -481,41 +450,41 @@ gtk_icon_helper_ensure_texture (GtkIconHelper *self)
cairo_surface_t *map; cairo_surface_t *map;
int width, height, scale; int width, height, scale;
if (self->priv->texture) if (self->texture)
return; return;
gtk_icon_helper_ensure_surface (self); gtk_icon_helper_ensure_surface (self);
if (self->priv->rendered_surface == NULL) if (self->rendered_surface == NULL)
return; return;
scale = gtk_widget_get_scale_factor (self->priv->owner); scale = gtk_widget_get_scale_factor (self->owner);
_gtk_icon_helper_get_size (self, &width, &height); _gtk_icon_helper_get_size (self, &width, &height);
if (cairo_image_surface_get_format (self->priv->rendered_surface) != CAIRO_FORMAT_ARGB32) if (cairo_image_surface_get_format (self->rendered_surface) != CAIRO_FORMAT_ARGB32)
{ {
cairo_surface_t *argb_surface = cairo_surface_create_similar_image (self->priv->rendered_surface, cairo_surface_t *argb_surface = cairo_surface_create_similar_image (self->rendered_surface,
CAIRO_FORMAT_ARGB32, CAIRO_FORMAT_ARGB32,
width, height); width, height);
cairo_t *ct; cairo_t *ct;
cairo_surface_set_device_scale (argb_surface, scale, scale); cairo_surface_set_device_scale (argb_surface, scale, scale);
ct = cairo_create (argb_surface); ct = cairo_create (argb_surface);
cairo_set_source_surface (ct, self->priv->rendered_surface, 0, 0); cairo_set_source_surface (ct, self->rendered_surface, 0, 0);
cairo_paint (ct); cairo_paint (ct);
cairo_destroy (ct); cairo_destroy (ct);
cairo_surface_destroy (self->priv->rendered_surface); cairo_surface_destroy (self->rendered_surface);
self->priv->rendered_surface = argb_surface; self->rendered_surface = argb_surface;
} }
map = cairo_surface_map_to_image (self->priv->rendered_surface, map = cairo_surface_map_to_image (self->rendered_surface,
&(GdkRectangle) { 0, 0, width * scale, height * scale}); &(GdkRectangle) { 0, 0, width * scale, height * scale});
self->priv->texture = gsk_texture_new_for_data (cairo_image_surface_get_data (map), self->texture = gsk_texture_new_for_data (cairo_image_surface_get_data (map),
width * scale, width * scale,
height * scale, height * scale,
cairo_image_surface_get_stride (map)); cairo_image_surface_get_stride (map));
cairo_surface_unmap_image (self->priv->rendered_surface, map); cairo_surface_unmap_image (self->rendered_surface, map);
} }
void void
@ -527,23 +496,23 @@ _gtk_icon_helper_get_size (GtkIconHelper *self,
width = height = 0; width = height = 0;
/* Certain kinds of images are easy to calculate the size for, these /* Certain kinds of images are easy to calculate the size for,</cosimoc>3 these
we do immediately to avoid having to potentially load the image we do immediately to avoid having to potentially load the image
data for something that may not yet be visible */ data for something that may not yet be visible */
switch (gtk_image_definition_get_storage_type (self->priv->def)) switch (gtk_image_definition_get_storage_type (self->def))
{ {
case GTK_IMAGE_SURFACE: case GTK_IMAGE_SURFACE:
get_surface_size (self, get_surface_size (self,
gtk_image_definition_get_surface (self->priv->def), gtk_image_definition_get_surface (self->def),
&width, &width,
&height); &height);
break; break;
case GTK_IMAGE_PIXBUF: case GTK_IMAGE_PIXBUF:
get_pixbuf_size (self, get_pixbuf_size (self,
gtk_widget_get_scale_factor (self->priv->owner), gtk_widget_get_scale_factor (self->owner),
gtk_image_definition_get_pixbuf (self->priv->def), gtk_image_definition_get_pixbuf (self->def),
gtk_image_definition_get_scale (self->priv->def), gtk_image_definition_get_scale (self->def),
&width, &height, &scale); &width, &height, &scale);
width = (width + scale - 1) / scale; width = (width + scale - 1) / scale;
height = (height + scale - 1) / scale; height = (height + scale - 1) / scale;
@ -551,7 +520,7 @@ _gtk_icon_helper_get_size (GtkIconHelper *self,
case GTK_IMAGE_ANIMATION: case GTK_IMAGE_ANIMATION:
{ {
GdkPixbufAnimation *animation = gtk_image_definition_get_animation (self->priv->def); GdkPixbufAnimation *animation = gtk_image_definition_get_animation (self->def);
width = gdk_pixbuf_animation_get_width (animation); width = gdk_pixbuf_animation_get_width (animation);
height = gdk_pixbuf_animation_get_height (animation); height = gdk_pixbuf_animation_get_height (animation);
break; break;
@ -559,7 +528,7 @@ _gtk_icon_helper_get_size (GtkIconHelper *self,
case GTK_IMAGE_ICON_NAME: case GTK_IMAGE_ICON_NAME:
case GTK_IMAGE_GICON: case GTK_IMAGE_GICON:
if (self->priv->pixel_size != -1 || self->priv->force_scale_pixbuf) if (self->pixel_size != -1 || self->force_scale_pixbuf)
ensure_icon_size (self, &width, &height); ensure_icon_size (self, &width, &height);
break; break;
@ -574,11 +543,11 @@ _gtk_icon_helper_get_size (GtkIconHelper *self,
{ {
gtk_icon_helper_ensure_surface (self); gtk_icon_helper_ensure_surface (self);
if (self->priv->rendered_surface != NULL) if (self->rendered_surface != NULL)
{ {
get_surface_size (self, self->priv->rendered_surface, &width, &height); get_surface_size (self, self->rendered_surface, &width, &height);
} }
else if (self->priv->icon_size != GTK_ICON_SIZE_INVALID) else if (self->icon_size != GTK_ICON_SIZE_INVALID)
{ {
ensure_icon_size (self, &width, &height); ensure_icon_size (self, &width, &height);
} }
@ -643,9 +612,9 @@ gboolean
_gtk_icon_helper_set_icon_size (GtkIconHelper *self, _gtk_icon_helper_set_icon_size (GtkIconHelper *self,
GtkIconSize icon_size) GtkIconSize icon_size)
{ {
if (self->priv->icon_size != icon_size) if (self->icon_size != icon_size)
{ {
self->priv->icon_size = icon_size; self->icon_size = icon_size;
gtk_icon_helper_invalidate (self); gtk_icon_helper_invalidate (self);
return TRUE; return TRUE;
} }
@ -656,9 +625,9 @@ gboolean
_gtk_icon_helper_set_pixel_size (GtkIconHelper *self, _gtk_icon_helper_set_pixel_size (GtkIconHelper *self,
gint pixel_size) gint pixel_size)
{ {
if (self->priv->pixel_size != pixel_size) if (self->pixel_size != pixel_size)
{ {
self->priv->pixel_size = pixel_size; self->pixel_size = pixel_size;
gtk_icon_helper_invalidate (self); gtk_icon_helper_invalidate (self);
return TRUE; return TRUE;
} }
@ -669,9 +638,9 @@ gboolean
_gtk_icon_helper_set_use_fallback (GtkIconHelper *self, _gtk_icon_helper_set_use_fallback (GtkIconHelper *self,
gboolean use_fallback) gboolean use_fallback)
{ {
if (self->priv->use_fallback != use_fallback) if (self->use_fallback != use_fallback)
{ {
self->priv->use_fallback = use_fallback; self->use_fallback = use_fallback;
gtk_icon_helper_invalidate (self); gtk_icon_helper_invalidate (self);
return TRUE; return TRUE;
} }
@ -681,80 +650,61 @@ _gtk_icon_helper_set_use_fallback (GtkIconHelper *self,
GtkImageType GtkImageType
_gtk_icon_helper_get_storage_type (GtkIconHelper *self) _gtk_icon_helper_get_storage_type (GtkIconHelper *self)
{ {
return gtk_image_definition_get_storage_type (self->priv->def); return gtk_image_definition_get_storage_type (self->def);
} }
gboolean gboolean
_gtk_icon_helper_get_use_fallback (GtkIconHelper *self) _gtk_icon_helper_get_use_fallback (GtkIconHelper *self)
{ {
return self->priv->use_fallback; return self->use_fallback;
} }
GtkIconSize GtkIconSize
_gtk_icon_helper_get_icon_size (GtkIconHelper *self) _gtk_icon_helper_get_icon_size (GtkIconHelper *self)
{ {
return self->priv->icon_size; return self->icon_size;
} }
gint gint
_gtk_icon_helper_get_pixel_size (GtkIconHelper *self) _gtk_icon_helper_get_pixel_size (GtkIconHelper *self)
{ {
return self->priv->pixel_size; return self->pixel_size;
} }
GtkImageDefinition * GtkImageDefinition *
gtk_icon_helper_get_definition (GtkIconHelper *self) gtk_icon_helper_get_definition (GtkIconHelper *self)
{ {
return self->priv->def; return self->def;
} }
GdkPixbuf * GdkPixbuf *
_gtk_icon_helper_peek_pixbuf (GtkIconHelper *self) _gtk_icon_helper_peek_pixbuf (GtkIconHelper *self)
{ {
return gtk_image_definition_get_pixbuf (self->priv->def); return gtk_image_definition_get_pixbuf (self->def);
} }
GIcon * GIcon *
_gtk_icon_helper_peek_gicon (GtkIconHelper *self) _gtk_icon_helper_peek_gicon (GtkIconHelper *self)
{ {
return gtk_image_definition_get_gicon (self->priv->def); return gtk_image_definition_get_gicon (self->def);
} }
GdkPixbufAnimation * GdkPixbufAnimation *
_gtk_icon_helper_peek_animation (GtkIconHelper *self) _gtk_icon_helper_peek_animation (GtkIconHelper *self)
{ {
return gtk_image_definition_get_animation (self->priv->def); return gtk_image_definition_get_animation (self->def);
} }
cairo_surface_t * cairo_surface_t *
_gtk_icon_helper_peek_surface (GtkIconHelper *self) _gtk_icon_helper_peek_surface (GtkIconHelper *self)
{ {
return gtk_image_definition_get_surface (self->priv->def); return gtk_image_definition_get_surface (self->def);
} }
const gchar * const gchar *
_gtk_icon_helper_get_icon_name (GtkIconHelper *self) _gtk_icon_helper_get_icon_name (GtkIconHelper *self)
{ {
return gtk_image_definition_get_icon_name (self->priv->def); return gtk_image_definition_get_icon_name (self->def);
}
GtkIconHelper *
gtk_icon_helper_new (GtkCssNode *node,
GtkWidget *owner)
{
GtkIconHelper *helper;
g_return_val_if_fail (GTK_IS_CSS_NODE (node), NULL);
g_return_val_if_fail (GTK_IS_WIDGET (owner), NULL);
helper = g_object_new (GTK_TYPE_ICON_HELPER, NULL);
helper->priv->node = node;
helper->priv->owner = owner;
g_signal_connect_swapped (owner, "direction-changed", G_CALLBACK (gtk_icon_helper_invalidate), helper);
g_signal_connect_swapped (owner, "notify::scale-factor", G_CALLBACK (gtk_icon_helper_invalidate), helper);
return helper;
} }
void void
@ -764,38 +714,38 @@ gtk_icon_helper_snapshot (GtkIconHelper *self,
GtkCssStyle *style; GtkCssStyle *style;
GskTexture *texture; GskTexture *texture;
style = gtk_css_node_get_style (self->priv->node); style = gtk_css_node_get_style (self->node);
gtk_icon_helper_ensure_texture (self); gtk_icon_helper_ensure_texture (self);
texture = self->priv->texture; texture = self->texture;
if (texture == NULL) if (texture == NULL)
return; return;
gtk_css_style_snapshot_icon_texture (style, gtk_css_style_snapshot_icon_texture (style,
snapshot, snapshot,
texture, texture,
gtk_widget_get_scale_factor (self->priv->owner)); gtk_widget_get_scale_factor (self->owner));
} }
gboolean gboolean
_gtk_icon_helper_get_is_empty (GtkIconHelper *self) _gtk_icon_helper_get_is_empty (GtkIconHelper *self)
{ {
return gtk_image_definition_get_storage_type (self->priv->def) == GTK_IMAGE_EMPTY; return gtk_image_definition_get_storage_type (self->def) == GTK_IMAGE_EMPTY;
} }
gboolean gboolean
_gtk_icon_helper_get_force_scale_pixbuf (GtkIconHelper *self) _gtk_icon_helper_get_force_scale_pixbuf (GtkIconHelper *self)
{ {
return self->priv->force_scale_pixbuf; return self->force_scale_pixbuf;
} }
void void
_gtk_icon_helper_set_force_scale_pixbuf (GtkIconHelper *self, _gtk_icon_helper_set_force_scale_pixbuf (GtkIconHelper *self,
gboolean force_scale) gboolean force_scale)
{ {
if (self->priv->force_scale_pixbuf != force_scale) if (self->force_scale_pixbuf != force_scale)
{ {
self->priv->force_scale_pixbuf = force_scale; self->force_scale_pixbuf = force_scale;
gtk_icon_helper_invalidate (self); gtk_icon_helper_invalidate (self);
} }
} }
@ -804,17 +754,17 @@ void
_gtk_icon_helper_set_pixbuf_scale (GtkIconHelper *self, _gtk_icon_helper_set_pixbuf_scale (GtkIconHelper *self,
int scale) int scale)
{ {
switch (gtk_image_definition_get_storage_type (self->priv->def)) switch (gtk_image_definition_get_storage_type (self->def))
{ {
case GTK_IMAGE_PIXBUF: case GTK_IMAGE_PIXBUF:
gtk_icon_helper_take_definition (self, gtk_icon_helper_take_definition (self,
gtk_image_definition_new_pixbuf (gtk_image_definition_get_pixbuf (self->priv->def), gtk_image_definition_new_pixbuf (gtk_image_definition_get_pixbuf (self->def),
scale)); scale));
break; break;
case GTK_IMAGE_ANIMATION: case GTK_IMAGE_ANIMATION:
gtk_icon_helper_take_definition (self, gtk_icon_helper_take_definition (self,
gtk_image_definition_new_animation (gtk_image_definition_get_animation (self->priv->def), gtk_image_definition_new_animation (gtk_image_definition_get_animation (self->def),
scale)); scale));
break; break;

50
gtk/gtkiconhelperprivate.h
View File

@ -28,48 +28,32 @@
G_BEGIN_DECLS G_BEGIN_DECLS
#define GTK_TYPE_ICON_HELPER gtk_icon_helper_get_type()
#define GTK_ICON_HELPER(obj) \
(G_TYPE_CHECK_INSTANCE_CAST ((obj), \
GTK_TYPE_ICON_HELPER, GtkIconHelper))
#define GTK_ICON_HELPER_CLASS(klass) \
(G_TYPE_CHECK_CLASS_CAST ((klass), \
GTK_TYPE_ICON_HELPER, GtkIconHelperClass))
#define GTK_IS_ICON_HELPER(obj) \
(G_TYPE_CHECK_INSTANCE_TYPE ((obj), \
GTK_TYPE_ICON_HELPER))
#define GTK_IS_ICON_HELPER_CLASS(klass) \
(G_TYPE_CHECK_CLASS_TYPE ((klass), \
GTK_TYPE_ICON_HELPER))
#define GTK_ICON_HELPER_GET_CLASS(obj) \
(G_TYPE_INSTANCE_GET_CLASS ((obj), \
GTK_TYPE_ICON_HELPER, GtkIconHelperClass))
typedef struct _GtkIconHelper GtkIconHelper; typedef struct _GtkIconHelper GtkIconHelper;
typedef struct _GtkIconHelperClass GtkIconHelperClass;
typedef struct _GtkIconHelperPrivate GtkIconHelperPrivate;
struct _GtkIconHelper struct _GtkIconHelper
{ {
GObject parent_instance; GObject parent_instance;
GtkIconHelperPrivate *priv; GtkImageDefinition *def;
GtkIconSize icon_size;
gint pixel_size;
guint use_fallback : 1;
guint force_scale_pixbuf : 1;
guint rendered_surface_is_symbolic : 1;
GtkWidget *owner;
GtkCssNode *node;
cairo_surface_t *rendered_surface;
GskTexture *texture;
}; };
struct _GtkIconHelperClass void gtk_icon_helper_init (GtkIconHelper *self,
{ GtkCssNode *css_node,
GObjectClass parent_class; GtkWidget *owner);
};
GType gtk_icon_helper_get_type (void) G_GNUC_CONST; void gtk_icon_helper_destroy (GtkIconHelper *self);
GtkIconHelper *gtk_icon_helper_new (GtkCssNode *node,
GtkWidget *owner);
void _gtk_icon_helper_clear (GtkIconHelper *self); void _gtk_icon_helper_clear (GtkIconHelper *self);

84
gtk/gtkimage.c
View File

@ -83,7 +83,7 @@
struct _GtkImagePrivate struct _GtkImagePrivate
{ {
GtkIconHelper *icon_helper; GtkIconHelper icon_helper;
GdkPixbufAnimationIter *animation_iter; GdkPixbufAnimationIter *animation_iter;
gint animation_timeout; gint animation_timeout;
@ -306,8 +306,8 @@ gtk_image_init (GtkImage *image)
widget_node = gtk_widget_get_css_node (GTK_WIDGET (image)); widget_node = gtk_widget_get_css_node (GTK_WIDGET (image));
gtk_widget_set_has_window (GTK_WIDGET (image), FALSE); gtk_widget_set_has_window (GTK_WIDGET (image), FALSE);
priv->icon_helper = gtk_icon_helper_new (widget_node, GTK_WIDGET (image)); gtk_icon_helper_init (&priv->icon_helper, widget_node, GTK_WIDGET (image));
_gtk_icon_helper_set_icon_size (priv->icon_helper, DEFAULT_ICON_SIZE); _gtk_icon_helper_set_icon_size (&priv->icon_helper, DEFAULT_ICON_SIZE);
} }
static void static void
@ -315,7 +315,7 @@ gtk_image_finalize (GObject *object)
{ {
GtkImage *image = GTK_IMAGE (object); GtkImage *image = GTK_IMAGE (object);
g_clear_object (&image->priv->icon_helper); gtk_icon_helper_destroy (&image->priv->icon_helper);
g_free (image->priv->filename); g_free (image->priv->filename);
g_free (image->priv->resource_path); g_free (image->priv->resource_path);
@ -331,7 +331,7 @@ gtk_image_set_property (GObject *object,
{ {
GtkImage *image = GTK_IMAGE (object); GtkImage *image = GTK_IMAGE (object);
GtkImagePrivate *priv = image->priv; GtkImagePrivate *priv = image->priv;
GtkIconSize icon_size = _gtk_icon_helper_get_icon_size (priv->icon_helper); GtkIconSize icon_size = _gtk_icon_helper_get_icon_size (&priv->icon_helper);
if (icon_size == GTK_ICON_SIZE_INVALID) if (icon_size == GTK_ICON_SIZE_INVALID)
icon_size = DEFAULT_ICON_SIZE; icon_size = DEFAULT_ICON_SIZE;
@ -348,7 +348,7 @@ gtk_image_set_property (GObject *object,
gtk_image_set_from_file (image, g_value_get_string (value)); gtk_image_set_from_file (image, g_value_get_string (value));
break; break;
case PROP_ICON_SIZE: case PROP_ICON_SIZE:
if (_gtk_icon_helper_set_icon_size (priv->icon_helper, g_value_get_int (value))) if (_gtk_icon_helper_set_icon_size (&priv->icon_helper, g_value_get_int (value)))
{ {
g_object_notify_by_pspec (object, pspec); g_object_notify_by_pspec (object, pspec);
gtk_widget_queue_resize (GTK_WIDGET (image)); gtk_widget_queue_resize (GTK_WIDGET (image));
@ -371,7 +371,7 @@ gtk_image_set_property (GObject *object,
break; break;
case PROP_USE_FALLBACK: case PROP_USE_FALLBACK:
if (_gtk_icon_helper_set_use_fallback (priv->icon_helper, g_value_get_boolean (value))) if (_gtk_icon_helper_set_use_fallback (&priv->icon_helper, g_value_get_boolean (value)))
g_object_notify_by_pspec (object, pspec); g_object_notify_by_pspec (object, pspec);
break; break;
@ -393,37 +393,37 @@ gtk_image_get_property (GObject *object,
switch (prop_id) switch (prop_id)
{ {
case PROP_PIXBUF: case PROP_PIXBUF:
g_value_set_object (value, _gtk_icon_helper_peek_pixbuf (priv->icon_helper)); g_value_set_object (value, _gtk_icon_helper_peek_pixbuf (&priv->icon_helper));
break; break;
case PROP_SURFACE: case PROP_SURFACE:
g_value_set_boxed (value, _gtk_icon_helper_peek_surface (priv->icon_helper)); g_value_set_boxed (value, _gtk_icon_helper_peek_surface (&priv->icon_helper));
break; break;
case PROP_FILE: case PROP_FILE:
g_value_set_string (value, priv->filename); g_value_set_string (value, priv->filename);
break; break;
case PROP_ICON_SIZE: case PROP_ICON_SIZE:
g_value_set_int (value, _gtk_icon_helper_get_icon_size (priv->icon_helper)); g_value_set_int (value, _gtk_icon_helper_get_icon_size (&priv->icon_helper));
break; break;
case PROP_PIXEL_SIZE: case PROP_PIXEL_SIZE:
g_value_set_int (value, _gtk_icon_helper_get_pixel_size (priv->icon_helper)); g_value_set_int (value, _gtk_icon_helper_get_pixel_size (&priv->icon_helper));
break; break;
case PROP_PIXBUF_ANIMATION: case PROP_PIXBUF_ANIMATION:
g_value_set_object (value, _gtk_icon_helper_peek_animation (priv->icon_helper)); g_value_set_object (value, _gtk_icon_helper_peek_animation (&priv->icon_helper));
break; break;
case PROP_ICON_NAME: case PROP_ICON_NAME:
g_value_set_string (value, _gtk_icon_helper_get_icon_name (priv->icon_helper)); g_value_set_string (value, _gtk_icon_helper_get_icon_name (&priv->icon_helper));
break; break;
case PROP_GICON: case PROP_GICON:
g_value_set_object (value, _gtk_icon_helper_peek_gicon (priv->icon_helper)); g_value_set_object (value, _gtk_icon_helper_peek_gicon (&priv->icon_helper));
break; break;
case PROP_RESOURCE: case PROP_RESOURCE:
g_value_set_string (value, priv->resource_path); g_value_set_string (value, priv->resource_path);
break; break;
case PROP_USE_FALLBACK: case PROP_USE_FALLBACK:
g_value_set_boolean (value, _gtk_icon_helper_get_use_fallback (priv->icon_helper)); g_value_set_boolean (value, _gtk_icon_helper_get_use_fallback (&priv->icon_helper));
break; break;
case PROP_STORAGE_TYPE: case PROP_STORAGE_TYPE:
g_value_set_enum (value, _gtk_icon_helper_get_storage_type (priv->icon_helper)); g_value_set_enum (value, _gtk_icon_helper_get_storage_type (&priv->icon_helper));
break; break;
default: default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@ -782,7 +782,7 @@ gtk_image_set_from_file (GtkImage *image,
else else
gtk_image_set_from_animation (image, anim); gtk_image_set_from_animation (image, anim);
_gtk_icon_helper_set_pixbuf_scale (priv->icon_helper, scale_factor); _gtk_icon_helper_set_pixbuf_scale (&priv->icon_helper, scale_factor);
g_object_unref (anim); g_object_unref (anim);
@ -874,7 +874,7 @@ gtk_image_set_from_resource (GtkImage *image,
else else
gtk_image_set_from_animation (image, animation); gtk_image_set_from_animation (image, animation);
_gtk_icon_helper_set_pixbuf_scale (priv->icon_helper, scale_factor); _gtk_icon_helper_set_pixbuf_scale (&priv->icon_helper, scale_factor);
priv->resource_path = g_strdup (resource_path); priv->resource_path = g_strdup (resource_path);
@ -910,7 +910,7 @@ gtk_image_set_from_pixbuf (GtkImage *image,
gtk_image_clear (image); gtk_image_clear (image);
if (pixbuf != NULL) if (pixbuf != NULL)
_gtk_icon_helper_set_pixbuf (priv->icon_helper, pixbuf); _gtk_icon_helper_set_pixbuf (&priv->icon_helper, pixbuf);
g_object_notify_by_pspec (G_OBJECT (image), image_props[PROP_PIXBUF]); g_object_notify_by_pspec (G_OBJECT (image), image_props[PROP_PIXBUF]);
@ -946,7 +946,7 @@ gtk_image_set_from_animation (GtkImage *image,
if (animation != NULL) if (animation != NULL)
{ {
_gtk_icon_helper_set_animation (priv->icon_helper, animation); _gtk_icon_helper_set_animation (&priv->icon_helper, animation);
g_object_unref (animation); g_object_unref (animation);
} }
@ -981,7 +981,7 @@ gtk_image_set_from_icon_name (GtkImage *image,
gtk_image_clear (image); gtk_image_clear (image);
if (icon_name) if (icon_name)
_gtk_icon_helper_set_icon_name (priv->icon_helper, icon_name, size); _gtk_icon_helper_set_icon_name (&priv->icon_helper, icon_name, size);
g_object_notify_by_pspec (G_OBJECT (image), image_props[PROP_ICON_NAME]); g_object_notify_by_pspec (G_OBJECT (image), image_props[PROP_ICON_NAME]);
g_object_notify_by_pspec (G_OBJECT (image), image_props[PROP_ICON_SIZE]); g_object_notify_by_pspec (G_OBJECT (image), image_props[PROP_ICON_SIZE]);
@ -1019,7 +1019,7 @@ gtk_image_set_from_gicon (GtkImage *image,
if (icon) if (icon)
{ {
_gtk_icon_helper_set_gicon (priv->icon_helper, icon, size); _gtk_icon_helper_set_gicon (&priv->icon_helper, icon, size);
g_object_unref (icon); g_object_unref (icon);
} }
@ -1057,7 +1057,7 @@ gtk_image_set_from_surface (GtkImage *image,
if (surface) if (surface)
{ {
_gtk_icon_helper_set_surface (priv->icon_helper, surface); _gtk_icon_helper_set_surface (&priv->icon_helper, surface);
cairo_surface_destroy (surface); cairo_surface_destroy (surface);
} }
@ -1081,7 +1081,7 @@ gtk_image_get_storage_type (GtkImage *image)
{ {
g_return_val_if_fail (GTK_IS_IMAGE (image), GTK_IMAGE_EMPTY); g_return_val_if_fail (GTK_IS_IMAGE (image), GTK_IMAGE_EMPTY);
return _gtk_icon_helper_get_storage_type (image->priv->icon_helper); return _gtk_icon_helper_get_storage_type (&image->priv->icon_helper);
} }
/** /**
@ -1102,7 +1102,7 @@ gtk_image_get_pixbuf (GtkImage *image)
{ {
g_return_val_if_fail (GTK_IS_IMAGE (image), NULL); g_return_val_if_fail (GTK_IS_IMAGE (image), NULL);
return _gtk_icon_helper_peek_pixbuf (image->priv->icon_helper); return _gtk_icon_helper_peek_pixbuf (&image->priv->icon_helper);
} }
/** /**
@ -1127,7 +1127,7 @@ gtk_image_get_animation (GtkImage *image)
priv = image->priv; priv = image->priv;
return _gtk_icon_helper_peek_animation (priv->icon_helper); return _gtk_icon_helper_peek_animation (&priv->icon_helper);
} }
/** /**
@ -1158,10 +1158,10 @@ gtk_image_get_icon_name (GtkImage *image,
priv = image->priv; priv = image->priv;
if (icon_name) if (icon_name)
*icon_name = _gtk_icon_helper_get_icon_name (priv->icon_helper); *icon_name = _gtk_icon_helper_get_icon_name (&priv->icon_helper);
if (size) if (size)
*size = _gtk_icon_helper_get_icon_size (priv->icon_helper); *size = _gtk_icon_helper_get_icon_size (&priv->icon_helper);
} }
/** /**
@ -1192,10 +1192,10 @@ gtk_image_get_gicon (GtkImage *image,
priv = image->priv; priv = image->priv;
if (gicon) if (gicon)
*gicon = _gtk_icon_helper_peek_gicon (priv->icon_helper); *gicon = _gtk_icon_helper_peek_gicon (&priv->icon_helper);
if (size) if (size)
*size = _gtk_icon_helper_get_icon_size (priv->icon_helper); *size = _gtk_icon_helper_get_icon_size (&priv->icon_helper);
} }
/** /**
@ -1259,7 +1259,7 @@ gtk_image_unrealize (GtkWidget *widget)
gtk_image_reset_anim_iter (image); gtk_image_reset_anim_iter (image);
gtk_icon_helper_invalidate (priv->icon_helper); gtk_icon_helper_invalidate (&priv->icon_helper);
GTK_WIDGET_CLASS (gtk_image_parent_class)->unrealize (widget); GTK_WIDGET_CLASS (gtk_image_parent_class)->unrealize (widget);
} }
@ -1300,7 +1300,7 @@ get_animation_frame (GtkImage *image)
int delay; int delay;
priv->animation_iter = priv->animation_iter =
gdk_pixbuf_animation_get_iter (_gtk_icon_helper_peek_animation (priv->icon_helper), NULL); gdk_pixbuf_animation_get_iter (_gtk_icon_helper_peek_animation (&priv->icon_helper), NULL);
delay = gdk_pixbuf_animation_iter_get_delay_time (priv->animation_iter); delay = gdk_pixbuf_animation_iter_get_delay_time (priv->animation_iter);
if (delay >= 0) { if (delay >= 0) {
@ -1351,7 +1351,7 @@ gtk_image_snapshot (GtkWidget *widget,
x = 0; x = 0;
y = 0; y = 0;
_gtk_icon_helper_get_size (priv->icon_helper, &w, &h); _gtk_icon_helper_get_size (&priv->icon_helper, &w, &h);
baseline = gtk_widget_get_allocated_baseline (widget); baseline = gtk_widget_get_allocated_baseline (widget);
@ -1374,7 +1374,7 @@ gtk_image_snapshot (GtkWidget *widget,
else else
{ {
gtk_snapshot_offset (snapshot, x, y); gtk_snapshot_offset (snapshot, x, y);
gtk_icon_helper_snapshot (priv->icon_helper, snapshot); gtk_icon_helper_snapshot (&priv->icon_helper, snapshot);
gtk_snapshot_offset (snapshot, -x, -y); gtk_snapshot_offset (snapshot, -x, -y);
} }
} }
@ -1420,12 +1420,12 @@ gtk_image_set_from_definition (GtkImage *image,
if (def != NULL) if (def != NULL)
{ {
_gtk_icon_helper_set_definition (priv->icon_helper, def); _gtk_icon_helper_set_definition (&priv->icon_helper, def);
gtk_image_notify_for_storage_type (image, gtk_image_definition_get_storage_type (def)); gtk_image_notify_for_storage_type (image, gtk_image_definition_get_storage_type (def));
} }
_gtk_icon_helper_set_icon_size (priv->icon_helper, icon_size); _gtk_icon_helper_set_icon_size (&priv->icon_helper, icon_size);
g_object_thaw_notify (G_OBJECT (image)); g_object_thaw_notify (G_OBJECT (image));
} }
@ -1433,7 +1433,7 @@ gtk_image_set_from_definition (GtkImage *image,
GtkImageDefinition * GtkImageDefinition *
gtk_image_get_definition (GtkImage *image) gtk_image_get_definition (GtkImage *image)
{ {
return gtk_icon_helper_get_definition (image->priv->icon_helper); return gtk_icon_helper_get_definition (&image->priv->icon_helper);
} }
/** /**
@ -1476,7 +1476,7 @@ gtk_image_clear (GtkImage *image)
g_object_notify_by_pspec (G_OBJECT (image), image_props[PROP_RESOURCE]); g_object_notify_by_pspec (G_OBJECT (image), image_props[PROP_RESOURCE]);
} }
_gtk_icon_helper_clear (priv->icon_helper); _gtk_icon_helper_clear (&priv->icon_helper);
g_object_thaw_notify (G_OBJECT (image)); g_object_thaw_notify (G_OBJECT (image));
} }
@ -1493,7 +1493,7 @@ gtk_image_measure (GtkWidget *widget,
gint width, height; gint width, height;
float baseline_align; float baseline_align;
_gtk_icon_helper_get_size (GTK_IMAGE (widget)->priv->icon_helper, _gtk_icon_helper_get_size (&GTK_IMAGE (widget)->priv->icon_helper,
&width, &height); &width, &height);
if (orientation == GTK_ORIENTATION_HORIZONTAL) if (orientation == GTK_ORIENTATION_HORIZONTAL)
@ -1519,7 +1519,7 @@ gtk_image_style_updated (GtkWidget *widget)
GtkStyleContext *context = gtk_widget_get_style_context (widget); GtkStyleContext *context = gtk_widget_get_style_context (widget);
GtkCssStyleChange *change = gtk_style_context_get_change (context); GtkCssStyleChange *change = gtk_style_context_get_change (context);
gtk_icon_helper_invalidate_for_change (priv->icon_helper, change); gtk_icon_helper_invalidate_for_change (&priv->icon_helper, change);
GTK_WIDGET_CLASS (gtk_image_parent_class)->style_updated (widget); GTK_WIDGET_CLASS (gtk_image_parent_class)->style_updated (widget);
@ -1543,7 +1543,7 @@ gtk_image_set_pixel_size (GtkImage *image,
{ {
g_return_if_fail (GTK_IS_IMAGE (image)); g_return_if_fail (GTK_IS_IMAGE (image));
if (_gtk_icon_helper_set_pixel_size (image->priv->icon_helper, pixel_size)) if (_gtk_icon_helper_set_pixel_size (&image->priv->icon_helper, pixel_size))
{ {
if (gtk_widget_get_visible (GTK_WIDGET (image))) if (gtk_widget_get_visible (GTK_WIDGET (image)))
gtk_widget_queue_resize (GTK_WIDGET (image)); gtk_widget_queue_resize (GTK_WIDGET (image));
@ -1566,5 +1566,5 @@ gtk_image_get_pixel_size (GtkImage *image)
{ {
g_return_val_if_fail (GTK_IS_IMAGE (image), -1); g_return_val_if_fail (GTK_IS_IMAGE (image), -1);
return _gtk_icon_helper_get_pixel_size (image->priv->icon_helper); return _gtk_icon_helper_get_pixel_size (&image->priv->icon_helper);
} }