static void
gis_bubble_widget_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GisBubbleWidget *widget = GIS_BUBBLE_WIDGET (object);
GisBubbleWidgetPrivate *priv = gis_bubble_widget_get_instance_private (widget);
switch (prop_id)
{
case PROP_LABEL:
g_value_set_string (value, gtk_label_get_label (GTK_LABEL (priv->label)));
break;
case PROP_ICON_NAME:
{
const char *icon_name;
gtk_image_get_icon_name (GTK_IMAGE (priv->icon), &icon_name, NULL);
g_value_set_string (value, icon_name);
break;
}
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static GdkPixbuf *
get_image_pixbuf (GtkImage *image)
{
const gchar *icon_name;
GtkIconSize size;
GtkIconTheme *icon_theme;
int width;
switch (gtk_image_get_storage_type (image))
{
case GTK_IMAGE_PIXBUF:
return g_object_ref (gtk_image_get_pixbuf (image));
case GTK_IMAGE_ICON_NAME:
gtk_image_get_icon_name (image, &icon_name, &size);
icon_theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (GTK_WIDGET (image)));
gtk_icon_size_lookup (size, &width, NULL);
return gtk_icon_theme_load_icon (icon_theme,
icon_name,
width,
GTK_ICON_LOOKUP_GENERIC_FALLBACK,
NULL);
default:
g_warning ("Image storage type %d not handled",
gtk_image_get_storage_type (image));
return NULL;
}
}
void
image_drag_data_get (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *selection_data,
guint info,
guint time,
gpointer data)
{
GdkPixbuf *pixbuf;
const gchar *name;
switch (info)
{
case TARGET_IMAGE:
pixbuf = get_image_pixbuf (GTK_IMAGE (data));
gtk_selection_data_set_pixbuf (selection_data, pixbuf);
g_object_unref (pixbuf);
break;
case TARGET_TEXT:
if (gtk_image_get_storage_type (GTK_IMAGE (data)) == GTK_IMAGE_ICON_NAME)
gtk_image_get_icon_name (GTK_IMAGE (data), &name, NULL);
else
name = "Boo!";
gtk_selection_data_set_text (selection_data, name, -1);
break;
default:
g_assert_not_reached ();
}
}
static GtkWidget *
clone_image_menu_size (GtkImage *image)
{
GtkImageType storage_type = gtk_image_get_storage_type (image);
if (storage_type == GTK_IMAGE_STOCK)
{
gchar *stock_id;
GtkWidget *widget;
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
gtk_image_get_stock (image, &stock_id, NULL);
widget = gtk_image_new_from_stock (stock_id, GTK_ICON_SIZE_MENU);
G_GNUC_END_IGNORE_DEPRECATIONS;
return widget;
}
else if (storage_type == GTK_IMAGE_ICON_NAME)
{
const gchar *icon_name;
gtk_image_get_icon_name (image, &icon_name, NULL);
return gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_MENU);
}
else if (storage_type == GTK_IMAGE_ICON_SET)
{
GtkWidget *widget;
GtkIconSet *icon_set;
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
gtk_image_get_icon_set (image, &icon_set, NULL);
widget = gtk_image_new_from_icon_set (icon_set, GTK_ICON_SIZE_MENU);
G_GNUC_END_IGNORE_DEPRECATIONS;
return widget;
}
else if (storage_type == GTK_IMAGE_GICON)
{
GIcon *icon;
gtk_image_get_gicon (image, &icon, NULL);
return gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_MENU);
}
else if (storage_type == GTK_IMAGE_PIXBUF)
{
gint width, height;
if (gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &width, &height))
{
GdkPixbuf *src_pixbuf, *dest_pixbuf;
GtkWidget *cloned_image;
src_pixbuf = gtk_image_get_pixbuf (image);
dest_pixbuf = gdk_pixbuf_scale_simple (src_pixbuf, width, height,
GDK_INTERP_BILINEAR);
cloned_image = gtk_image_new_from_pixbuf (dest_pixbuf);
g_object_unref (dest_pixbuf);
return cloned_image;
}
}
return NULL;
}
static void
event_box_realize_cb (GtkWidget *widget, GtkImage *icon)
{
GtkImageType type;
set_drag_cursor (widget);
type = gtk_image_get_storage_type (icon);
if (type == GTK_IMAGE_STOCK)
{
gchar *stock_id;
GdkPixbuf *pixbuf;
gtk_image_get_stock (icon, &stock_id, NULL);
pixbuf = gtk_widget_render_icon (widget, stock_id,
GTK_ICON_SIZE_LARGE_TOOLBAR, NULL);
gtk_drag_source_set_icon_pixbuf (widget, pixbuf);
g_object_unref (pixbuf);
}
else if (type == GTK_IMAGE_ICON_NAME)
{
const gchar *icon_name;
GdkScreen *screen;
GtkIconTheme *icon_theme;
GtkSettings *settings;
gint width, height;
GdkPixbuf *pixbuf;
gtk_image_get_icon_name (icon, &icon_name, NULL);
screen = gtk_widget_get_screen (widget);
icon_theme = gtk_icon_theme_get_for_screen (screen);
settings = gtk_settings_get_for_screen (screen);
if (!gtk_icon_size_lookup_for_settings (settings,
GTK_ICON_SIZE_LARGE_TOOLBAR,
&width, &height))
{
width = height = 24;
}
pixbuf = gtk_icon_theme_load_icon (icon_theme, icon_name,
MIN (width, height), 0, NULL);
if (G_UNLIKELY (!pixbuf))
return;
gtk_drag_source_set_icon_pixbuf (widget, pixbuf);
g_object_unref (pixbuf);
}
else if (type == GTK_IMAGE_PIXBUF)
{
GdkPixbuf *pixbuf = gtk_image_get_pixbuf (icon);
gtk_drag_source_set_icon_pixbuf (widget, pixbuf);
}
}
const gchar *
egg_empty_state_get_icon_name (EggEmptyState *self)
{
EggEmptyStatePrivate *priv = egg_empty_state_get_instance_private (self);
const gchar *icon_name = NULL;
g_return_val_if_fail (EGG_IS_EMPTY_STATE (self), NULL);
gtk_image_get_icon_name (priv->image, &icon_name, NULL);
return icon_name;
}
static void
hd_incoming_event_window_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
HDIncomingEventWindowPrivate *priv = HD_INCOMING_EVENT_WINDOW (object)->priv;
switch (prop_id)
{
case PROP_PREVIEW:
g_value_set_boolean (value, priv->preview);
break;
case PROP_DESTINATION:
g_value_set_string (value, priv->destination);
break;
case PROP_ICON:
{
const gchar *icon_name;
gtk_image_get_icon_name (GTK_IMAGE (priv->icon), &icon_name, NULL);
g_value_set_string (value, icon_name);
}
break;
case PROP_TITLE:
g_value_set_string (value, gtk_label_get_label (GTK_LABEL (priv->title)));
break;
case PROP_TIME:
g_value_set_long (value, priv->time);
break;
case PROP_AMOUNT:
g_value_set_ulong (value, priv->amount);
break;
case PROP_MESSAGE:
g_value_set_string (value, gtk_label_get_label (GTK_LABEL (priv->message)));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
item_activated (GtkMenuItem * item, gpointer picker)
{
NldSearchContextPickerPrivate *priv = NLD_SEARCH_CONTEXT_PICKER_GET_PRIVATE (picker);
GtkImage *image;
const char *icon_name;
GtkIconSize icon_size;
image = GTK_IMAGE (gtk_image_menu_item_get_image (GTK_IMAGE_MENU_ITEM (item)));
gtk_image_get_icon_name (image, &icon_name, &icon_size);
gtk_image_set_from_icon_name (priv->cur_icon, icon_name, icon_size);
priv->cur_context =
GPOINTER_TO_INT (g_object_get_data (G_OBJECT (item),
"NldSearchContextPicker:context_id"));
g_signal_emit (picker, signals[CONTEXT_CHANGED], 0);
}
/**
* gtk_button_get_icon_name:
* @button: A #GtkButton
*
* Returns the icon name set via gtk_button_set_icon_name().
*
* Returns: (nullable): The icon name set via gtk_button_set_icon_name()
*
* Since: 3.90
*/
const char *
gtk_button_get_icon_name (GtkButton *button)
{
GtkButtonPrivate *priv = gtk_button_get_instance_private (button);
g_return_val_if_fail (GTK_IS_BUTTON (button), NULL);
if (priv->child_type == ICON_CHILD)
{
const char *icon_name;
GtkWidget *child = gtk_bin_get_child (GTK_BIN (button));
gtk_image_get_icon_name (GTK_IMAGE (child), &icon_name, NULL);
return icon_name;
}
return NULL;
}
static void
event_box_realize (GtkWidget *widget,
GtkImage *image)
{
GtkImageType type;
GdkPixbuf *pixbuf;
const gchar *icon_name;
_exo_toolbars_set_drag_cursor (widget);
type = gtk_image_get_storage_type (image);
if (type == GTK_IMAGE_ICON_NAME)
{
gtk_image_get_icon_name (image, &icon_name, NULL);
if (icon_name != NULL)
gtk_drag_source_set_icon_name (widget, icon_name);
}
else if (type == GTK_IMAGE_PIXBUF)
{
pixbuf = gtk_image_get_pixbuf (image);
if (G_LIKELY (pixbuf != NULL))
gtk_drag_source_set_icon_pixbuf (widget, pixbuf);
}
}
static GdkPaintable *
get_image_paintable (GtkImage *image)
{
const gchar *icon_name;
GtkIconTheme *icon_theme;
GtkIconInfo *icon_info;
switch (gtk_image_get_storage_type (image))
{
case GTK_IMAGE_PAINTABLE:
return g_object_ref (gtk_image_get_paintable (image));
case GTK_IMAGE_ICON_NAME:
icon_name = gtk_image_get_icon_name (image);
icon_theme = gtk_icon_theme_get_for_display (gtk_widget_get_display (GTK_WIDGET (image)));
icon_info = gtk_icon_theme_lookup_icon (icon_theme, icon_name, 48, GTK_ICON_LOOKUP_GENERIC_FALLBACK);
if (icon_info == NULL)
return NULL;
return GDK_PAINTABLE (gtk_icon_info_load_texture (icon_info));
default:
g_warning ("Image storage type %d not handled",
gtk_image_get_storage_type (image));
return NULL;
}
}
static void
hd_incoming_event_window_realize (GtkWidget *widget)
{
HDIncomingEventWindowPrivate *priv = HD_INCOMING_EVENT_WINDOW (widget)->priv;
GdkScreen *screen;
const gchar *notification_type, *icon;
GtkIconSize icon_size;
GdkPixmap *pixmap;
cairo_t *cr;
screen = gtk_widget_get_screen (widget);
gtk_widget_set_colormap (widget,
gdk_screen_get_rgba_colormap (screen));
gtk_widget_set_app_paintable (widget,
TRUE);
gtk_window_set_decorated (GTK_WINDOW (widget), FALSE);
GTK_WIDGET_CLASS (hd_incoming_event_window_parent_class)->realize (widget);
/* Notification window */
gdk_window_set_type_hint (widget->window, GDK_WINDOW_TYPE_HINT_NOTIFICATION);
/* Set the _NET_WM_WINDOW_TYPE property to _HILDON_WM_WINDOW_TYPE_HOME_APPLET */
if (priv->preview)
notification_type = "_HILDON_NOTIFICATION_TYPE_PREVIEW";
else
notification_type = "_HILDON_NOTIFICATION_TYPE_INCOMING_EVENT";
hd_incoming_event_window_set_string_xwindow_property (widget,
"_HILDON_NOTIFICATION_TYPE",
notification_type);
/* Assume the properties have already been set. Earlier these X window
* properties couldn't be set because we weren't realized. */
gtk_image_get_icon_name (GTK_IMAGE (priv->icon), &icon, &icon_size);
hd_incoming_event_window_set_string_xwindow_property (widget,
"_HILDON_INCOMING_EVENT_NOTIFICATION_ICON",
icon);
hd_incoming_event_window_set_string_xwindow_property (widget,
"_HILDON_INCOMING_EVENT_NOTIFICATION_SUMMARY",
gtk_label_get_text (GTK_LABEL (priv->title)));
hd_incoming_event_window_set_string_xwindow_property (widget,
"_HILDON_INCOMING_EVENT_NOTIFICATION_MESSAGE",
gtk_label_get_label (GTK_LABEL (priv->message)));
hd_incoming_event_window_set_string_xwindow_property (widget,
"_HILDON_INCOMING_EVENT_NOTIFICATION_DESTINATION",
priv->destination);
/* Update time of nopreview windows */
if (!priv->preview && hd_incoming_events_get_display_on ())
hd_incoming_event_window_update_time (HD_INCOMING_EVENT_WINDOW (widget));
hd_incoming_event_window_update_title_and_amount (HD_INCOMING_EVENT_WINDOW (widget));
/* Set background to transparent pixmap */
pixmap = gdk_pixmap_new (GDK_DRAWABLE (widget->window), 1, 1, -1);
cr = gdk_cairo_create (GDK_DRAWABLE (pixmap));
cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
cairo_set_source_rgba (cr, 0.0, 0.0, 0.0, 0.0);
cairo_paint (cr);
cairo_destroy (cr);
gdk_window_set_back_pixmap (widget->window, pixmap, FALSE);
g_object_unref(pixmap);
}
