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;
}
