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)
{
GFile *file;
GFileInfo *file_info;
file = g_file_new_for_uri (gimp_object_get_name (imagefile));
file_info = g_file_query_info (file, "standard::icon", 0, NULL, NULL);
if (file_info)
{
GIcon *icon = g_file_info_get_icon (file_info);
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);
}
else
{
#ifdef GIMP_UNSTABLE
g_printerr ("no icon for: %s\n",
gimp_object_get_name (imagefile));
#endif
}
g_object_unref (file_info);
}
g_object_unref (file);
}
if (! pixbuf && thumbnail->image_mimetype)
{
pixbuf = get_icon_for_mime_type (thumbnail->image_mimetype,
size);
}
if (! pixbuf)
{
const gchar *icon_name = GTK_STOCK_FILE;
if (thumbnail->image_state == GIMP_THUMB_STATE_FOLDER)
icon_name = GTK_STOCK_DIRECTORY;
pixbuf = gtk_icon_theme_load_icon (icon_theme,
icon_name, size,
GTK_ICON_LOOKUP_USE_BUILTIN,
NULL);
}
return pixbuf;
}
static CoglHandle
cinnamon_app_create_faded_icon_cpu (StTextureCache *cache,
const char *key,
void *datap,
GError **error)
{
CreateFadedIconData *data = datap;
CinnamonApp *app;
GdkPixbuf *pixbuf;
int size;
int scale;
CoglHandle texture;
gint width, height, rowstride;
guint8 n_channels;
gboolean have_alpha;
gint fade_start;
gint fade_range;
guint i, j;
guint pixbuf_byte_size;
guint8 *orig_pixels;
guint8 *pixels;
GIcon *icon;
GtkIconInfo *info;
app = data->app;
size = data->size;
scale = data->scale;
info = NULL;
icon = g_app_info_get_icon (G_APP_INFO (gmenu_tree_entry_get_app_info (app->entry)));
if (icon != NULL)
{
info = gtk_icon_theme_lookup_by_gicon_for_scale (gtk_icon_theme_get_default (),
icon, size, scale,
GTK_ICON_LOOKUP_FORCE_SIZE);
}
if (info == NULL)
{
icon = g_themed_icon_new ("application-x-executable");
info = gtk_icon_theme_lookup_by_gicon_for_scale (gtk_icon_theme_get_default (),
icon, size, scale,
GTK_ICON_LOOKUP_FORCE_SIZE);
g_object_unref (icon);
}
if (info == NULL)
return COGL_INVALID_HANDLE;
pixbuf = gtk_icon_info_load_icon (info, NULL);
g_object_unref (info);
if (pixbuf == NULL)
return COGL_INVALID_HANDLE;
width = gdk_pixbuf_get_width (pixbuf);
height = gdk_pixbuf_get_height (pixbuf);
rowstride = gdk_pixbuf_get_rowstride (pixbuf);
n_channels = gdk_pixbuf_get_n_channels (pixbuf);
orig_pixels = gdk_pixbuf_get_pixels (pixbuf);
have_alpha = gdk_pixbuf_get_has_alpha (pixbuf);
pixbuf_byte_size = (height - 1) * rowstride +
+ width * ((n_channels * gdk_pixbuf_get_bits_per_sample (pixbuf) + 7) / 8);
pixels = g_malloc0 (rowstride * height);
memcpy (pixels, orig_pixels, pixbuf_byte_size);
fade_start = width / 2;
fade_range = width - fade_start;
for (i = fade_start; i < width; i++)
{
for (j = 0; j < height; j++)
{
guchar *pixel = &pixels[j * rowstride + i * n_channels];
float fade = 1.0 - ((float) i - fade_start) / fade_range;
pixel[0] = 0.5 + pixel[0] * fade;
pixel[1] = 0.5 + pixel[1] * fade;
pixel[2] = 0.5 + pixel[2] * fade;
if (have_alpha)
pixel[3] = 0.5 + pixel[3] * fade;
}
}
texture = st_cogl_texture_new_from_data_wrapper (width, height,
COGL_TEXTURE_NONE,
have_alpha ? COGL_PIXEL_FORMAT_RGBA_8888 : COGL_PIXEL_FORMAT_RGB_888,
COGL_PIXEL_FORMAT_ANY,
rowstride, pixels);
g_free (pixels);
g_object_unref (pixbuf);
return texture;
}
nsresult
nsIconChannel::InitWithGIO(nsIMozIconURI* aIconURI)
{
GIcon *icon = nullptr;
nsCOMPtr<nsIURL> fileURI;
// Read icon content
aIconURI->GetIconURL(getter_AddRefs(fileURI));
// Get icon for file specified by URI
if (fileURI) {
bool isFile;
nsAutoCString spec;
fileURI->GetAsciiSpec(spec);
if (NS_SUCCEEDED(fileURI->SchemeIs("file", &isFile)) && isFile) {
GFile* file = g_file_new_for_uri(spec.get());
GFileInfo* fileInfo = g_file_query_info(file,
G_FILE_ATTRIBUTE_STANDARD_ICON,
G_FILE_QUERY_INFO_NONE,
nullptr, nullptr);
g_object_unref(file);
if (fileInfo) {
// icon from g_content_type_get_icon doesn't need unref
icon = g_file_info_get_icon(fileInfo);
if (icon) {
g_object_ref(icon);
}
g_object_unref(fileInfo);
}
}
}
// Try to get icon by using MIME type
if (!icon) {
nsAutoCString type;
aIconURI->GetContentType(type);
// Try to get MIME type from file extension by using nsIMIMEService
if (type.IsEmpty()) {
nsCOMPtr<nsIMIMEService> ms(do_GetService("@mozilla.org/mime;1"));
if (ms) {
nsAutoCString fileExt;
aIconURI->GetFileExtension(fileExt);
ms->GetTypeFromExtension(fileExt, type);
}
}
char* ctype = nullptr; // character representation of content type
if (!type.IsEmpty()) {
ctype = g_content_type_from_mime_type(type.get());
}
if (ctype) {
icon = g_content_type_get_icon(ctype);
g_free(ctype);
}
}
// Get default icon theme
GtkIconTheme* iconTheme = gtk_icon_theme_get_default();
GtkIconInfo* iconInfo = nullptr;
// Get icon size
int32_t iconSize = GetIconSize(aIconURI);
if (icon) {
// Use icon and theme to get GtkIconInfo
iconInfo = gtk_icon_theme_lookup_by_gicon(iconTheme,
icon, iconSize,
(GtkIconLookupFlags)0);
g_object_unref(icon);
}
if (!iconInfo) {
// Mozilla's mimetype lookup failed. Try the "unknown" icon.
iconInfo = gtk_icon_theme_lookup_icon(iconTheme,
"unknown", iconSize,
(GtkIconLookupFlags)0);
if (!iconInfo) {
return NS_ERROR_NOT_AVAILABLE;
}
}
// Create a GdkPixbuf buffer containing icon and scale it
GdkPixbuf* buf = gtk_icon_info_load_icon(iconInfo, nullptr);
gtk_icon_info_free(iconInfo);
if (!buf) {
return NS_ERROR_UNEXPECTED;
}
nsresult rv = ScaleIconBuf(&buf, iconSize);
NS_ENSURE_SUCCESS(rv, rv);
rv = moz_gdk_pixbuf_to_channel(buf, aIconURI,
getter_AddRefs(mRealChannel));
g_object_unref(buf);
return rv;
}
NautilusIconInfo *
nautilus_icon_info_lookup (GIcon *icon,
int size)
{
NautilusIconInfo *icon_info;
GdkPixbuf *pixbuf;
if (G_IS_LOADABLE_ICON (icon)) {
LoadableIconKey lookup_key;
LoadableIconKey *key;
GInputStream *stream;
if (loadable_icon_cache == NULL) {
loadable_icon_cache =
g_hash_table_new_full ((GHashFunc)loadable_icon_key_hash,
(GEqualFunc)loadable_icon_key_equal,
(GDestroyNotify) loadable_icon_key_free,
(GDestroyNotify) g_object_unref);
}
lookup_key.icon = icon;
lookup_key.size = size;
icon_info = g_hash_table_lookup (loadable_icon_cache, &lookup_key);
if (icon_info) {
return g_object_ref (icon_info);
}
pixbuf = NULL;
stream = g_loadable_icon_load (G_LOADABLE_ICON (icon),
size,
NULL, NULL, NULL);
if (stream) {
pixbuf = eel_gdk_pixbuf_load_from_stream_at_size (stream, size);
g_object_unref (stream);
}
icon_info = nautilus_icon_info_new_for_pixbuf (pixbuf);
key = loadable_icon_key_new (icon, size);
g_hash_table_insert (loadable_icon_cache, key, icon_info);
return g_object_ref (icon_info);
} else if (G_IS_THEMED_ICON (icon)) {
const char * const *names;
ThemedIconKey lookup_key;
ThemedIconKey *key;
GtkIconTheme *icon_theme;
GtkIconInfo *gtkicon_info;
const char *filename;
if (themed_icon_cache == NULL) {
themed_icon_cache =
g_hash_table_new_full ((GHashFunc)themed_icon_key_hash,
(GEqualFunc)themed_icon_key_equal,
(GDestroyNotify) themed_icon_key_free,
(GDestroyNotify) g_object_unref);
}
names = g_themed_icon_get_names (G_THEMED_ICON (icon));
icon_theme = gtk_icon_theme_get_default ();
gtkicon_info = gtk_icon_theme_choose_icon (icon_theme, (const char **)names, size, 0);
if (gtkicon_info == NULL) {
return nautilus_icon_info_new_for_pixbuf (NULL);
}
filename = gtk_icon_info_get_filename (gtkicon_info);
lookup_key.filename = (char *)filename;
lookup_key.size = size;
icon_info = g_hash_table_lookup (themed_icon_cache, &lookup_key);
if (icon_info) {
gtk_icon_info_free (gtkicon_info);
return g_object_ref (icon_info);
}
icon_info = nautilus_icon_info_new_for_icon_info (gtkicon_info);
key = themed_icon_key_new (filename, size);
g_hash_table_insert (themed_icon_cache, key, icon_info);
gtk_icon_info_free (gtkicon_info);
return g_object_ref (icon_info);
} else {
GdkPixbuf *pixbuf;
GtkIconInfo *gtk_icon_info;
gtk_icon_info = gtk_icon_theme_lookup_by_gicon (gtk_icon_theme_get_default (),
icon,
size,
GTK_ICON_LOOKUP_GENERIC_FALLBACK);
if (gtk_icon_info != NULL) {
pixbuf = gtk_icon_info_load_icon (gtk_icon_info, NULL);
gtk_icon_info_free (gtk_icon_info);
} else {
pixbuf = NULL;
}
return nautilus_icon_info_new_for_pixbuf (pixbuf);
}
}
