gboolean populate_files (gpointer data) //TODO:: show an spinner while loading { FilebrowserBackend *filebackend= FILEBROWSER_BACKEND(data); FilebrowserBackendDetails *directory = FILEBROWSER_BACKEND_GET_PRIVATE(filebackend); GDK_THREADS_ENTER(); if (g_cancellable_is_cancelled (directory->cancellable)){ GDK_THREADS_LEAVE(); return FALSE; /* remove source */ } GError *error=NULL; GFileInfo *info = g_file_enumerator_next_file (directory->enumerator, directory->cancellable, &error); if (info){ const gchar *mime= g_file_info_get_content_type (info); if (!g_file_info_get_is_hidden (info) && !g_file_info_get_is_backup (info)){ if (MIME_ISDIR(mime)){ //if has dot in name pos 0 don't process const gchar *folder=g_file_info_get_display_name(info); if(folder[0]!='.'){ FOLDERFILE *current; current=new_folderfile(); current->mime=g_strdup(mime); GIcon *icon =g_file_info_get_icon(info); current->icon= g_icon_to_string (icon); current->display_name=g_strdup(folder); /* add to list */ directory->filesinfolder = g_slist_append(directory->filesinfolder, current); } } else { if (IS_TEXT(mime) && !IS_APPLICATION(mime)){ //files FOLDERFILE *current; current=new_folderfile(); current->mime=g_strdup(mime); GIcon *icon =g_file_info_get_icon(info); current->icon= g_icon_to_string (icon); current->display_name=g_strdup(g_file_info_get_display_name(info)); /* add to list */ directory->filesinfolder = g_slist_append(directory->filesinfolder, current); } } } g_object_unref(info); } else { if (error){ g_print(_("Error::%s"),error->message); g_error_free (error); } GDK_THREADS_LEAVE(); return FALSE; /* remove source */ } GDK_THREADS_LEAVE(); return TRUE; }
GdkPixbuf * pluma_file_browser_utils_pixbuf_from_file (GFile * file, GtkIconSize size) { GIcon * icon; GFileInfo * info; GdkPixbuf * ret = NULL; info = g_file_query_info (file, G_FILE_ATTRIBUTE_STANDARD_ICON, G_FILE_QUERY_INFO_NONE, NULL, NULL); if (!info) return NULL; icon = g_file_info_get_icon (info); if (icon != NULL) ret = pluma_file_browser_utils_pixbuf_from_icon (icon, size); g_object_unref (info); return ret; }
GdkPixbuf * gedit_file_browser_utils_pixbuf_from_file (GFile *file, GtkIconSize size, gboolean use_symbolic) { GIcon *icon; GFileInfo *info; GdkPixbuf *ret = NULL; const char *attribute; attribute = use_symbolic ? G_FILE_ATTRIBUTE_STANDARD_SYMBOLIC_ICON : G_FILE_ATTRIBUTE_STANDARD_ICON; info = g_file_query_info (file, attribute, G_FILE_QUERY_INFO_NONE, NULL, NULL); if (!info) return NULL; icon = use_symbolic ? g_file_info_get_symbolic_icon (info) : g_file_info_get_icon (info); if (icon != NULL) ret = gedit_file_browser_utils_pixbuf_from_icon (icon, size); g_object_unref (info); return ret; }
static void trash_applet_monitor_changed (TrashApplet *applet) { GError *error = NULL; GFileInfo *info; GIcon *icon; gint items; info = g_file_query_info (applet->trash, G_FILE_ATTRIBUTE_STANDARD_ICON"," G_FILE_ATTRIBUTE_TRASH_ITEM_COUNT, 0, NULL, &error); if (!info) { g_critical ("could not query trash:/: '%s'", error->message); g_error_free (error); return; } icon = g_file_info_get_icon (info); items = g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_TRASH_ITEM_COUNT); if (!g_icon_equal (icon, applet->icon)) { /* note: the size is meaningless here, * since we do set_pixel_size() later */ gtk_image_set_from_gicon (GTK_IMAGE (applet->image), icon, GTK_ICON_SIZE_MENU); if (applet->icon) g_object_unref (applet->icon); applet->icon = g_object_ref (icon); } if (items != applet->items) { if (items) { char *text; text = g_strdup_printf (ngettext ("%d Item in Trash", "%d Items in Trash", items), items); gtk_widget_set_tooltip_text (GTK_WIDGET (applet), text); g_free (text); } else gtk_widget_set_tooltip_text (GTK_WIDGET (applet), _("No Items in Trash")); applet->items = items; } g_object_unref (info); }
/* FIXME: we probably want to return a GIcon, that would be built with * g_themed_icon_new_with_default_fallbacks() since we can get an icon like * "folder-music", where "folder" is the safe fallback. */ char * panel_util_get_icon_for_uri (const char *text_uri) { const char *icon; GFile *file; GFileInfo *info; GIcon *gicon; char *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 */ icon = panel_util_get_icon_for_uri_known_folders (text_uri); if (icon) return g_strdup (icon); if (g_str_has_prefix (text_uri, "x-nautilus-search:")) return g_strdup (PANEL_ICON_SAVED_SEARCH); /* gvfs doesn't give us a nice icon, so overriding */ if (g_str_has_prefix (text_uri, "burn:")) return g_strdup (PANEL_ICON_BURNER); file = g_file_new_for_uri (text_uri); retval = panel_util_get_file_icon_name_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 = panel_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 NULL; gicon = g_file_info_get_icon (info); retval = panel_util_get_icon_name_from_g_icon (gicon); g_object_unref (info); return retval; }
GdkPixbuf* getPixBuf(char* name) { GFile* file=g_file_new_for_path(name); GFileInfo* file_info=g_file_query_info(file,"standard::*",G_FILE_QUERY_INFO_NONE,NULL,NULL); GIcon* icon=g_file_info_get_icon(file_info); GdkPixbuf* pix=NULL; gchar* path; gchar const* const* names; GFile* icon_file; char* newname; if(G_IS_THEMED_ICON(icon)) { names=g_themed_icon_get_names(G_THEMED_ICON(icon)); pix=gtk_icon_theme_load_icon(gtk_icon_theme_get_default(),*names,16,(GtkIconLookupFlags)(GTK_ICON_LOOKUP_USE_BUILTIN|GTK_ICON_LOOKUP_FORCE_SVG|GTK_ICON_LOOKUP_GENERIC_FALLBACK|GTK_ICON_LOOKUP_FORCE_SIZE),NULL); if(pix==NULL) { asprintf(&newname,"gnome-mime-%s",*names); pix=gtk_icon_theme_load_icon(gtk_icon_theme_get_default(),(const gchar*)newname,16,(GtkIconLookupFlags)(GTK_ICON_LOOKUP_USE_BUILTIN|GTK_ICON_LOOKUP_FORCE_SVG|GTK_ICON_LOOKUP_GENERIC_FALLBACK|GTK_ICON_LOOKUP_FORCE_SIZE),NULL); debugFree(&newname); } } else if(G_IS_FILE_ICON(icon)) { icon_file=g_file_icon_get_file(G_FILE_ICON(icon)); path=g_file_get_path(icon_file); pix=gdk_pixbuf_new_from_file_at_size(path,16,16,NULL); debugFree(&path); g_object_unref(G_OBJECT(icon_file)); } g_object_unref(G_OBJECT(file)); g_object_unref(G_OBJECT(file_info)); return(pix); }
GdkPixbuf * get_file_pixbuf (GSearchWindow * gsearch, GFileInfo * file_info) { GdkPixbuf * pixbuf; GIcon * icon = NULL; const gchar * thumbnail_path = NULL; if (file_info == NULL) { return NULL; } icon = g_file_info_get_icon (file_info); if (gsearch->show_thumbnails == TRUE) { thumbnail_path = g_file_info_get_attribute_byte_string (file_info, G_FILE_ATTRIBUTE_THUMBNAIL_PATH); } if (thumbnail_path != NULL) { pixbuf = gsearchtool_get_thumbnail_image (thumbnail_path); } else { gchar * icon_string; icon_string = g_icon_to_string (icon); pixbuf = (GdkPixbuf *) g_hash_table_lookup (gsearch->search_results_filename_hash_table, icon_string); if (pixbuf == NULL) { pixbuf = get_themed_icon_pixbuf (G_THEMED_ICON (icon), ICON_SIZE, gtk_icon_theme_get_default ()); g_hash_table_insert (gsearch->search_results_filename_hash_table, g_strdup (icon_string), pixbuf); } g_free (icon_string); } return pixbuf; }
QStringList On::placesBookmarks() { QFile file(QDir::homePath()+"/.gtk-bookmarks"); if (file.open(QIODevice::ReadOnly | QIODevice::Text)) { QTextStream in(&file); QStringList bookmarks; QString line; in.setCodec("UTF-8"); while (!in.atEnd()) { QString line = in.readLine(); GFile *file = g_file_new_for_uri(line.toLocal8Bit()); GFileInfo *fileInfo = g_file_query_info(file, "standard::*", 0, NULL, NULL); QString icon = g_icon_to_string(g_file_info_get_icon(fileInfo)); if (icon != NULL) { if (icon.contains(" ")) icon = icon.split(" ")[2]; bookmarks.append(line); bookmarks.append(QUrl::fromPercentEncoding(QFileInfo(line).fileName().toLocal8Bit())); bookmarks.append(getThemeIcon(icon)); } } file.close(); return bookmarks; } return QStringList(); }
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; }
void TrashLauncherIcon::UpdateTrashIconCb(GObject* source, GAsyncResult* res, gpointer data) { auto self = static_cast<TrashLauncherIcon*>(data); // FIXME: should use the generic LoadIcon function (not taking from the unity theme) glib::Object<GFileInfo> info(g_file_query_info_finish(G_FILE(source), res, nullptr)); if (info) { glib::Object<GIcon> icon(g_file_info_get_icon(info), glib::AddRef()); glib::String icon_string(g_icon_to_string(icon)); self->icon_name = icon_string.Str(); self->empty_ = (self->icon_name == "user-trash"); } }
static GIcon * get_icon (GFile *file, GFileInfo *info) { GIcon *icon; icon = NULL; if (info) { icon = g_file_info_get_icon (info); if (icon) g_object_ref (icon); } return icon; }
static GIcon * get_icon (GFile *file) { GFileInfo *info; GIcon *icon; icon = NULL; info = g_file_query_info (file, G_FILE_ATTRIBUTE_STANDARD_ICON, 0, NULL, NULL); if (info) { icon = g_file_info_get_icon (info); if (icon) g_object_ref (icon); g_object_unref (info); } return icon; }
bool DefaultThumbnailer::Run(int size, std::string const& input_file, std::string& output_file, std::string& error_hint) { glib::Object<GFile> file(::g_file_new_for_uri(input_file.c_str())); GError *err = NULL; glib::Object<GFileInfo> file_info(g_file_query_info(file, G_FILE_ATTRIBUTE_STANDARD_ICON, G_FILE_QUERY_INFO_NONE, NULL, &err)); if (err != NULL) { error_hint = err->message; g_error_free (err); return ""; } GIcon* icon = g_file_info_get_icon(file_info); // [transfer none] output_file = g_icon_to_string(icon); return true; }
static GdkPixbuf* anjuta_docman_get_pixbuf_for_file (GFile* file) { /* add a nice mime-type icon if we can */ const gchar** icon_names; GtkIconInfo* icon_info; GIcon* icon; GdkPixbuf* pixbuf; GFileInfo* file_info; GError* err = NULL; g_return_val_if_fail (file != NULL, NULL); file_info = g_file_query_info (file, "standard::*", G_FILE_QUERY_INFO_NONE, NULL, &err); if (err) DEBUG_PRINT ("GFile-Error %s", err->message); if (file_info != NULL) { icon = g_file_info_get_icon (file_info); g_object_get (icon, "names", &icon_names, NULL); icon_info = gtk_icon_theme_choose_icon (gtk_icon_theme_get_default(), icon_names, GTK_ICON_SIZE_MENU, GTK_ICON_LOOKUP_GENERIC_FALLBACK); pixbuf = gtk_icon_info_load_icon (icon_info, NULL); gtk_icon_info_free(icon_info); g_object_unref (icon); if (pixbuf != NULL) { return pixbuf; } } return NULL; }
GdkPixbuf * iconstore_get_pixbuf (GFileInfo * file_info) { // create new hash table if (pixbuf_hash_table == NULL) { pixbuf_hash_table = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref); } GIcon *icon = NULL; gboolean icon_needs_free = FALSE; if (file_info) { icon = g_file_info_get_icon (file_info); } else { icon = g_icon_new_for_string ("image-missing", NULL); icon_needs_free = TRUE; } gchar *icon_string = g_icon_to_string (icon); GdkPixbuf *pixbuf = (GdkPixbuf *) g_hash_table_lookup (pixbuf_hash_table, icon_string); if (pixbuf == NULL) { pixbuf = get_themed_icon_pixbuf (G_THEMED_ICON (icon), ICON_SIZE, gtk_icon_theme_get_default ()); g_hash_table_insert (pixbuf_hash_table, g_strdup (icon_string), pixbuf); } if (icon_needs_free) { g_object_unref (icon); } g_free (icon_string); return pixbuf; }
/** * 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"); }
void vfs_backend_get_file_info (const gchar *cBaseURI, gchar **cName, gchar **cURI, gchar **cIconName, gboolean *bIsDirectory, int *iVolumeID, double *fOrder, CairoDockFMSortType iSortType) { g_return_if_fail (cBaseURI != NULL); GError *erreur = NULL; cd_message ("%s (%s)", __func__, cBaseURI); gchar *cFullURI; if (strncmp (cBaseURI, "x-nautilus-desktop://", 21) == 0) { gchar *cNautilusFile = g_strdup (cBaseURI+14); memcpy (cNautilusFile, "file", 4); if (g_str_has_suffix (cBaseURI, ".volume")) { cNautilusFile[strlen(cNautilusFile)-7] = '\0'; } else if (g_str_has_suffix (cBaseURI, ".drive")) { cNautilusFile[strlen(cNautilusFile)-6] = '\0'; } cFullURI = g_filename_from_uri (cNautilusFile, NULL, &erreur); if (erreur != NULL) { cd_warning ("gnome_integration : %s", erreur->message); g_error_free (erreur); return ; } gchar *cVolumeName = cFullURI + 1; // on saute le '/'. cd_message ("cVolumeName : %s", cVolumeName); GMount *pMount = NULL; _cd_find_mount_from_volume_name (cVolumeName, &pMount, cURI, cIconName); g_return_if_fail (pMount != NULL); *cName = g_strdup (cVolumeName); *bIsDirectory = TRUE; *iVolumeID = 1; *fOrder = 0; //g_object_unref (pMount); g_free (cFullURI); //g_free (cNautilusFile); return; } else { if (*cBaseURI == '/') cFullURI = g_filename_to_uri (cBaseURI, NULL, NULL); else cFullURI = g_strdup (cBaseURI); } cd_message (" -> cFullURI : %s", cFullURI); GFile *pFile = g_file_new_for_uri (cFullURI); const gchar *cQuery = G_FILE_ATTRIBUTE_STANDARD_TYPE"," G_FILE_ATTRIBUTE_STANDARD_SIZE"," G_FILE_ATTRIBUTE_TIME_MODIFIED"," G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE"," G_FILE_ATTRIBUTE_STANDARD_NAME"," G_FILE_ATTRIBUTE_STANDARD_ICON"," G_FILE_ATTRIBUTE_STANDARD_TARGET_URI"," G_FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE; GFileInfo *pFileInfo = g_file_query_info (pFile, cQuery, G_FILE_QUERY_INFO_NONE, /// G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS NULL, &erreur); //g_object_unref (pFile); if (erreur != NULL) { cd_warning ("gnome_integration : %s", erreur->message); g_error_free (erreur); return ; } *cURI = cFullURI; const gchar *cFileName = g_file_info_get_name (pFileInfo); const gchar *cMimeType = g_file_info_get_content_type (pFileInfo); GFileType iFileType = g_file_info_get_file_type (pFileInfo); if (iSortType == CAIRO_DOCK_FM_SORT_BY_DATE) { GTimeVal t; g_file_info_get_modification_time (pFileInfo, &t); *fOrder = t.tv_sec; } else if (iSortType == CAIRO_DOCK_FM_SORT_BY_SIZE) *fOrder = g_file_info_get_size (pFileInfo); else if (iSortType == CAIRO_DOCK_FM_SORT_BY_TYPE) *fOrder = (cMimeType != NULL ? *((int *) cMimeType) : 0); else *fOrder = 0; *bIsDirectory = (iFileType == G_FILE_TYPE_DIRECTORY); cd_message (" => '%s' (mime:%s ; bIsDirectory:%d)", cFileName, cMimeType, *bIsDirectory); if (iFileType == G_FILE_TYPE_MOUNTABLE) { *cName = NULL; *iVolumeID = 1; const gchar *cTargetURI = g_file_info_get_attribute_string (pFileInfo, G_FILE_ATTRIBUTE_STANDARD_TARGET_URI); cd_message (" cTargetURI:%s", cTargetURI); GMount *pMount = NULL; if (cTargetURI != NULL) { GFile *file = g_file_new_for_uri (cTargetURI); pMount = g_file_find_enclosing_mount (file, NULL, NULL); //g_object_unref (file); } if (pMount != NULL) { *cName = g_mount_get_name (pMount); cd_message ("un GMount existe (%s)",* cName); } else { gchar *cMountName = g_strdup (cFileName); gchar *str = strrchr (cMountName, '.'); // on vire l'extension ".volume" ou ".drive". if (str != NULL) { *str = '\0'; if (strcmp (str+1, "link") == 0) // pour les liens, on prend le nom du lien. { if (strcmp (cMountName, "root") == 0) // on remplace 'root' par un nom plus parlant, sinon on prendra le nom du lien. { *cName = g_strdup ("/"); } } else if (strcmp (str+1, "drive") == 0) // on cherche un nom plus parlant si possible. { gchar *cVolumeName = _cd_find_volume_name_from_drive_name (cMountName); if (cVolumeName != NULL) { *cName = cVolumeName; } } } if (*cName == NULL) *cName = cMountName; //else //g_free (cMountName); } if (*cName == NULL) *cName = g_strdup (cFileName); } else { *iVolumeID = 0; *cName = g_strdup (cFileName); } *cIconName = NULL; if (cMimeType != NULL && strncmp (cMimeType, "image", 5) == 0) { gchar *cHostname = NULL; GError *erreur = NULL; gchar *cFilePath = g_filename_from_uri (cBaseURI, &cHostname, &erreur); if (erreur != NULL) { g_error_free (erreur); } else if (cHostname == NULL || strcmp (cHostname, "localhost") == 0) // on ne recupere la vignette que sur les fichiers locaux. { *cIconName = g_strdup (cFilePath); cairo_dock_remove_html_spaces (*cIconName); } //g_free (cHostname); } if (*cIconName == NULL) { GIcon *pSystemIcon = g_file_info_get_icon (pFileInfo); if (pSystemIcon != NULL) { *cIconName = _cd_get_icon_path (pSystemIcon); } } cd_message ("cIconName : %s", *cIconName); //*iVolumeID = g_file_info_get_attribute_uint32 (pFileInfo, G_FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE); //cd_message ("ID : %d\n", *iVolumeID); //g_object_unref (pFileInfo); }
nsresult nsIconChannel::InitWithGIO(nsIMozIconURI *aIconURI) { GIcon *icon = NULL; 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, NULL, NULL); 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 = NULL; // 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 = NULL; // 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, NULL); 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; }
GList *vfs_backend_list_directory (const gchar *cBaseURI, CairoDockFMSortType iSortType, int iNewIconsType, gboolean bListHiddenFiles, gchar **cFullURI) { g_return_val_if_fail (cBaseURI != NULL, NULL); cd_message ("%s (%s)", __func__, cBaseURI); gchar *cURI; gboolean bAddHome = FALSE; if (strcmp (cBaseURI, CAIRO_DOCK_FM_VFS_ROOT) == 0) { cURI = g_strdup ("computer://"); bAddHome = TRUE; ///*cFullURI = cURI; ///return vfs_backend_list_volumes (); //vfs_backend_list_volumes (); } else if (strcmp (cBaseURI, CAIRO_DOCK_FM_NETWORK) == 0) cURI = g_strdup ("network://"); else cURI = (*cBaseURI == '/' ? g_strconcat ("file://", cBaseURI, NULL) : g_strdup (cBaseURI)); *cFullURI = cURI; GFile *pFile = g_file_new_for_uri (cURI); GError *erreur = NULL; const gchar *cAttributes = G_FILE_ATTRIBUTE_STANDARD_TYPE"," G_FILE_ATTRIBUTE_STANDARD_SIZE"," G_FILE_ATTRIBUTE_TIME_MODIFIED"," G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE"," G_FILE_ATTRIBUTE_STANDARD_NAME"," G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN"," G_FILE_ATTRIBUTE_STANDARD_ICON"," G_FILE_ATTRIBUTE_STANDARD_TARGET_URI"," G_FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE; GFileEnumerator *pFileEnum = g_file_enumerate_children (pFile, cAttributes, G_FILE_QUERY_INFO_NONE, /// G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS NULL, &erreur); //g_object_unref (pFile); if (erreur != NULL) { cd_warning ("gnome_integration : %s", erreur->message); g_error_free (erreur); return NULL; } int iOrder = 0; GList *pIconList = NULL; Icon *icon; GFileInfo *pFileInfo; do { pFileInfo = g_file_enumerator_next_file (pFileEnum, NULL, &erreur); if (erreur != NULL) { cd_warning ("gnome_integration : %s", erreur->message); g_error_free (erreur); erreur = NULL; continue; } if (pFileInfo == NULL) break ; gboolean bIsHidden = g_file_info_get_is_hidden (pFileInfo); if (bListHiddenFiles || ! bIsHidden) { GFileType iFileType = g_file_info_get_file_type (pFileInfo); GIcon *pFileIcon = g_file_info_get_icon (pFileInfo); if (pFileIcon == NULL) { cd_message ("AUCUNE ICONE"); continue; } const gchar *cFileName = g_file_info_get_name (pFileInfo); const gchar *cMimeType = g_file_info_get_content_type (pFileInfo); gchar *cName = NULL; icon = g_new0 (Icon, 1); icon->iType = iNewIconsType; icon->cBaseURI = g_strconcat (*cFullURI, "/", cFileName, NULL); cd_message ("+ %s (mime:%s)", icon->cBaseURI, cMimeType); if (iFileType == G_FILE_TYPE_MOUNTABLE) { const gchar *cTargetURI = g_file_info_get_attribute_string (pFileInfo, G_FILE_ATTRIBUTE_STANDARD_TARGET_URI); cd_message (" c'est un point de montage correspondant a %s", cTargetURI); GMount *pMount = NULL; if (cTargetURI != NULL) { icon->acCommand = g_strdup (cTargetURI); GFile *file = g_file_new_for_uri (cTargetURI); pMount = g_file_find_enclosing_mount (file, NULL, NULL); //g_object_unref (file); } if (pMount != NULL) { cName = g_mount_get_name (pMount); cd_message ("un GMount existe (%s)", cName); GVolume *volume = g_mount_get_volume (pMount); if (volume) cd_message (" volume associe : %s", g_volume_get_name (volume)); GDrive *drive = g_mount_get_drive (pMount); if (drive) cd_message (" disque associe : %s", g_drive_get_name (drive)); ///pFileIcon = g_mount_get_icon (pMount); } else { cName = g_strdup (cFileName); gchar *str = strrchr (cName, '.'); // on vire l'extension ".volume" ou ".drive". if (str != NULL) { *str = '\0'; if (strcmp (str+1, "link") == 0) { if (strcmp (cName, "root") == 0) { g_free (cName); cName = g_strdup ("/"); } } else if (strcmp (str+1, "drive") == 0) // on cherche un nom plus parlant si possible. { gchar *cVolumeName = _cd_find_volume_name_from_drive_name (cName); if (cVolumeName != NULL) { g_free (cName); g_free (cVolumeName); continue; /// apparemment il n'est plus necessaire d'afficher les .drives qui ont 1 (ou plusieurs ?) volumes, car ces derniers sont dans la liste, donc ca fait redondant. /**if (strcmp (cVolumeName, "discard") == 0) continue; g_free (cName); cName = cVolumeName;*/ } } } } icon->iVolumeID = 1; cd_message ("le nom de ce volume est : %s", cName); } else cName = g_strdup (cFileName); if (icon->acCommand == NULL) icon->acCommand = g_strdup (icon->cBaseURI); icon->acName = cName; icon->acFileName = NULL; if (cMimeType != NULL && strncmp (cMimeType, "image", 5) == 0) { gchar *cHostname = NULL; gchar *cFilePath = g_filename_from_uri (icon->cBaseURI, &cHostname, &erreur); if (erreur != NULL) { g_error_free (erreur); erreur = NULL; } else if (cHostname == NULL || strcmp (cHostname, "localhost") == 0) // on ne recupere la vignette que sur les fichiers locaux. { icon->acFileName = g_strdup (cFilePath); cairo_dock_remove_html_spaces (icon->acFileName); } g_free (cHostname); g_free (cFilePath); } if (icon->acFileName == NULL) { icon->acFileName = _cd_get_icon_path (pFileIcon); cd_message ("icon->acFileName : %s", icon->acFileName); } if (iSortType == CAIRO_DOCK_FM_SORT_BY_SIZE) icon->fOrder = g_file_info_get_size (pFileInfo); else if (iSortType == CAIRO_DOCK_FM_SORT_BY_DATE) { GTimeVal t; g_file_info_get_modification_time (pFileInfo, &t); icon->fOrder = t.tv_sec; } else if (iSortType == CAIRO_DOCK_FM_SORT_BY_TYPE) icon->fOrder = (cMimeType != NULL ? *((int *) cMimeType) : 0); if (icon->fOrder == 0) // un peu moyen mais mieux que rien non ? icon->fOrder = iOrder; pIconList = g_list_insert_sorted (pIconList, icon, (GCompareFunc) cairo_dock_compare_icons_order); //g_list_prepend (pIconList, icon); iOrder ++; } } while (TRUE); // 'g_file_enumerator_close' est appelee lors du dernier 'g_file_enumerator_next_file'. if (bAddHome && pIconList != NULL) { icon = g_new0 (Icon, 1); icon->iType = iNewIconsType; icon->cBaseURI = g_strdup_printf ("file://%s", "/home"); icon->acCommand = g_strdup ("/home"); //icon->acCommand = g_strdup (icon->cBaseURI); icon->iVolumeID = 0; icon->acName = g_strdup ("home"); Icon *pRootIcon = cairo_dock_get_icon_with_name (pIconList, "/"); if (pRootIcon == NULL) { pRootIcon = cairo_dock_get_first_icon (pIconList); g_print ("domage ! (%s:%s)\n", pRootIcon->acCommand, pRootIcon->acName); } icon->acFileName = g_strdup (pRootIcon->acFileName); icon->fOrder = iOrder++; pIconList = g_list_insert_sorted (pIconList, icon, (GCompareFunc) cairo_dock_compare_icons_order); } if (iSortType == CAIRO_DOCK_FM_SORT_BY_NAME) pIconList = cairo_dock_sort_icons_by_name (pIconList); else pIconList = cairo_dock_sort_icons_by_order (pIconList); return pIconList; }
static void get_folder_content_done_cb (GError *error, gpointer user_data) { LoadData *load_data = user_data; FrFileSelectorDialog *self = load_data->dialog; GtkListStore *list_store; GList *scan; GtkTreeIter iter; GDateTime *today; int sort_column_id; GtkSortType sort_order; GHashTable *selected_files; if (error != NULL) { if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_MOUNTED)) { GMountOperation *operation; operation = gtk_mount_operation_new (GTK_WINDOW (self)); g_file_mount_enclosing_volume (load_data->folder, G_MOUNT_MOUNT_NONE, operation, load_data->cancellable, folder_mount_enclosing_volume_ready_cb, load_data); g_object_unref (operation); return; } if (! g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) _gtk_error_dialog_run (GTK_WINDOW (self), _("Could not load the location"), "%s", error->message); if (load_data->dialog->priv->current_operation == load_data) load_data->dialog->priv->current_operation = NULL; load_data_free (load_data); return; } load_data->files = g_list_reverse (load_data->files); today = g_date_time_new_now_local (); gtk_tree_sortable_get_sort_column_id (GTK_TREE_SORTABLE (GET_WIDGET ("files_liststore")), &sort_column_id, &sort_order); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (GET_WIDGET ("files_liststore")), GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID, 0); selected_files = g_hash_table_new (g_file_hash, (GEqualFunc) g_file_equal); for (scan = load_data->files_to_select; scan; scan = scan->next) g_hash_table_insert(selected_files, scan->data, GINT_TO_POINTER (1)); list_store = GTK_LIST_STORE (GET_WIDGET ("files_liststore")); gtk_list_store_clear (list_store); for (scan = load_data->files; scan; scan = scan->next) { FileInfo *file_info = scan->data; GdkPixbuf *icon_pixbuf; char *size; GTimeVal timeval; GDateTime *datetime; char *modified; char *collate_key; gboolean is_folder; if (! self->priv->show_hidden && g_file_info_get_is_hidden (file_info->info)) continue; gtk_list_store_append (list_store, &iter); icon_pixbuf = gth_icon_cache_get_pixbuf (self->priv->icon_cache, g_file_info_get_icon (file_info->info)); size = g_format_size (g_file_info_get_size (file_info->info)); g_file_info_get_modification_time (file_info->info, &timeval); datetime = g_date_time_new_from_timeval_local (&timeval); modified = g_date_time_format (datetime, _g_date_time_same_day (datetime, today) ? "%X" : "%x"); collate_key = g_utf8_collate_key_for_filename (g_file_info_get_display_name (file_info->info), -1); is_folder = (g_file_info_get_file_type (file_info->info) == G_FILE_TYPE_DIRECTORY); gtk_list_store_set (list_store, &iter, FILE_LIST_COLUMN_ICON, icon_pixbuf, FILE_LIST_COLUMN_NAME, g_file_info_get_display_name (file_info->info), FILE_LIST_COLUMN_SIZE, (is_folder ? "" : size), FILE_LIST_COLUMN_MODIFIED, modified, FILE_LIST_COLUMN_FILE, file_info->file, FILE_LIST_COLUMN_NAME_ORDER, collate_key, FILE_LIST_COLUMN_SIZE_ORDER, g_file_info_get_size (file_info->info), FILE_LIST_COLUMN_MODIFIED_ORDER, timeval.tv_sec, FILE_LIST_COLUMN_IS_FOLDER, is_folder, FILE_LIST_COLUMN_IS_SELECTED, (g_hash_table_lookup (selected_files, file_info->file) != NULL), -1); g_free (collate_key); g_free (modified); g_date_time_unref (datetime); g_free (size); _g_object_unref (icon_pixbuf); } gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (GET_WIDGET ("files_liststore")), sort_column_id, sort_order); set_current_folder (self, load_data->folder); if (load_data->dialog->priv->current_operation == load_data) load_data->dialog->priv->current_operation = NULL; g_hash_table_unref (selected_files); g_date_time_unref (today); load_data_free (load_data); }
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; }
/** * Gets the icon name from a {@link GLib.File}. * * @param file the file to get the icon name for * @return the icon name for the file, or null if none exists */ gchar* plank_drawing_drawing_service_get_icon_from_file (GFile* file) { gchar* result = NULL; GError * _inner_error_ = NULL; g_return_val_if_fail (file != NULL, NULL); { GFileInfo* info = NULL; GFile* _tmp0_ = NULL; GFileInfo* _tmp1_ = NULL; gchar* custom_icon_name = NULL; GFileInfo* _tmp2_ = NULL; const gchar* _tmp3_ = NULL; gchar* _tmp4_ = NULL; gboolean _tmp5_ = FALSE; const gchar* _tmp6_ = NULL; gchar* custom_icon = NULL; GFileInfo* _tmp8_ = NULL; const gchar* _tmp9_ = NULL; gchar* _tmp10_ = NULL; gboolean _tmp11_ = FALSE; const gchar* _tmp12_ = NULL; gchar* thumb_icon = NULL; GFileInfo* _tmp22_ = NULL; const gchar* _tmp23_ = NULL; gchar* _tmp24_ = NULL; gboolean _tmp25_ = FALSE; const gchar* _tmp26_ = NULL; GFileInfo* _tmp28_ = NULL; GIcon* _tmp29_ = NULL; gchar* _tmp30_ = NULL; _tmp0_ = file; _tmp1_ = g_file_query_info (_tmp0_, G_FILE_ATTRIBUTE_STANDARD_ICON "," PLANK_DRAWING_DRAWING_SERVICE_FILE_ATTRIBUTE_CUSTOM_ICON_NAME "," PLANK_DRAWING_DRAWING_SERVICE_FILE_ATTRIBUTE_CUSTOM_ICON "," G_FILE_ATTRIBUTE_THUMBNAIL_PATH, 0, NULL, &_inner_error_); info = _tmp1_; if (_inner_error_ != NULL) { goto __catch1_g_error; } _tmp2_ = info; _tmp3_ = g_file_info_get_attribute_string (_tmp2_, PLANK_DRAWING_DRAWING_SERVICE_FILE_ATTRIBUTE_CUSTOM_ICON_NAME); _tmp4_ = g_strdup (_tmp3_); custom_icon_name = _tmp4_; _tmp6_ = custom_icon_name; if (_tmp6_ != NULL) { const gchar* _tmp7_ = NULL; _tmp7_ = custom_icon_name; _tmp5_ = g_strcmp0 (_tmp7_, "") != 0; } else { _tmp5_ = FALSE; } if (_tmp5_) { result = custom_icon_name; _g_object_unref0 (info); return result; } _tmp8_ = info; _tmp9_ = g_file_info_get_attribute_string (_tmp8_, PLANK_DRAWING_DRAWING_SERVICE_FILE_ATTRIBUTE_CUSTOM_ICON); _tmp10_ = g_strdup (_tmp9_); custom_icon = _tmp10_; _tmp12_ = custom_icon; if (_tmp12_ != NULL) { const gchar* _tmp13_ = NULL; _tmp13_ = custom_icon; _tmp11_ = g_strcmp0 (_tmp13_, "") != 0; } else { _tmp11_ = FALSE; } if (_tmp11_) { const gchar* _tmp14_ = NULL; gboolean _tmp15_ = FALSE; GFile* _tmp16_ = NULL; const gchar* _tmp17_ = NULL; GFile* _tmp18_ = NULL; GFile* _tmp19_ = NULL; gchar* _tmp20_ = NULL; gchar* _tmp21_ = NULL; _tmp14_ = custom_icon; _tmp15_ = g_str_has_prefix (_tmp14_, "file://"); if (_tmp15_) { result = custom_icon; _g_free0 (custom_icon_name); _g_object_unref0 (info); return result; } _tmp16_ = file; _tmp17_ = custom_icon; _tmp18_ = g_file_get_child (_tmp16_, _tmp17_); _tmp19_ = _tmp18_; _tmp20_ = g_file_get_path (_tmp19_); _tmp21_ = _tmp20_; _g_object_unref0 (_tmp19_); result = _tmp21_; _g_free0 (custom_icon); _g_free0 (custom_icon_name); _g_object_unref0 (info); return result; } _tmp22_ = info; _tmp23_ = g_file_info_get_attribute_byte_string (_tmp22_, G_FILE_ATTRIBUTE_THUMBNAIL_PATH); _tmp24_ = g_strdup (_tmp23_); thumb_icon = _tmp24_; _tmp26_ = thumb_icon; if (_tmp26_ != NULL) { const gchar* _tmp27_ = NULL; _tmp27_ = thumb_icon; _tmp25_ = g_strcmp0 (_tmp27_, "") != 0; } else { _tmp25_ = FALSE; } if (_tmp25_) { result = thumb_icon; _g_free0 (custom_icon); _g_free0 (custom_icon_name); _g_object_unref0 (info); return result; } _tmp28_ = info; _tmp29_ = g_file_info_get_icon (_tmp28_); _tmp30_ = plank_drawing_drawing_service_get_icon_from_gicon (_tmp29_); result = _tmp30_; _g_free0 (thumb_icon); _g_free0 (custom_icon); _g_free0 (custom_icon_name); _g_object_unref0 (info); return result; } goto __finally1; __catch1_g_error: { gchar* _tmp31_ = NULL; GFile* _tmp32_ = NULL; gchar* _tmp33_ = NULL; g_clear_error (&_inner_error_); _inner_error_ = NULL; _tmp32_ = file; _tmp33_ = g_file_get_path (_tmp32_); _tmp31_ = _tmp33_; if (_tmp31_ == NULL) { gchar* _tmp34_ = NULL; _tmp34_ = g_strdup (""); _g_free0 (_tmp31_); _tmp31_ = _tmp34_; } g_debug ("DrawingService.vala:80: Could not get file info for '%s'", _tmp31_); _g_free0 (_tmp31_); } __finally1: if (_inner_error_ != NULL) { g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); g_clear_error (&_inner_error_); return NULL; } result = NULL; return result; }
static GIcon * xfdesktop_regular_file_icon_load_icon(XfdesktopIcon *icon) { XfdesktopRegularFileIcon *regular_icon = XFDESKTOP_REGULAR_FILE_ICON(icon); XfdesktopFileIcon *file_icon = XFDESKTOP_FILE_ICON(icon); GIcon *gicon = NULL; TRACE("entering"); /* Try to load the icon referenced in the .desktop file */ if(xfdesktop_file_utils_is_desktop_file(regular_icon->priv->file_info)) { gicon = xfdesktop_load_icon_from_desktop_file(regular_icon); } else if(g_file_info_get_file_type(regular_icon->priv->file_info) == G_FILE_TYPE_DIRECTORY) { /* Try to load a thumbnail from the standard folder image locations */ gchar *thumbnail_file = NULL; if(regular_icon->priv->show_thumbnails) thumbnail_file = xfdesktop_load_icon_location_from_folder(file_icon); if(thumbnail_file) { /* If there's a folder thumbnail, use it */ regular_icon->priv->thumbnail_file = g_file_new_for_path(thumbnail_file); gicon = g_file_icon_new(regular_icon->priv->thumbnail_file); g_free(thumbnail_file); } } else { /* If we have a thumbnail then they are enabled, use it. */ if(regular_icon->priv->thumbnail_file) { gchar *file = g_file_get_path(regular_icon->priv->file); gchar *mimetype = xfdesktop_get_file_mimetype(file); /* Don't use thumbnails for svg, use the file itself */ if(g_strcmp0(mimetype, "image/svg+xml") == 0) gicon = g_file_icon_new(regular_icon->priv->file); else gicon = g_file_icon_new(regular_icon->priv->thumbnail_file); g_free(mimetype); g_free(file); } } /* If we still don't have an icon, use the default */ if(!G_IS_ICON(gicon)) { gicon = g_file_info_get_icon(regular_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); /* load the read only emblem if necessary */ if(!g_file_info_get_attribute_boolean(regular_icon->priv->file_info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE)) { GIcon *themed_icon = g_themed_icon_new(EMBLEM_READONLY); GEmblem *emblem = g_emblem_new(themed_icon); g_emblemed_icon_add_emblem(G_EMBLEMED_ICON(gicon), emblem); g_object_unref(emblem); g_object_unref(themed_icon); } /* load the symlink emblem if necessary */ if(g_file_info_get_attribute_boolean(regular_icon->priv->file_info, G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK)) { GIcon *themed_icon = g_themed_icon_new(EMBLEM_SYMLINK); GEmblem *emblem = g_emblem_new(themed_icon); g_emblemed_icon_add_emblem(G_EMBLEMED_ICON(gicon), emblem); g_object_unref(emblem); g_object_unref(themed_icon); } return gicon; }