static void
xfdesktop_regular_file_icon_finalize(GObject *obj)
{
XfdesktopRegularFileIcon *icon = XFDESKTOP_REGULAR_FILE_ICON(obj);
GtkIconTheme *itheme = gtk_icon_theme_get_for_screen(icon->priv->gscreen);
g_signal_handlers_disconnect_by_func(G_OBJECT(itheme),
G_CALLBACK(xfdesktop_icon_invalidate_pixbuf),
icon);
if(icon->priv->file_info)
g_object_unref(icon->priv->file_info);
if(icon->priv->filesystem_info)
g_object_unref(icon->priv->filesystem_info);
g_object_unref(icon->priv->file);
g_free(icon->priv->display_name);
if(icon->priv->tooltip)
g_free(icon->priv->tooltip);
if(icon->priv->thumbnail_file)
g_object_unref(icon->priv->thumbnail_file);
if(icon->priv->monitor)
g_object_unref(icon->priv->monitor);
G_OBJECT_CLASS(xfdesktop_regular_file_icon_parent_class)->finalize(obj);
}
static void
on_notebook_drag_begin (GtkWidget *widget,
GdkDragContext *context,
gpointer data)
{
GdkPixbuf *pixbuf;
guint page_num;
page_num = gtk_notebook_get_current_page (GTK_NOTEBOOK (widget));
if (page_num > 2)
{
GtkIconTheme *icon_theme;
int width;
icon_theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (widget));
gtk_icon_size_lookup (GTK_ICON_SIZE_DND, &width, NULL);
pixbuf = gtk_icon_theme_load_icon (icon_theme,
(page_num % 2) ? "help-browser" : "process-stop",
width,
GTK_ICON_LOOKUP_GENERIC_FALLBACK,
NULL);
gtk_drag_set_icon_pixbuf (context, pixbuf, 0, 0);
g_object_unref (pixbuf);
}
}
static void
from_gicon (GtkSourcePixbufHelper *helper,
GtkWidget *widget,
gint size)
{
GdkScreen *screen;
GtkIconTheme *icon_theme;
GtkIconInfo *info;
GtkIconLookupFlags flags;
screen = gtk_widget_get_screen (widget);
icon_theme = gtk_icon_theme_get_for_screen (screen);
flags = GTK_ICON_LOOKUP_USE_BUILTIN;
info = gtk_icon_theme_lookup_by_gicon (icon_theme,
helper->gicon,
size,
flags);
if (info)
{
set_cache (helper, gtk_icon_info_load_icon (info, NULL));
}
}
static CanvasItem*
canvas_item_new (GtkWidget *widget,
GtkToolButton *button,
gdouble x,
gdouble y)
{
CanvasItem *item = NULL;
const gchar *icon_name;
GdkPixbuf *pixbuf;
GtkIconTheme *icon_theme;
int width;
icon_name = gtk_tool_button_get_icon_name (button);
icon_theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (widget));
gtk_icon_size_lookup (GTK_ICON_SIZE_DIALOG, &width, NULL);
pixbuf = gtk_icon_theme_load_icon (icon_theme,
icon_name,
width,
GTK_ICON_LOOKUP_GENERIC_FALLBACK,
NULL);
if (pixbuf)
{
item = g_slice_new0 (CanvasItem);
item->pixbuf = pixbuf;
item->x = x;
item->y = y;
}
return item;
}
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;
}
}
static void
ev_stock_icons_add_icons_path_for_screen (GdkScreen *screen)
{
GtkIconTheme *icon_theme;
g_return_if_fail (ev_icons_path != NULL);
icon_theme = screen ? gtk_icon_theme_get_for_screen (screen) : gtk_icon_theme_get_default ();
if (icon_theme) {
gchar **path = NULL;
gint n_paths;
gint i;
/* GtkIconTheme will then look in Atril custom hicolor dir
* for icons as well as the standard search paths
*/
gtk_icon_theme_get_search_path (icon_theme, &path, &n_paths);
for (i = n_paths - 1; i >= 0; i--) {
if (g_ascii_strcasecmp (ev_icons_path, path[i]) == 0)
break;
}
if (i < 0)
gtk_icon_theme_append_search_path (icon_theme,
ev_icons_path);
g_strfreev (path);
}
}
static GtkCssImage *
gtk_css_image_icon_theme_compute (GtkCssImage *image,
guint property_id,
GtkStyleProviderPrivate *provider,
int scale,
GtkCssComputedValues *values,
GtkCssComputedValues *parent_values,
GtkCssDependencies *dependencies)
{
GtkCssImageIconTheme *icon_theme = GTK_CSS_IMAGE_ICON_THEME (image);
GtkCssImageIconTheme *copy;
GtkSettings *settings;
GdkScreen *screen;
settings = _gtk_style_provider_private_get_settings (provider);
if (settings == NULL)
screen = gdk_screen_get_default ();
else
screen = _gtk_settings_get_screen (settings);
copy = g_object_new (GTK_TYPE_CSS_IMAGE_ICON_THEME, NULL);
copy->name = g_strdup (icon_theme->name);
copy->icon_theme = gtk_icon_theme_get_for_screen (screen);
copy->scale = scale;
copy->color = *_gtk_css_rgba_value_get_rgba (_gtk_css_computed_values_get_value (values, GTK_CSS_PROPERTY_COLOR));
*dependencies = GTK_CSS_DEPENDS_ON_COLOR;
return GTK_CSS_IMAGE (copy);
}
static void show_desktop_applet_realized(MatePanelApplet* applet, gpointer data)
{
ShowDesktopData* sdd;
GdkScreen* screen;
sdd = (ShowDesktopData*) data;
if (sdd->matewnck_screen != NULL)
g_signal_handlers_disconnect_by_func(sdd->matewnck_screen, show_desktop_changed_callback, sdd);
if (sdd->icon_theme != NULL)
g_signal_handlers_disconnect_by_func(sdd->icon_theme, theme_changed_callback, sdd);
screen = gtk_widget_get_screen(sdd->applet);
sdd->matewnck_screen = matewnck_screen_get(gdk_screen_get_number (screen));
if (sdd->matewnck_screen != NULL)
wncklet_connect_while_alive(sdd->matewnck_screen, "showing_desktop_changed", G_CALLBACK(show_desktop_changed_callback), sdd, sdd->applet);
else
g_warning("Could not get MatewnckScreen!");
show_desktop_changed_callback(sdd->matewnck_screen, sdd);
sdd->icon_theme = gtk_icon_theme_get_for_screen (screen);
wncklet_connect_while_alive(sdd->icon_theme, "changed", G_CALLBACK(theme_changed_callback), sdd, sdd->applet);
update_icon (sdd);
}
static GdkPixbuf *
load_pixbuf (GsdMediaKeysWindow *window,
const char *name,
int icon_size)
{
GtkIconTheme *theme;
GdkPixbuf *pixbuf;
if (window != NULL && gtk_widget_has_screen (GTK_WIDGET (window))) {
theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (GTK_WIDGET (window)));
} else {
theme = gtk_icon_theme_get_default ();
}
pixbuf = gtk_icon_theme_load_icon (theme,
name,
icon_size,
GTK_ICON_LOOKUP_FORCE_SVG,
NULL);
/* make sure the pixbuf is close to the requested size
* this is necessary because GTK_ICON_LOOKUP_FORCE_SVG
* seems to be broken */
if (pixbuf != NULL) {
int width;
width = gdk_pixbuf_get_width (pixbuf);
if (width < (float)icon_size * 0.75) {
g_object_unref (pixbuf);
pixbuf = NULL;
}
}
return pixbuf;
}
static void
xfdesktop_special_file_icon_finalize(GObject *obj)
{
XfdesktopSpecialFileIcon *icon = XFDESKTOP_SPECIAL_FILE_ICON(obj);
GtkIconTheme *itheme = gtk_icon_theme_get_for_screen(icon->priv->gscreen);
g_signal_handlers_disconnect_by_func(G_OBJECT(itheme),
G_CALLBACK(xfdesktop_icon_invalidate_pixbuf),
icon);
if(icon->priv->monitor) {
g_signal_handlers_disconnect_by_func(icon->priv->monitor,
G_CALLBACK(xfdesktop_special_file_icon_changed),
icon);
g_object_unref(icon->priv->monitor);
}
g_object_unref(icon->priv->file);
if(icon->priv->file_info)
g_object_unref(icon->priv->file_info);
if(icon->priv->tooltip)
g_free(icon->priv->tooltip);
G_OBJECT_CLASS(xfdesktop_special_file_icon_parent_class)->finalize(obj);
}
static void
bigboard_button_applet_realized (PanelApplet *applet,
gpointer data)
{
ButtonData *button_data;
GdkScreen *screen;
button_data = (ButtonData *) data;
if (button_data->icon_theme != NULL)
g_signal_handlers_disconnect_by_func (button_data->icon_theme,
theme_changed_callback,
button_data);
screen = gtk_widget_get_screen (button_data->applet);
button_data->icon_theme = gtk_icon_theme_get_for_screen (screen);
wncklet_connect_while_alive (button_data->icon_theme, "changed",
G_CALLBACK (theme_changed_callback),
button_data,
button_data->applet);
button_data->suppress_popout_set = TRUE;
update_button_state (button_data);
button_data->suppress_popout_set = FALSE;
}
static void
ensure_pixbuf_for_gicon (GtkIconHelper *self,
GtkStyleContext *context)
{
GtkIconTheme *icon_theme;
gint width, height;
GtkIconInfo *info;
GtkIconLookupFlags flags;
if (!check_invalidate_pixbuf (self, context))
return;
icon_theme = gtk_icon_theme_get_for_screen (gtk_style_context_get_screen (context));
flags = get_icon_lookup_flags (self, context);
ensure_icon_size (self, context, &width, &height);
if (self->priv->gicon != NULL)
{
info = gtk_icon_theme_lookup_by_gicon (icon_theme,
self->priv->gicon,
MIN (width, height), flags);
}
else
{
g_assert_not_reached ();
return;
}
self->priv->rendered_pixbuf = ensure_stated_icon_from_info (self, context, info);
if (info)
g_object_unref (info);
}
void
gth_application_activate_about (GSimpleAction *action,
GVariant *parameter,
gpointer user_data)
{
GApplication *application = user_data;
GthWindow *window;
const char *authors[] = {
#include "AUTHORS.tab"
NULL
};
const char *documenters [] = {
"Paolo Bacchilega",
"Alexander Kirillov",
NULL
};
char *license_text;
const char *license[] = {
N_("gThumb is free software; you can redistribute it and/or modify "
"it under the terms of the GNU General Public License as published by "
"the Free Software Foundation; either version 2 of the License, or "
"(at your option) any later version."),
N_("gThumb is distributed in the hope that it will be useful, "
"but WITHOUT ANY WARRANTY; without even the implied warranty of "
"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the "
"GNU General Public License for more details."),
N_("You should have received a copy of the GNU General Public License "
"along with gThumb. If not, see http://www.gnu.org/licenses/.")
};
GdkPixbuf *logo;
window = (GthWindow *) _gth_application_get_current_window (application);
license_text = g_strconcat (_(license[0]), "\n\n",
_(license[1]), "\n\n",
_(license[2]),
NULL);
logo = gtk_icon_theme_load_icon (gtk_icon_theme_get_for_screen (gtk_widget_get_screen (GTK_WIDGET (window))),
"gthumb",
128,
GTK_ICON_LOOKUP_NO_SVG,
NULL);
gtk_show_about_dialog (GTK_WINDOW (window),
"version", VERSION,
"copyright", "Copyright \xc2\xa9 2001-2013 Free Software Foundation, Inc.",
"comments", _("An image viewer and browser for GNOME."),
"authors", authors,
"documenters", documenters,
"translator-credits", _("translator-credits"),
"license", license_text,
"wrap-license", TRUE,
"website", "http://live.gnome.org/Apps/gthumb",
(logo != NULL ? "logo" : NULL), logo,
NULL);
_g_object_unref (logo);
g_free (license_text);
}
static void icon_gicon(pqi inst, GIcon* icon, int size)
{
GtkIconTheme *ithm = gtk_icon_theme_get_for_screen(gtk_widget_get_screen(inst->box)); /* Get the image theme of our box. */
GtkIconInfo *iinfo = gtk_icon_theme_lookup_by_gicon(ithm, icon, size, 0); /* We need the pixbuf of our icon. */
inst->pmainicon = gtk_icon_info_load_icon(iinfo, NULL); /* Now we're cooking with gas. */
inst->pmainicon_glow = make_bright_pixbuf(inst->pmainicon);
g_object_ref(inst->pmainicon); g_object_ref(inst->pmainicon_glow);
}
static gboolean
xfce_panel_image_load (gpointer data)
{
XfcePanelImagePrivate *priv = XFCE_PANEL_IMAGE (data)->priv;
GdkPixbuf *pixbuf;
GdkScreen *screen;
GtkIconTheme *icon_theme = NULL;
gint dest_w, dest_h;
GDK_THREADS_ENTER ();
dest_w = priv->width;
dest_h = priv->height;
if (G_UNLIKELY (priv->force_icon_sizes
&& dest_w < 32
&& dest_w == dest_h))
{
/* we use some hardcoded values here for convienence,
* above 32 pixels svg icons will kick in */
if (dest_w > 16 && dest_w < 22)
dest_w = 16;
else if (dest_w > 22 && dest_w < 24)
dest_w = 22;
else if (dest_w > 24 && dest_w < 32)
dest_w = 24;
dest_h = dest_w;
}
if (priv->pixbuf != NULL)
{
/* use the pixbuf set by the user */
pixbuf = g_object_ref (G_OBJECT (priv->pixbuf));
if (G_LIKELY (pixbuf != NULL))
{
/* scale the icon to the correct size */
priv->cache = xfce_panel_image_scale_pixbuf (pixbuf, dest_w, dest_h);
g_object_unref (G_OBJECT (pixbuf));
}
}
else
{
screen = gtk_widget_get_screen (GTK_WIDGET (data));
if (G_LIKELY (screen != NULL))
icon_theme = gtk_icon_theme_get_for_screen (screen);
priv->cache = xfce_panel_pixbuf_from_source_at_size (priv->source, icon_theme, dest_w, dest_h);
}
if (G_LIKELY (priv->cache != NULL))
gtk_widget_queue_draw (GTK_WIDGET (data));
GDK_THREADS_LEAVE ();
return FALSE;
}
/**
* gul_gui_image_set_from_mime_type:
* @image: a #GtkImage
* @mime_type: a MIME type
* @icon_size: a stock icon size
*
* Set the @image to display the icon for MIME type @mime_type. Sample MIME
* types are "text/plain", "application/ogg". Sample stock sizes are
* #GTK_ICON_SIZE_MENU, #GTK_ICON_SIZE_DIALOG.
*/
void
gul_gui_image_set_from_mime_type (GtkWidget *image,
const char *mime_type,
GtkIconSize icon_size)
{
GtkIconTheme *theme;
char *icon;
GtkIconSource *source;
GtkIconSet *icon_set;
g_return_if_fail (GTK_IS_IMAGE(image));
g_return_if_fail (mime_type != NULL);
theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (image));
icon = gnome_icon_lookup (theme, NULL, NULL, NULL, NULL,
mime_type,
GNOME_ICON_LOOKUP_FLAGS_NONE, NULL);
if (!g_path_is_absolute (icon))
{
int width, height;
GtkIconInfo *icon_info;
if (!gtk_icon_size_lookup_for_settings
(gtk_widget_get_settings (GTK_WIDGET(image)),
icon_size, &width, &height))
{
width = height = -1;
}
icon_info = gtk_icon_theme_lookup_icon (theme, icon, height,0);
g_free (icon);
g_return_if_fail (icon_info != NULL);
icon = g_strdup (gtk_icon_info_get_filename (icon_info));
gtk_icon_info_free (icon_info);
}
/* Now that we have the icon filename, wrap it into an GtkIconSet so
* that we really get the desired size; the icon size in the file may
* still be arbitrary, in case of SVG themes, for example.
*/
source = gtk_icon_source_new ();
gtk_icon_source_set_filename (source, icon);
g_free (icon);
icon_set = gtk_icon_set_new ();
gtk_icon_set_add_source (icon_set, source);
gtk_icon_source_free (source);
gtk_image_set_from_icon_set (GTK_IMAGE(image), icon_set, icon_size);
gtk_icon_set_unref (icon_set);
}
static void
load_icon_items (GtkToolPalette *palette)
{
GList *contexts;
GList *l;
GtkIconTheme *icon_theme;
icon_theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (GTK_WIDGET (palette)));
contexts = gtk_icon_theme_list_contexts (icon_theme);
for (l = contexts; l; l = g_list_next (l))
{
gchar *context = l->data;
GList *icon_names;
GList *ll;
const guint max_icons = 10;
guint icons_count = 0;
GtkWidget *group = gtk_tool_item_group_new (context);
gtk_container_add (GTK_CONTAINER (palette), group);
if (g_strcmp0 (context, "Animations") == 0)
continue;
g_message ("Got context '%s'", context);
icon_names = gtk_icon_theme_list_icons (icon_theme, context);
icon_names = g_list_sort (icon_names, (GCompareFunc) strcmp);
for (ll = icon_names; ll; ll = g_list_next (ll))
{
GtkToolItem *item;
gchar *id = ll->data;
if (g_str_equal (id, "emblem-desktop"))
continue;
if (g_str_has_suffix (id, "-symbolic"))
continue;
g_message ("Got id '%s'", id);
item = gtk_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), id);
gtk_tool_item_set_tooltip_text (GTK_TOOL_ITEM (item), id);
gtk_tool_item_group_insert (GTK_TOOL_ITEM_GROUP (group), item, -1);
/* Prevent us having an insane number of icons: */
++icons_count;
if(icons_count >= max_icons)
break;
}
g_list_free_full (icon_names, g_free);
}
g_list_free_full (contexts, g_free);
}
static void
xfce_xkb_construct (XfcePanelPlugin *plugin)
{
GtkWidget *configure_layouts;
GtkIconTheme *theme;
GtkWidget *image;
GdkPixbuf *pixbuf;
t_xkb *xkb = xkb_new (plugin);
xfce_textdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR, "UTF-8");
xfce_panel_plugin_set_small (plugin, TRUE);
g_signal_connect (plugin, "orientation-changed",
G_CALLBACK (xfce_xkb_orientation_changed), xkb);
g_signal_connect (plugin, "size-changed",
G_CALLBACK (xfce_xkb_set_size), xkb);
g_signal_connect (plugin, "free-data",
G_CALLBACK (xfce_xkb_free_data), xkb);
g_signal_connect (plugin, "save",
G_CALLBACK (xfce_xkb_save_config), xkb);
xfce_panel_plugin_menu_show_configure (plugin);
g_signal_connect (plugin, "configure-plugin",
G_CALLBACK (xfce_xkb_configure), xkb);
xfce_panel_plugin_menu_show_about (plugin);
g_signal_connect (plugin, "about",
G_CALLBACK (xfce_xkb_about), xkb);
configure_layouts =
gtk_menu_item_new_with_label (_("Keyboard settings"));
theme = gtk_icon_theme_get_for_screen (gdk_screen_get_default());
pixbuf = gtk_icon_theme_load_icon (theme, "preferences-desktop-keyboard",
GTK_ICON_SIZE_MENU, 0, NULL);
if (pixbuf != NULL)
{
image = gtk_image_new ();
gtk_image_set_from_pixbuf (GTK_IMAGE (image), pixbuf);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (configure_layouts),
image);
g_object_unref (pixbuf);
}
gtk_widget_show (configure_layouts);
xfce_panel_plugin_menu_insert_item (plugin,
GTK_MENU_ITEM (configure_layouts));
g_signal_connect (G_OBJECT (configure_layouts), "activate",
G_CALLBACK (xfce_xkb_configure_layout), NULL);
}
/**
* gtk_clutter_texture_set_from_icon_name:
* @texture: a #GtkClutterTexture
* @widget: (allow-none): a #GtkWidget or %NULL
* @icon_name: the name of the icon
* @icon_size: the icon size or -1
* @error: a return location for errors, or %NULL
*
* Sets the contents of @texture using the @icon_name from the
* current icon theme.
*
* Return value: %TRUE on success, %FALSE on failure
*
* Since: 1.0
*/
gboolean
gtk_clutter_texture_set_from_icon_name (GtkClutterTexture *texture,
GtkWidget *widget,
const gchar *icon_name,
GtkIconSize icon_size,
GError **error)
{
GError *local_error = NULL;
GtkSettings *settings;
GtkIconTheme *icon_theme;
gboolean returnval;
gint width, height;
GdkPixbuf *pixbuf;
g_return_val_if_fail (CLUTTER_IS_TEXTURE (texture), FALSE);
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
g_return_val_if_fail (icon_name != NULL, FALSE);
g_return_val_if_fail ((icon_size > GTK_ICON_SIZE_INVALID) || (icon_size == -1), FALSE);
if (widget && gtk_widget_has_screen (widget))
{
GdkScreen *screen;
screen = gtk_widget_get_screen (widget);
settings = gtk_settings_get_for_screen (screen);
icon_theme = gtk_icon_theme_get_for_screen (screen);
}
else
{
settings = gtk_settings_get_default ();
icon_theme = gtk_icon_theme_get_default ();
}
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
if (icon_size == -1 ||
!gtk_icon_size_lookup_for_settings (settings, icon_size, &width, &height))
{
width = height = 48;
}
G_GNUC_END_IGNORE_DEPRECATIONS
pixbuf = gtk_icon_theme_load_icon (icon_theme,
icon_name,
MIN (width, height), 0,
&local_error);
if (local_error)
{
g_propagate_error (error, local_error);
return FALSE;
}
returnval = gtk_clutter_texture_set_from_pixbuf (texture, pixbuf, error);
g_object_unref (pixbuf);
return returnval;
}
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);
}
}
static void
xplayer_fullscreen_window_unrealize_cb (GtkWidget *widget, XplayerFullscreen *fs)
{
GdkScreen *screen;
screen = gtk_widget_get_screen (widget);
g_signal_handlers_disconnect_by_func (screen,
G_CALLBACK (xplayer_fullscreen_size_changed_cb), fs);
g_signal_handlers_disconnect_by_func (gtk_icon_theme_get_for_screen (screen),
G_CALLBACK (xplayer_fullscreen_theme_changed_cb), fs);
}
GthIconCache *
gth_icon_cache_new_for_widget (GtkWidget *widget,
GtkIconSize icon_size)
{
GtkIconTheme *icon_theme;
int pixel_size;
icon_theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (widget));
pixel_size = _gtk_icon_get_pixel_size (widget, GTK_ICON_SIZE_MENU);
return gth_icon_cache_new (icon_theme, pixel_size);
}
static void
xplayer_fullscreen_window_realize_cb (GtkWidget *widget, XplayerFullscreen *fs)
{
GdkScreen *screen;
screen = gtk_widget_get_screen (widget);
g_signal_connect (G_OBJECT (screen), "size-changed",
G_CALLBACK (xplayer_fullscreen_size_changed_cb), fs);
g_signal_connect (G_OBJECT (gtk_icon_theme_get_for_screen (screen)),
"changed",
G_CALLBACK (xplayer_fullscreen_theme_changed_cb), fs);
}
static void
applet_realized (PanelApplet *applet,
TasklistData *tasklist)
{
WnckScreen *screen;
screen = wncklet_get_screen (GTK_WIDGET (applet));
wnck_tasklist_set_screen (WNCK_TASKLIST (tasklist->tasklist), screen);
tasklist->icon_theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (tasklist->applet));
}
static GdkPixbuf *
gimp_view_renderer_imagefile_get_icon (GimpImagefile *imagefile,
GtkWidget *widget,
gint size)
{
GdkScreen *screen = gtk_widget_get_screen (widget);
GtkIconTheme *icon_theme = gtk_icon_theme_get_for_screen (screen);
GimpThumbnail *thumbnail = gimp_imagefile_get_thumbnail (imagefile);
GdkPixbuf *pixbuf = NULL;
if (! gimp_object_get_name (imagefile))
return NULL;
if (! pixbuf)
{
GIcon *icon = gimp_imagefile_get_gicon (imagefile);
if (icon)
{
GtkIconInfo *info;
info = gtk_icon_theme_lookup_by_gicon (icon_theme, icon, size, 0);
if (info)
{
pixbuf = gtk_icon_info_load_icon (info, NULL);
gtk_icon_info_free (info);
}
}
}
if (! pixbuf && thumbnail->image_mimetype)
{
pixbuf = get_icon_for_mime_type (thumbnail->image_mimetype, size);
}
if (! pixbuf)
{
const gchar *icon_name = "text-x-generic";
if (thumbnail->image_state == GIMP_THUMB_STATE_FOLDER)
icon_name = "folder";
pixbuf = gtk_icon_theme_load_icon (icon_theme,
icon_name, size,
GTK_ICON_LOOKUP_USE_BUILTIN,
NULL);
}
return pixbuf;
}
static void
update_preview_cb (GtkFileChooser *chooser)
{
gchar *filename = gtk_file_chooser_get_preview_filename (chooser);
GtkWidget *label = g_object_get_data (G_OBJECT (chooser), "label-widget");
GtkWidget *image = g_object_get_data (G_OBJECT (chooser), "image-widget");
if (filename == NULL) {
gtk_widget_hide (image);
gtk_widget_hide (label);
} else if (g_file_test (filename, G_FILE_TEST_IS_DIR)) {
/* Not quite sure what to do here. */
gtk_widget_hide (image);
gtk_widget_hide (label);
} else {
GdkPixbuf *buf;
gboolean dummy;
buf = gdk_pixbuf_new_from_file (filename, NULL);
if (buf) {
dummy = FALSE;
} else {
GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (chooser));
buf = gtk_icon_theme_load_icon
(gtk_icon_theme_get_for_screen (screen),
"unknown_image", 100, 100, NULL);
dummy = buf != NULL;
}
if (buf) {
GdkPixbuf *pixbuf = go_pixbuf_intelligent_scale (buf, PREVIEW_HSIZE, PREVIEW_VSIZE);
gtk_image_set_from_pixbuf (GTK_IMAGE (image), pixbuf);
g_object_unref (pixbuf);
gtk_widget_show (image);
if (dummy)
gtk_label_set_text (GTK_LABEL (label), "");
else {
int w = gdk_pixbuf_get_width (buf);
int h = gdk_pixbuf_get_height (buf);
char *size = g_strdup_printf (_("%d x %d"), w, h);
gtk_label_set_text (GTK_LABEL (label), size);
g_free (size);
}
gtk_widget_show (label);
g_object_unref (buf);
}
g_free (filename);
}
}
static void
task_title_setup (TaskTitle *title)
{
TaskTitlePrivate *priv = title->priv;
priv->screen = wnck_screen_get_default ();
priv->window = NULL;
gtk_widget_add_events (GTK_WIDGET (title), GDK_ALL_EVENTS_MASK);
priv->align = gtk_alignment_new (0.0, 0.0, 1.0, 1.0);
gtk_alignment_set_padding (GTK_ALIGNMENT (priv->align),
0, 0, 6, 6);
gtk_container_add (GTK_CONTAINER (title), priv->align);
priv->grid = gtk_grid_new();
gtk_grid_set_row_spacing (GTK_GRID(priv->grid), 2);
gtk_container_add (GTK_CONTAINER (priv->align), priv->grid);
gtk_widget_set_no_show_all (priv->grid, TRUE);
gtk_widget_show (priv->grid);
//Prepare and show the title label
priv->label = getTitleLabel();
gtk_grid_attach (GTK_GRID(priv->grid), priv->label, 0, 0, 1, 1);
gtk_widget_show (priv->label);
//Create the close button
priv->button = getCloseButton (title);
gtk_grid_attach (GTK_GRID(priv->grid), priv->button, 1, 0, 1, 1);
gtk_widget_show (priv->button);
g_signal_connect (GTK_WIDGET(title), "draw",
G_CALLBACK (on_draw), title);
// Prepare and add the logoff icon to the title
GdkScreen *gdkscreen = gtk_widget_get_screen (GTK_WIDGET (title));
GtkIconTheme *theme = gtk_icon_theme_get_for_screen (gdkscreen);
//this shows a little green exit icon, like the ones on emergency exits
priv->quit_icon = gtk_icon_theme_load_icon (
theme, "gnome-logout", 16, 0, NULL
);
priv->button_image = gtk_image_new_from_pixbuf (priv->quit_icon);
gtk_container_add (GTK_CONTAINER (priv->button), priv->button_image);
gtk_widget_show (priv->button_image);
gtk_widget_set_tooltip_text (priv->button,
_("Log off, switch user, lock screen or "
"power down the computer")
);
gtk_widget_set_tooltip_text (GTK_WIDGET (title), _("Home"));
gtk_widget_add_events (GTK_WIDGET (title), GDK_ALL_EVENTS_MASK);
g_signal_connect (priv->screen, "active-window-changed",
G_CALLBACK (on_active_window_changed), title);
g_signal_connect (title, "button-press-event",
G_CALLBACK (on_button_press), NULL);
}
static void
gth_window_realize (GtkWidget *widget)
{
GTK_WIDGET_CLASS (gth_window_parent_class)->realize (widget);
gtk_icon_theme_append_search_path (gtk_icon_theme_get_for_screen (gtk_widget_get_screen (widget)), GTHUMB_ICON_DIR);
_gth_window_add_css_provider (widget, "/org/gnome/gThumb/resources/gthumb.css");
if ((gtk_major_version >= 3) && (gtk_minor_version >= 14))
_gth_window_add_css_provider (widget, "/org/gnome/gThumb/resources/gthumb-gtk314.css");
else if ((gtk_major_version >= 3) && (gtk_minor_version >= 10))
_gth_window_add_css_provider (widget, "/org/gnome/gThumb/resources/gthumb-gtk312.css");
}
void
gtk_icon_entry_set_icon_from_gicon (const GtkIconEntry *entry,
GtkIconEntryPosition icon_pos,
GIcon *icon)
{
GdkPixbuf *pixbuf = NULL;
GtkIconEntryPrivate *priv;
EntryIconInfo *icon_info;
GdkScreen *screen;
GtkIconTheme *icon_theme;
GtkSettings *settings;
gint width, height;
GError *error = NULL;
GtkIconInfo *info;
priv = GTK_ICON_ENTRY_GET_PRIVATE (entry);
icon_info = &priv->icons[icon_pos];
screen = gtk_widget_get_screen (GTK_WIDGET (entry));
icon_theme = gtk_icon_theme_get_for_screen (screen);
settings = gtk_settings_get_for_screen (screen);
if (icon != NULL)
{
gtk_icon_size_lookup_for_settings (settings,
GTK_ICON_SIZE_MENU,
&width, &height);
#if #GTK_CHECK_VERSION (2, 14, 0)
info = gtk_icon_theme_lookup_by_gicon (icon_theme,
icon,
MIN (width, height), 0);
#else
info = NULL;
#endif
pixbuf = gtk_icon_info_load_icon (info, &error);
if (pixbuf == NULL)
{
g_error_free (error);
pixbuf = gtk_widget_render_icon (GTK_WIDGET (entry),
GTK_STOCK_MISSING_IMAGE,
GTK_ICON_SIZE_MENU,
NULL);
}
}
gtk_icon_entry_set_icon_internal ((GtkIconEntry*)entry,
icon_pos,
pixbuf);
}
static void
pluma_spinner_screen_changed (GtkWidget *widget,
GdkScreen *old_screen)
{
PlumaSpinner *spinner = PLUMA_SPINNER (widget);
PlumaSpinnerPrivate *priv = spinner->priv;
GdkScreen *screen;
if (GTK_WIDGET_CLASS (parent_class)->screen_changed)
{
GTK_WIDGET_CLASS (parent_class)->screen_changed (widget, old_screen);
}
screen = gtk_widget_get_screen (widget);
/* FIXME: this seems to be happening when then spinner is destroyed!? */
if (old_screen == screen)
return;
/* We'll get mapped again on the new screen, but not unmapped from
* the old screen, so remove timeout here.
*/
pluma_spinner_remove_update_callback (spinner);
pluma_spinner_unload_images (spinner);
if (old_screen != NULL)
{
g_signal_handlers_disconnect_by_func
(gtk_icon_theme_get_for_screen (old_screen),
G_CALLBACK (icon_theme_changed_cb), spinner);
}
priv->icon_theme = gtk_icon_theme_get_for_screen (screen);
g_signal_connect (priv->icon_theme, "changed",
G_CALLBACK (icon_theme_changed_cb), spinner);
}
