CajaIconInfo *
caja_icon_info_lookup_from_name (const char *name,
int size)
{
GIcon *icon;
CajaIconInfo *info;
icon = g_themed_icon_new (name);
info = caja_icon_info_lookup (icon, size);
g_object_unref (icon);
return info;
}
NautilusIconInfo *
nautilus_icon_info_lookup_from_name (const char *name,
int size,
int scale)
{
GIcon *icon;
NautilusIconInfo *info;
icon = g_themed_icon_new (name);
info = nautilus_icon_info_lookup (icon, size, scale);
g_object_unref (icon);
return info;
}
static void
apply_warning_emblem (GIcon **base,
gboolean symbolic)
{
GIcon *warning, *emblemed_icon;
GEmblem *emblem;
if (symbolic) {
warning = g_themed_icon_new ("dialog-warning-symbolic");
} else {
warning = g_themed_icon_new (GTK_STOCK_DIALOG_WARNING);
}
emblem = g_emblem_new (warning);
emblemed_icon = g_emblemed_icon_new (*base, emblem);
g_object_unref (emblem);
g_object_unref (warning);
g_object_unref (*base);
*base = emblemed_icon;
}
static GIcon *
icon_for_recent (GtkRecentInfo *info)
{
const char *mimetype;
mimetype = gtk_recent_info_get_mime_type (info);
if (!mimetype)
{
return g_themed_icon_new (GTK_STOCK_FILE);
}
return icon_for_mimetype (mimetype);
}
static GIcon *
photos_base_item_create_symbolic_emblem (const gchar *name)
{
GIcon *pix;
gint size;
size = photos_utils_get_icon_size ();
pix = photos_utils_create_symbolic_icon (name, size);
if (pix == NULL)
pix = g_themed_icon_new (name);
return pix;
}
GdkPixbuf *
photos_utils_create_placeholder_icon_for_scale (const gchar *name, gint size, gint scale)
{
GApplication *app;
g_autoptr (GdkPixbuf) centered_pixbuf = NULL;
g_autoptr (GdkPixbuf) pixbuf = NULL;
GdkPixbuf *ret_val = NULL;
g_autoptr (GIcon) icon = NULL;
GList *windows;
g_autoptr (GtkIconInfo) info = NULL;
GtkIconTheme *theme;
GtkStyleContext *context;
gint size_scaled;
app = g_application_get_default ();
windows = gtk_application_get_windows (GTK_APPLICATION (app));
if (windows == NULL)
goto out;
icon = g_themed_icon_new (name);
theme = gtk_icon_theme_get_default ();
info = gtk_icon_theme_lookup_by_gicon_for_scale (theme,
icon,
16,
scale,
GTK_ICON_LOOKUP_FORCE_SIZE | GTK_ICON_LOOKUP_FORCE_SYMBOLIC);
if (info == NULL)
goto out;
context = gtk_widget_get_style_context (GTK_WIDGET (windows->data));
{
g_autoptr (GError) error = NULL;
pixbuf = gtk_icon_info_load_symbolic_for_context (info, context, NULL, &error);
if (error != NULL)
{
g_warning ("Unable to load icon '%s': %s", name, error->message);
goto out;
}
}
size_scaled = size * scale;
centered_pixbuf = photos_utils_center_pixbuf (pixbuf, size_scaled);
ret_val = centered_pixbuf;
centered_pixbuf = NULL;
out:
return ret_val;
}
static void
nautilus_bookmark_set_icon_to_default (NautilusBookmark *bookmark)
{
GIcon *icon, *symbolic_icon;
char *uri;
if (g_file_is_native (bookmark->details->location)) {
symbolic_icon = get_native_icon (bookmark, TRUE);
icon = get_native_icon (bookmark, FALSE);
} else {
uri = nautilus_bookmark_get_uri (bookmark);
if (g_str_has_prefix (uri, EEL_SEARCH_URI)) {
symbolic_icon = g_themed_icon_new (NAUTILUS_ICON_FOLDER_SAVED_SEARCH);
icon = g_themed_icon_new (NAUTILUS_ICON_FULLCOLOR_FOLDER_SAVED_SEARCH);
} else {
symbolic_icon = g_themed_icon_new (NAUTILUS_ICON_FOLDER_REMOTE);
icon = g_themed_icon_new (NAUTILUS_ICON_FULLCOLOR_FOLDER_REMOTE);
}
g_free (uri);
}
if (!bookmark->details->exists) {
DEBUG ("%s: file does not exist, add emblem", nautilus_bookmark_get_name (bookmark));
apply_warning_emblem (&icon, FALSE);
apply_warning_emblem (&symbolic_icon, TRUE);
}
DEBUG ("%s: setting icon to default", nautilus_bookmark_get_name (bookmark));
g_object_set (bookmark,
"icon", icon,
"symbolic-icon", symbolic_icon,
NULL);
g_object_unref (icon);
g_object_unref (symbolic_icon);
}
static GList *
mock_importer_create_for_parsed (GcrParsed *parsed)
{
GcrImporter *self;
GIcon *icon;
icon = g_themed_icon_new ("dialog-warning");
self = g_object_new (mock_importer_get_type (),
"label", gcr_parsed_get_label (parsed),
"icon", icon,
NULL);
g_object_unref (icon);
return g_list_append (NULL, self);
}
/**
* st_texture_cache_load_icon_name:
* @cache: The texture cache instance
* @name: Name of a themed icon
* @size: Size of themed
*
* Load a themed icon into a texture.
*
* Return Value: (transfer none): A new #ClutterTexture for the icon
*/
ClutterActor *
st_texture_cache_load_icon_name (StTextureCache *cache,
const char *name,
gint size)
{
ClutterActor *texture;
GIcon *themed;
themed = g_themed_icon_new (name);
texture = st_texture_cache_load_gicon (cache, themed, size);
g_object_unref (themed);
return CLUTTER_ACTOR (texture);
}
static GdkPaintable *
gtk_icon_helper_load_paintable (GtkIconHelper *self,
gboolean *out_symbolic)
{
GdkPaintable *paintable;
GIcon *gicon;
gboolean symbolic;
switch (gtk_image_definition_get_storage_type (self->def))
{
case GTK_IMAGE_PAINTABLE:
paintable = g_object_ref (gtk_image_definition_get_paintable (self->def));
symbolic = FALSE;
break;
case GTK_IMAGE_ICON_NAME:
if (self->use_fallback)
gicon = g_themed_icon_new_with_default_fallbacks (gtk_image_definition_get_icon_name (self->def));
else
gicon = g_themed_icon_new (gtk_image_definition_get_icon_name (self->def));
paintable = ensure_paintable_for_gicon (self,
gtk_css_node_get_style (self->node),
gtk_widget_get_direction (self->owner),
gtk_widget_get_scale_factor (self->owner),
gicon,
&symbolic);
g_object_unref (gicon);
break;
case GTK_IMAGE_GICON:
paintable = ensure_paintable_for_gicon (self,
gtk_css_node_get_style (self->node),
gtk_widget_get_direction (self->owner),
gtk_widget_get_scale_factor (self->owner),
gtk_image_definition_get_gicon (self->def),
&symbolic);
break;
case GTK_IMAGE_EMPTY:
default:
paintable = NULL;
symbolic = FALSE;
break;
}
*out_symbolic = symbolic;
return paintable;
}
/**
* st_texture_cache_load_icon_name:
* @cache: The texture cache instance
* @theme_node: (allow-none): a #StThemeNode
* @name: Name of a themed icon
* @icon_type: the type of icon to load
* @size: Size of themed icon
*
* Load a themed icon into a texture. See the #StIconType documentation
* for an explanation of how @icon_type affects the returned icon. The
* colors used for symbolic icons are derived from @theme_node.
*
* Return Value: (transfer none): A new #ClutterTexture for the icon
*/
ClutterActor *
st_texture_cache_load_icon_name (StTextureCache *cache,
StThemeNode *theme_node,
const char *name,
StIconType icon_type,
gint size)
{
ClutterActor *texture;
GIcon *themed;
char **names;
g_return_val_if_fail (!(icon_type == ST_ICON_SYMBOLIC && theme_node == NULL), NULL);
switch (icon_type)
{
case ST_ICON_SYMBOLIC:
names = symbolic_names_for_icon (name);
themed = g_themed_icon_new_from_names (names, -1);
g_strfreev (names);
texture = load_gicon_with_colors (cache, themed, size,
st_theme_node_get_icon_colors (theme_node));
g_object_unref (themed);
if (texture == NULL)
{
/* We don't have an equivalent of image-missing
* for the symbolic icon theme, so just create a blank
* actor. */
texture = (ClutterActor *) create_default_texture ();
clutter_actor_set_size (texture, size, size);
}
return texture;
break;
case ST_ICON_FULLCOLOR:
themed = g_themed_icon_new_with_default_fallbacks (name);
texture = load_gicon_with_colors (cache, themed, size, NULL);
g_object_unref (themed);
if (texture == NULL)
{
themed = g_themed_icon_new ("image-missing");
texture = load_gicon_with_colors (cache, themed, size, NULL);
g_object_unref (themed);
}
return texture;
break;
default:
g_assert_not_reached ();
}
}
static void
pack_numerable (GtkWidget *parent,
GtkIconSize size)
{
PackData *d;
GtkWidget *vbox, *label, *image, *button;
gchar *str;
GIcon *icon, *numerable;
d = g_slice_new0 (PackData);
image = gtk_image_new ();
icon = g_themed_icon_new ("system-file-manager");
numerable = gtk_numerable_icon_new (icon);
d->image = image;
d->numerable = numerable;
d->odd = FALSE;
d->size = size;
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_box_pack_start (GTK_BOX (parent), vbox, FALSE, FALSE, 0);
gtk_numerable_icon_set_count (GTK_NUMERABLE_ICON (numerable), 42);
gtk_box_pack_start (GTK_BOX (vbox), image, FALSE, FALSE, 0);
gtk_numerable_icon_set_style_context (GTK_NUMERABLE_ICON (numerable),
gtk_widget_get_style_context (image));
gtk_image_set_from_gicon (GTK_IMAGE (image), numerable, size);
label = gtk_label_new (NULL);
str = g_strdup_printf ("Numerable icon, hash %u", g_icon_hash (numerable));
gtk_label_set_label (GTK_LABEL (label), str);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Change icon number");
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
g_signal_connect (button, "clicked",
G_CALLBACK (button_clicked_cb), d);
button = gtk_button_new_with_label ("Properties");
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
g_signal_connect (button, "clicked",
G_CALLBACK (properties_cb), numerable);
button = gtk_button_new_with_label ("Refresh");
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
g_signal_connect (button, "clicked",
G_CALLBACK (refresh_cb), d);
}
static void
gth_organize_task_init (GthOrganizeTask *self)
{
GIcon *icon;
self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GTH_TYPE_ORGANIZE_TASK, GthOrganizeTaskPrivate);
self->priv->builder = _gtk_builder_new_from_file ("organize-files-task.ui", "catalogs");
self->priv->results_liststore = (GtkListStore *) gtk_builder_get_object (self->priv->builder, "results_liststore");
self->priv->catalogs = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (self->priv->results_liststore), KEY_COLUMN, GTK_SORT_ASCENDING);
g_object_set (GET_WIDGET ("catalog_name_cellrenderertext"), "editable", TRUE, NULL);
icon = g_themed_icon_new ("file-catalog");
self->priv->icon_pixbuf = _g_icon_get_pixbuf (icon,
_gtk_icon_get_pixel_size (GET_WIDGET ("organization_treeview"), GTK_ICON_SIZE_MENU),
gtk_icon_theme_get_for_screen (gtk_widget_get_screen (GET_WIDGET ("organization_treeview"))));
g_object_unref (icon);
self->priv->file_list = gth_file_list_new (GTH_FILE_LIST_TYPE_NORMAL, FALSE);
gth_file_list_set_caption (GTH_FILE_LIST (self->priv->file_list), "standard::display-name");
gtk_widget_show (self->priv->file_list);
gtk_box_pack_start (GTK_BOX (GET_WIDGET ("preview_box")), self->priv->file_list, TRUE, TRUE, 0);
g_signal_connect (GET_WIDGET ("catalog_name_cellrenderertext"),
"edited",
G_CALLBACK (catalog_name_cellrenderertext_edited_cb),
self);
g_signal_connect (GET_WIDGET ("create_cellrenderertoggle"),
"toggled",
G_CALLBACK (create_cellrenderertoggle_toggled_cb),
self);
g_signal_connect (GET_WIDGET ("organize_files_dialog"),
"response",
G_CALLBACK (organize_files_dialog_response_cb),
self);
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (GET_WIDGET ("organization_treeview"))),
"changed",
G_CALLBACK (organization_treeview_selection_changed_cb),
self);
g_signal_connect (GET_WIDGET ("select_all_button"),
"clicked",
G_CALLBACK (select_all_button_clicked_cb),
self);
g_signal_connect (GET_WIDGET ("select_none_button"),
"clicked",
G_CALLBACK (select_none_button_clicked_cb),
self);
}
static void
gdm_password_extension_init (GdmPasswordExtension *extension)
{
extension->priv = G_TYPE_INSTANCE_GET_PRIVATE (extension,
GDM_TYPE_PASSWORD_EXTENSION,
GdmPasswordExtensionPrivate);
extension->priv->icon = g_themed_icon_new ("dialog-password");
create_page (extension);
create_actions (extension);
extension->priv->message_queue = g_queue_new ();
gdm_password_extension_reset (GDM_LOGIN_EXTENSION (extension));
}
void
_gtk_icon_helper_set_icon_name (GtkIconHelper *self,
const gchar *icon_name,
GtkIconSize icon_size)
{
_gtk_icon_helper_clear (self);
if (icon_name != NULL &&
icon_name[0] != '\0')
{
self->priv->storage_type = GTK_IMAGE_ICON_NAME;
self->priv->gicon = g_themed_icon_new (icon_name);
_gtk_icon_helper_set_icon_size (self, icon_size);
}
}
static GIcon *
xfdesktop_special_file_icon_load_icon(XfdesktopIcon *icon)
{
XfdesktopSpecialFileIcon *special_icon = XFDESKTOP_SPECIAL_FILE_ICON(icon);
XfdesktopFileIcon *file_icon = XFDESKTOP_FILE_ICON(icon);
gchar *icon_name = NULL;
GFile *parent = NULL;
GIcon *gicon = NULL;
TRACE("entering");
/* use a custom icon name for the local filesystem root */
parent = g_file_get_parent(special_icon->priv->file);
if(!parent && g_file_has_uri_scheme(special_icon->priv->file, "file"))
icon_name = g_strdup("drive-harddisk");
if(parent)
g_object_unref(parent);
/* use a custom icon for the trash, based on it having files
* the user can delete */
if(special_icon->priv->type == XFDESKTOP_SPECIAL_FILE_ICON_TRASH) {
if(special_icon->priv->trash_item_count == 0)
icon_name = g_strdup("user-trash");
else
icon_name = g_strdup("user-trash-full");
}
/* Create the themed icon for it */
if(icon_name) {
gicon = g_themed_icon_new(icon_name);
g_free(icon_name);
}
/* If we still don't have an icon, use the default */
if(!G_IS_ICON(gicon)) {
gicon = g_file_info_get_icon(special_icon->priv->file_info);
if(G_IS_ICON(gicon))
g_object_ref(gicon);
}
g_object_set(file_icon, "gicon", gicon, NULL);
/* Add any user set emblems */
gicon = xfdesktop_file_icon_add_emblems(file_icon);
return gicon;
}
static void
gtk_app_chooser_add_default (GtkAppChooserWidget *self,
GAppInfo *app)
{
GtkTreeIter iter;
GIcon *icon;
gchar *string;
gboolean unref_icon;
unref_icon = FALSE;
string = g_strdup_printf ("<b>%s</b>", _("Default Application"));
gtk_list_store_append (self->priv->program_list_store, &iter);
gtk_list_store_set (self->priv->program_list_store, &iter,
COLUMN_HEADING_TEXT, string,
COLUMN_HEADING, TRUE,
COLUMN_DEFAULT, TRUE,
-1);
g_free (string);
string = g_markup_printf_escaped ("%s",
g_app_info_get_name (app) != NULL ?
g_app_info_get_name (app) : "");
icon = g_app_info_get_icon (app);
if (icon == NULL)
{
icon = g_themed_icon_new ("application-x-executable");
unref_icon = TRUE;
}
gtk_list_store_append (self->priv->program_list_store, &iter);
gtk_list_store_set (self->priv->program_list_store, &iter,
COLUMN_APP_INFO, app,
COLUMN_GICON, icon,
COLUMN_NAME, g_app_info_get_name (app),
COLUMN_DESC, string,
COLUMN_EXEC, g_app_info_get_executable (app),
COLUMN_HEADING, FALSE,
COLUMN_DEFAULT, TRUE,
-1);
g_free (string);
if (unref_icon)
g_object_unref (icon);
}
GIcon *
photos_utils_get_icon_from_cursor (TrackerSparqlCursor *cursor)
{
GIcon *icon = NULL;
gboolean is_remote = FALSE;
const gchar *identifier;
const gchar *mime_type;
const gchar *rdf_type;
identifier = tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_IDENTIFIER, NULL);
if (identifier != NULL)
{
if (g_str_has_prefix (identifier, "facebook:") || g_str_has_prefix (identifier, "flickr:"))
is_remote = TRUE;
}
if (!is_remote)
{
const gchar *uri;
uri = tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_URI, NULL);
if (uri != NULL)
icon = photos_utils_get_thumbnail_icon (uri);
}
if (icon != NULL)
goto out;
mime_type = tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_MIME_TYPE, NULL);
if (mime_type != NULL)
icon = g_content_type_get_icon (mime_type);
if (icon != NULL)
goto out;
rdf_type = tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_RDF_TYPE, NULL);
if (mime_type != NULL)
icon = photos_utils_icon_from_rdf_type (rdf_type);
if (icon != NULL)
goto out;
icon = g_themed_icon_new ("image-x-generic");
out:
return icon;
}
GIcon *
photos_utils_get_icon_from_item (PhotosBaseItem *item)
{
GIcon *icon = NULL;
gboolean is_remote = FALSE;
const gchar *identifier;
const gchar *mime_type;
identifier = photos_base_item_get_identifier (item);
if (identifier != NULL)
{
if (g_str_has_prefix (identifier, "facebook:") ||
g_str_has_prefix (identifier, "flickr:") ||
g_str_has_prefix (identifier, "google:"))
is_remote = TRUE;
}
if (!is_remote)
icon = photos_utils_get_thumbnail_icon (item);
if (icon != NULL)
goto out;
mime_type = photos_base_item_get_mime_type (item);
if (mime_type != NULL)
icon = g_content_type_get_icon (mime_type);
if (icon != NULL)
goto out;
if (photos_base_item_is_collection (item))
{
gint size;
size = photos_utils_get_icon_size ();
icon = photos_utils_create_collection_icon (size, NULL);
}
if (icon != NULL)
goto out;
icon = g_themed_icon_new ("image-x-generic");
out:
return icon;
}
static void
gdm_smartcard_extension_init (GdmSmartcardExtension *extension)
{
extension->priv = G_TYPE_INSTANCE_GET_PRIVATE (extension,
GDM_TYPE_SMARTCARD_EXTENSION,
GdmSmartcardExtensionPrivate);
extension->priv->icon = g_themed_icon_new ("gdm-smartcard");
create_page (extension);
create_actions (extension);
extension->priv->message_queue = g_queue_new ();
extension->priv->settings = g_settings_new ("org.gnome.login-screen");
gdm_smartcard_extension_reset (GDM_LOGIN_EXTENSION (extension));
}
static void
gdm_fingerprint_extension_init (GdmFingerprintExtension *extension)
{
extension->priv = G_TYPE_INSTANCE_GET_PRIVATE (extension,
GDM_TYPE_FINGERPRINT_EXTENSION,
GdmFingerprintExtensionPrivate);
extension->priv->icon = g_themed_icon_new ("gdm-fingerprint");
create_page (extension);
create_actions (extension);
extension->priv->message_queue = g_queue_new ();
extension->priv->settings = g_settings_new ("org.gnome.login-screen");
extension->priv->bus_connection = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, NULL);
gdm_fingerprint_extension_reset (GDM_LOGIN_EXTENSION (extension));
}
/**
* rb_device_source_set_display_details:
* @source: a #RBDeviceSource
*
* Sets the icon and display name for a device-based source.
* The details come from the mount and/or volume. This should
* be called in the source's constructed method.
*/
void
rb_device_source_set_display_details (RBDeviceSource *source)
{
GMount *mount = NULL;
GVolume *volume = NULL;
GIcon *icon = NULL;
char *display_name;
if (g_object_class_find_property (G_OBJECT_GET_CLASS (source), "volume")) {
g_object_get (source, "volume", &volume, NULL);
}
if (g_object_class_find_property (G_OBJECT_GET_CLASS (source), "mount")) {
g_object_get (source, "mount", &mount, NULL);
}
/* prefer mount details to volume details, as the nautilus sidebar does */
if (mount != NULL) {
mount = g_object_ref (mount);
} else if (volume != NULL) {
mount = g_volume_get_mount (volume);
} else {
mount = NULL;
}
if (mount != NULL) {
display_name = g_mount_get_name (mount);
icon = g_mount_get_symbolic_icon (mount);
rb_debug ("details from mount: display name = %s, icon = %p", display_name, icon);
} else if (volume != NULL) {
display_name = g_volume_get_name (volume);
icon = g_volume_get_symbolic_icon (volume);
rb_debug ("details from volume: display name = %s, icon = %p", display_name, icon);
} else {
display_name = g_strdup ("Unknown Device");
icon = g_themed_icon_new ("multimedia-player-symbolic");
}
g_object_set (source, "name", display_name, "icon", icon, NULL);
g_free (display_name);
g_clear_object (&mount);
g_clear_object (&volume);
g_clear_object (&icon);
}
static void
add_application (CcNotificationsPanel *panel,
Application *app)
{
GtkWidget *box, *w;
GIcon *icon;
icon = g_app_info_get_icon (app->app_info);
if (icon == NULL)
icon = g_themed_icon_new ("application-x-executable");
else
g_object_ref (icon);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
g_object_set_qdata_full (G_OBJECT (box), application_quark (),
app, (GDestroyNotify) application_free);
gtk_container_add (GTK_CONTAINER (panel->list_box), box);
w = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_DIALOG);
gtk_widget_set_margin_left (w, 12);
gtk_container_add (GTK_CONTAINER (box), w);
g_object_unref (icon);
w = gtk_label_new (g_app_info_get_name (app->app_info));
gtk_container_add (GTK_CONTAINER (box), w);
w = gtk_label_new ("");
g_settings_bind_with_mapping (app->settings, "enable",
w, "label",
G_SETTINGS_BIND_GET |
G_SETTINGS_BIND_NO_SENSITIVITY,
on_off_label_mapping_get,
NULL,
NULL,
NULL);
gtk_widget_set_margin_right (w, 12);
gtk_widget_set_valign (w, GTK_ALIGN_CENTER);
gtk_box_pack_end (GTK_BOX (box), w, FALSE, FALSE, 0);
gtk_widget_show_all (box);
g_hash_table_add (panel->known_applications, g_strdup (app->canonical_app_id));
}
GdkPixbuf *
_g_mime_type_get_icon (const char *mime_type,
int icon_size,
GtkIconTheme *icon_theme)
{
GdkPixbuf *pixbuf = NULL;
GIcon *icon;
if (icon_theme == NULL)
icon_theme = gtk_icon_theme_get_default ();
icon = g_content_type_get_icon (mime_type);
if (icon == NULL)
icon = g_themed_icon_new ("text-x-generic");
pixbuf = _g_icon_get_pixbuf (icon, icon_size, icon_theme);
g_object_unref (icon);
return pixbuf;
}
/**
* shell_startup_sequence_create_icon:
* @sequence:
* @size: Size in pixels of icon
*
* Returns: (transfer none): A new #ClutterTexture containing an icon for the sequence
*/
ClutterActor *
shell_startup_sequence_create_icon (ShellStartupSequence *sequence, guint size)
{
GIcon *themed;
const char *icon_name;
ClutterActor *texture;
icon_name = sn_startup_sequence_get_icon_name ((SnStartupSequence*)sequence);
if (!icon_name)
{
texture = clutter_texture_new ();
clutter_actor_set_size (texture, size, size);
return texture;
}
themed = g_themed_icon_new (icon_name);
texture = st_texture_cache_load_gicon (st_texture_cache_get_default (),
themed, size);
g_object_unref (G_OBJECT (themed));
return texture;
}
static void
update_icon (PolariRoom *room)
{
PolariRoomPrivate *priv = room->priv;
g_clear_object (&priv->icon);
if (priv->channel)
{
const char *icon_name;
gboolean is_private;
is_private = !tp_proxy_has_interface_by_id (TP_PROXY (priv->channel),
TP_IFACE_QUARK_CHANNEL_INTERFACE_GROUP);
icon_name = is_private ? "avatar-default-symbolic"
: "user-available-symbolic";
priv->icon = g_themed_icon_new (icon_name);
}
g_object_notify_by_pspec (G_OBJECT (room), props[PROP_ICON]);
}
GdkPixbuf *
gth_icon_cache_get_pixbuf (GthIconCache *icon_cache,
GIcon *icon)
{
const char *key;
GdkPixbuf *pixbuf;
key = NULL;
if (icon != NULL)
key = _gth_icon_cache_get_icon_key (icon);
if (key == NULL)
key = VOID_PIXBUF_KEY;
performance (DEBUG_INFO, "get pixbuf for %s", key);
pixbuf = g_hash_table_lookup (icon_cache->cache, key);
if (pixbuf != NULL) {
g_object_ref (pixbuf);
return pixbuf;
}
if (icon != NULL)
pixbuf = _g_icon_get_pixbuf (icon, icon_cache->icon_size, icon_cache->icon_theme);
if (pixbuf == NULL) {
GIcon *unknown_icon;
unknown_icon = g_themed_icon_new ("missing-image");
pixbuf = _g_icon_get_pixbuf (unknown_icon, icon_cache->icon_size, icon_cache->icon_theme);
g_object_unref (unknown_icon);
}
g_hash_table_insert (icon_cache->cache, (gpointer) key, g_object_ref (pixbuf));
performance (DEBUG_INFO, "done (not cached)");
return pixbuf;
}
gboolean
_gtk_icon_helper_set_use_fallback (GtkIconHelper *self,
gboolean use_fallback)
{
if (self->priv->use_fallback != use_fallback)
{
self->priv->use_fallback = use_fallback;
_gtk_icon_helper_invalidate (self);
if (self->priv->storage_type == GTK_IMAGE_ICON_NAME)
{
GIcon *old_icon = self->priv->gicon;
const char *icon_name = g_themed_icon_get_names (G_THEMED_ICON (self->priv->gicon))[0];
if (self->priv->use_fallback)
self->priv->gicon = g_themed_icon_new_with_default_fallbacks (icon_name);
else
self->priv->gicon = g_themed_icon_new (icon_name);
g_object_unref (old_icon);
}
return TRUE;
}
return FALSE;
}
static void
insert_one_application (GtkAppChooserButton *self,
GAppInfo *app,
GtkTreeIter *iter)
{
GIcon *icon;
icon = g_app_info_get_icon (app);
if (icon == NULL)
icon = g_themed_icon_new ("application-x-executable");
else
g_object_ref (icon);
gtk_list_store_set (self->priv->store, iter,
COLUMN_APP_INFO, app,
COLUMN_LABEL, g_app_info_get_name (app),
COLUMN_ICON, icon,
COLUMN_CUSTOM, FALSE,
-1);
g_object_unref (icon);
}
/**
* shell_util_get_icon_for_uri:
* @text_uri: A URI
*
* Look up the icon that should be associated with a given URI. Handles
* various special GNOME-internal cases like x-nautilus-search, etc.
*
* Return Value: (transfer none): A new #GIcon
*/
GIcon *
shell_util_get_icon_for_uri (const char *text_uri)
{
const char *name;
GFile *file;
GFileInfo *info;
GIcon *retval;
/* Here's what we do:
* + check for known file: URI
* + x-nautilus-search: URI
* + override burn: URI icon
* + check if the URI is a mount
* + override trash: URI icon for subfolders
* + check for application/x-gnome-saved-search mime type and override
* icon of the GFile
* + use icon of the GFile
*/
/* this only checks file: URI */
name = shell_util_get_icon_for_uri_known_folders (text_uri);
if (name)
return g_themed_icon_new (name);
if (g_str_has_prefix (text_uri, "x-nautilus-search:"))
return g_themed_icon_new ("folder-saved-search");
/* gvfs doesn't give us a nice icon, so overriding */
if (g_str_has_prefix (text_uri, "burn:"))
return g_themed_icon_new ("nautilus-cd-burner");
file = g_file_new_for_uri (text_uri);
retval = shell_util_get_file_icon_if_mount (file);
if (retval)
return retval;
/* gvfs doesn't give us a nice icon for subfolders of the trash, so
* overriding */
if (g_str_has_prefix (text_uri, "trash:"))
{
GFile *root;
root = shell_util_get_gfile_root (file);
g_object_unref (file);
file = root;
}
info = g_file_query_info (file, "standard::icon", G_FILE_QUERY_INFO_NONE,
NULL, NULL);
g_object_unref (file);
if (!info)
return g_themed_icon_new ("gtk-file");
retval = g_file_info_get_icon (info);
if (retval)
g_object_ref (retval);
g_object_unref (info);
if (retval)
return retval;
return g_themed_icon_new ("gtk-file");
}