static void
volume_mount_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
PanelVolumeMountData *mount_data = user_data;
GError *error;
char *primary;
char *name;
error = NULL;
if (!g_volume_mount_finish (G_VOLUME (source_object), res, &error)) {
if (error->code != G_IO_ERROR_FAILED_HANDLED) {
name = g_volume_get_name (G_VOLUME (source_object));
primary = g_strdup_printf (_("Unable to mount %s"),
name);
g_free (name);
panel_error_dialog (NULL, mount_data->screen,
"cannot_mount_volume", TRUE,
primary, error->message);
g_free (primary);
}
g_error_free (error);
}
//FIXME: should we activate the root of the new mount?
g_object_unref (mount_data->mount_op);
g_slice_free (PanelVolumeMountData, mount_data);
}
static gboolean
ignore_volume (GVolume *volume)
{
gboolean ret = TRUE;
char *path;
GDrive *drive;
/* Ignore drive? */
drive = g_volume_get_drive (volume);
if (drive != NULL && ignore_drive (drive)) {
g_object_unref (drive);
return TRUE;
}
g_clear_object (&drive);
path = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);
if (path != NULL) {
ret = FALSE;
g_free (path);
} else {
GRL_DEBUG ("%s: Not adding volume %s as it has no identifier", __FUNCTION__,
g_volume_get_name (volume));
}
return ret;
}
static void
panel_menu_item_append_volume (GtkWidget *menu,
GVolume *volume)
{
GtkWidget *item;
GIcon *icon;
char *title;
char *tooltip;
icon = g_volume_get_icon (volume);
title = g_volume_get_name (volume);
item = panel_image_menu_item_new ();
setup_menu_item_with_icon (item,
panel_menu_icon_get_size (),
NULL, NULL, icon,
title);
g_object_unref (icon);
tooltip = g_strdup_printf (_("Mount %s"), title);
panel_util_set_tooltip_text (item, tooltip);
g_free (tooltip);
g_free (title);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
g_signal_connect_data (item, "activate",
G_CALLBACK (panel_menu_item_mount_volume),
g_object_ref (volume),
(GClosureNotify) g_object_unref, 0);
g_signal_connect (G_OBJECT (item), "button_press_event",
G_CALLBACK (menu_dummy_button_press_event), NULL);
}
static void
do_volume_tests (GDrive *drive, GVolume *volume)
{
GDrive *d;
gchar *name;
GMount *mount;
gchar *uuid;
name = g_volume_get_name (volume);
g_assert (name != NULL);
g_free (name);
d = g_volume_get_drive (volume);
g_assert (d == drive);
if (d != NULL)
g_object_unref (d);
mount = g_volume_get_mount (volume);
if (mount != NULL)
{
do_mount_tests (drive, volume, mount);
g_object_unref (mount);
}
uuid = g_volume_get_uuid (volume);
if (uuid)
{
GVolume *v;
v = g_volume_monitor_get_volume_for_uuid (monitor, uuid);
g_assert (v == volume);
g_object_unref (v);
g_free (uuid);
}
}
static GList *
add_volume (GList *media_list,
GVolume *volume,
GDrive *drive,
GrlOpticalMediaSource *source)
{
char *name, *icon_uri;
GIcon *icon;
char *device_path, *id;
GrlMedia * media;
GMount *mount;
device_path = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);
if (device_path == NULL)
return media_list;
/* Is it an audio CD or a blank media */
mount = g_volume_get_mount (volume);
if (mount != NULL) {
GFile *root;
root = g_mount_get_root (mount);
g_object_unref (mount);
if (g_file_has_uri_scheme (root, "burn") != FALSE || g_file_has_uri_scheme (root, "cdda") != FALSE) {
/* We don't add Audio CDs, or blank media */
g_object_unref (root);
g_free (device_path);
return media_list;
}
g_object_unref (root);
}
media = grl_media_video_new ();
id = g_filename_to_uri (device_path, NULL, NULL);
g_free (device_path);
grl_media_set_id (media, id);
g_free (id);
/* Work out an icon to display */
icon = g_volume_get_icon (volume);
icon_uri = get_uri_for_gicon (icon);
g_object_unref (icon);
grl_media_set_thumbnail (media, icon_uri);
g_free (icon_uri);
/* Get the volume's pretty name for the menu label */
name = g_volume_get_name (volume);
g_strstrip (name);
grl_media_set_title (media, name);
g_free (name);
grl_media_set_mime (media, "x-special/device-block");
return g_list_prepend (media_list, media);
}
static void
monitor_volume_changed (GVolumeMonitor *volume_monitor, GVolume *volume)
{
char *name;
name = g_volume_get_name (volume);
g_print ("Volume changed: '%s'\n", name);
g_free (name);
monitor_print_volume (volume);
}
static void update_vol(FmPlacesModel* model, FmPlaceItem* item, GtkTreeIter* it, FmFileInfoJob* job)
{
FmIcon* icon;
GIcon* gicon;
char* name;
GdkPixbuf* pix;
GMount* mount;
FmPath* path;
name = g_volume_get_name(item->vol);
if(item->fi->icon)
fm_icon_unref(item->fi->icon);
gicon = g_volume_get_icon(item->vol);
icon = fm_icon_from_gicon(gicon);
item->fi->icon = icon;
g_object_unref(gicon);
mount = g_volume_get_mount(item->vol);
if(mount)
{
GFile* gf = g_mount_get_root(mount);
path = fm_path_new_for_gfile(gf);
g_object_unref(gf);
g_object_unref(mount);
item->vol_mounted = TRUE;
}
else
{
path = NULL;
item->vol_mounted = FALSE;
}
if(!fm_path_equal(item->fi->path, path))
{
fm_file_info_set_path(item->fi, path);
if(path)
{
if(job)
fm_file_info_job_add(job, path);
else
{
job = fm_file_info_job_new(NULL, FM_FILE_INFO_JOB_FOLLOW_SYMLINK);
model->jobs = g_slist_prepend(model->jobs, job);
g_signal_connect(job, "finished", G_CALLBACK(on_file_info_job_finished), model);
fm_job_run_async(FM_JOB(job));
}
fm_path_unref(path);
}
}
pix = fm_icon_get_pixbuf(item->fi->icon, fm_config->pane_icon_size);
gtk_list_store_set(GTK_LIST_STORE(model), it, FM_PLACES_MODEL_COL_ICON, pix, FM_PLACES_MODEL_COL_LABEL, name, -1);
g_object_unref(pix);
g_free(name);
}
static gchar *_cd_find_volume_name_from_drive_name (const gchar *cName)
{
g_return_val_if_fail (cName != NULL, NULL);
cd_message ("%s (%s)", __func__, cName);
GDrive *pDrive = _cd_find_drive_from_name (cName);
g_return_val_if_fail (pDrive != NULL, NULL);
gchar *cVolumeName = NULL;
GList *pAssociatedVolumes = g_drive_get_volumes (pDrive);
if (pAssociatedVolumes != NULL)
{
GVolume *pVolume;
GList *av;
if (pAssociatedVolumes->next != NULL)
{
cd_message ("ce disque contient plus d'un volume, on garde le nom du disque plutot que de selectionner le nom d'un volume");
cd_message ("Pour info, la liste des volumes disponibles sur ce disque est :");
for (av = pAssociatedVolumes; av != NULL; av = av->next)
{
pVolume = av->data;
cd_message (" - %s", g_volume_get_name (pVolume));
/*if (cVolumeName == NULL)
cVolumeName = g_volume_get_name (pVolume);
else
cd_warning ("Attention : this drive (%s) has more than 1 volume but we only consider the first one (%s), ignoring %s", cName, cVolumeName, g_volume_get_name (pVolume));*/
g_object_unref (pVolume);
}
}
else
{
return g_strdup ("discard");
pVolume = pAssociatedVolumes->data;
cVolumeName = g_volume_get_name (pVolume);
g_object_unref (pVolume);
cd_message ("ce disque contient 1 seul volume (%s), on prend son nom", cVolumeName);
}
g_list_free (pAssociatedVolumes);
}
//g_object_unref (pDrive);
return cVolumeName;
}
const gchar *
xfdesktop_volume_icon_peek_label(XfdesktopIcon *icon)
{
XfdesktopVolumeIcon *volume_icon = XFDESKTOP_VOLUME_ICON(icon);
g_return_val_if_fail(XFDESKTOP_IS_VOLUME_ICON(icon), NULL);
if(!volume_icon->priv->label) {
volume_icon->priv->label = g_volume_get_name(volume_icon->priv->volume);
}
return volume_icon->priv->label;
}
void GioLister::DeviceInfo::ReadVolumeInfo(GVolume* volume) {
this->volume.reset_without_add(volume);
if (!volume)
return;
volume_name = ConvertAndFree(g_volume_get_name(volume));
volume_uuid = ConvertAndFree(g_volume_get_uuid(volume));
volume_unix_device = ConvertAndFree(g_volume_get_identifier(
volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE));
GFile* root = g_volume_get_activation_root(volume);
if (root) {
volume_root_uri = g_file_get_uri(root);
g_object_unref(root);
}
}
static void
xfdesktop_volume_icon_eject_finish(GObject *object,
GAsyncResult *result,
gpointer user_data)
{
XfdesktopVolumeIcon *icon = XFDESKTOP_VOLUME_ICON(user_data);
GtkWidget *icon_view = xfdesktop_icon_peek_icon_view(XFDESKTOP_ICON(icon));
GtkWidget *toplevel = icon_view ? gtk_widget_get_toplevel(icon_view) : NULL;
GVolume *volume = G_VOLUME(object);
GError *error = NULL;
gboolean eject_successful;
g_return_if_fail(G_IS_VOLUME(object));
g_return_if_fail(G_IS_ASYNC_RESULT(result));
g_return_if_fail(XFDESKTOP_IS_VOLUME_ICON(icon));
eject_successful = g_volume_eject_with_operation_finish(volume, result, &error);
if(!eject_successful) {
/* ignore GIO errors handled internally */
if(error->domain != G_IO_ERROR || error->code != G_IO_ERROR_FAILED_HANDLED) {
gchar *volume_name = g_volume_get_name(volume);
gchar *primary = g_markup_printf_escaped(_("Failed to eject \"%s\""),
volume_name);
/* display an error dialog to inform the user */
xfce_message_dialog(toplevel ? GTK_WINDOW(toplevel) : NULL,
_("Eject Failed"), GTK_STOCK_DIALOG_ERROR,
primary, error->message,
GTK_STOCK_CLOSE, GTK_RESPONSE_ACCEPT, NULL);
g_free(primary);
g_free(volume_name);
}
g_error_free(error);
}
#ifdef HAVE_LIBNOTIFY
xfdesktop_notify_eject_finish(volume, eject_successful);
#endif
g_object_unref(icon);
}
/**
* 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
volume_mount_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
PanelVolumeMountData *mount_data = user_data;
GError *error;
error = NULL;
if (!g_volume_mount_finish (G_VOLUME (source_object), res, &error)) {
char *primary;
char *name;
if (error->code != G_IO_ERROR_FAILED_HANDLED) {
name = g_volume_get_name (G_VOLUME (source_object));
primary = g_strdup_printf (_("Unable to mount %s"),
name);
g_free (name);
panel_error_dialog (NULL, mount_data->screen,
"cannot_mount_volume", TRUE,
primary, error->message);
g_free (primary);
}
g_error_free (error);
} else {
GMount *mount;
GFile *root;
char *rooturi;
mount = g_volume_get_mount (G_VOLUME (source_object));
root = g_mount_get_root (mount);
rooturi = g_file_get_uri (root);
activate_uri_on_screen (rooturi, mount_data->screen);
g_object_unref (mount);
g_object_unref (root);
g_free (rooturi);
}
g_object_unref (mount_data->mount_op);
g_slice_free (PanelVolumeMountData, mount_data);
}
static Icon *_cd_get_icon_for_volume (GVolume *pVolume, GMount *pMount)
{
Icon *pNewIcon = NULL;
GIcon *pIcon;
GFile *pRootDir;
if (pVolume != NULL)
pMount = g_volume_get_mount (pVolume);
else if (pMount == NULL)
return NULL;
if (pMount != NULL) // ce volume est monte.
{
pNewIcon = g_new0 (Icon, 1);
pNewIcon->acName = g_mount_get_name (pMount);
pRootDir = g_mount_get_root (pMount);
pNewIcon->acCommand = g_file_get_uri (pRootDir);
//g_object_unref (pRootDir);
pIcon = g_mount_get_icon (pMount);
pNewIcon->acFileName = _cd_get_icon_path (pIcon);
//g_object_unref (pIcon);
//g_object_unref (pMount);
}
else // ce volume est demonte, on le montre quand meme (l'automount peut etre off).
{
pNewIcon = g_new0 (Icon, 1);
pNewIcon->acName = g_volume_get_name (pVolume);
pIcon = g_volume_get_icon (pVolume);
pNewIcon->acFileName = _cd_get_icon_path (pIcon);
//g_object_unref (pIcon);
pNewIcon->acCommand = g_strdup (pNewIcon->acName);
}
pNewIcon->iVolumeID = 1;
pNewIcon->cBaseURI = g_strdup (pNewIcon->acCommand);
cd_message (" => %s", pNewIcon->acCommand);
return pNewIcon;
}
static void update_vol(PlaceItem* item, GtkTreeIter* it)
{
FmIcon* icon;
GIcon* gicon;
char* name;
GdkPixbuf* pix;
name = g_volume_get_name(item->vol);
if(item->icon)
fm_icon_unref(item->icon);
gicon = g_volume_get_icon(item->vol);
icon = fm_icon_from_gicon(gicon);
item->icon = icon;
g_object_unref(gicon);
pix = fm_icon_get_pixbuf(item->icon, fm_config->pane_icon_size);
gtk_list_store_set(model, it, COL_ICON, pix, COL_LABEL, name, -1);
g_object_unref(pix);
g_free(name);
}
static void volume_added (GVolumeMonitor *monitor, GVolume *volume, GObject *unused)
{
ASVolume *v;
char* name = g_volume_get_name (volume);
if (name == NULL)
return;
/* check if existing - could have been added at the initialization phase */
v = name2Volume (name);
free (name);
if (v != NULL)
return;
v = ASVolume_newGVolume (volume);
SHOW_CHECKPOINT;
if (v) {
show_progress ("Volume \"%s\" added", v->name);
append_bidirelem (AppState.volumes, v);
redecorateVolumes();
}
}
void GVolume2ASVolume (ASVolume *v, GVolume *g_v)
{
GMount *mount = g_volume_get_mount (g_v);
v->gVolume = g_v;
ASVolume_freeData (v);
set_string (&(v->name), g_volume_get_name (v->gVolume));
LOCAL_DEBUG_OUT ("mount = %p", mount);
v->flags = 0;
if (g_volume_can_eject (g_v))
set_flags (v->flags, ASVolume_Ejectable);
if (mount) {
set_flags (v->flags, ASVolume_Mounted);
g_object_unref (mount);
}
if (check_audio_cd (g_v))
set_flags (v->flags, ASVolume_Audio);
else if (check_dvd_video (g_v))
set_flags (v->flags, ASVolume_Video);
v->icon = g_volume_get_icon (g_v);
ASVolume_parseGnomeIconString (v);
}
void
thunar_notify_eject (GVolume *volume)
{
const gchar * const *icon_names;
NotifyNotification *notification = NULL;
const gchar *summary;
GFileInfo *info;
gboolean read_only = FALSE;
GMount *mount;
GFile *icon_file;
GFile *mount_point;
GIcon *icon;
gchar *icon_name = NULL;
gchar *message;
gchar *name;
g_return_if_fail (G_IS_VOLUME (volume));
if (!thunar_notify_init ())
return;
mount = g_volume_get_mount (volume);
if (mount != NULL)
{
mount_point = g_mount_get_root (mount);
info = g_file_query_info (mount_point, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE,
G_FILE_QUERY_INFO_NONE, NULL, NULL);
if (info != NULL)
{
read_only =
!g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE);
g_object_unref (info);
}
g_object_unref (mount_point);
}
name = g_volume_get_name (volume);
icon = g_volume_get_icon (volume);
if (G_IS_THEMED_ICON (icon))
{
icon_names = g_themed_icon_get_names (G_THEMED_ICON (icon));
if (icon_names != NULL)
icon_name = g_strdup (icon_names[0]);
}
else if (G_IS_FILE_ICON (icon))
{
icon_file = g_file_icon_get_file (G_FILE_ICON (icon));
if (icon_file != NULL)
{
icon_name = g_file_get_path (icon_file);
g_object_unref (icon_file);
}
}
g_object_unref (icon);
if (icon_name == NULL)
icon_name = g_strdup ("drive-removable-media");
if (read_only)
{
summary = _("Ejecting device");
message = g_strdup_printf (_("The device \"%s\" is being ejected. "
"This may take some time"), name);
}
else
{
summary = _("Writing data to device");
message = g_strdup_printf (_("There is data that needs to be written to the "
"device \"%s\" before it can be removed. Please "
"do not remove the media or disconnect the drive"),
name);
}
#ifdef NOTIFY_CHECK_VERSION
#if NOTIFY_CHECK_VERSION (0, 7, 0)
notification = notify_notification_new (summary, message, icon_name);
#else
notification = notify_notification_new (summary, message, icon_name, NULL);
#endif
#else
notification = notify_notification_new (summary, message, icon_name, NULL);
#endif
notify_notification_set_urgency (notification, NOTIFY_URGENCY_CRITICAL);
notify_notification_set_timeout (notification, NOTIFY_EXPIRES_NEVER);
notify_notification_show (notification, NULL);
g_object_set_data_full (G_OBJECT (volume), "thunar-notification", notification,
g_object_unref);
g_free (message);
g_free (icon_name);
g_free (name);
}
static void
xfdesktop_volume_icon_mount_finish(GObject *object,
GAsyncResult *result,
gpointer user_data)
{
XfdesktopVolumeIcon *icon = XFDESKTOP_VOLUME_ICON(user_data);
GtkWidget *icon_view = xfdesktop_icon_peek_icon_view(XFDESKTOP_ICON(icon));
GtkWidget *toplevel = gtk_widget_get_toplevel(icon_view);
GVolume *volume = G_VOLUME(object);
GError *error = NULL;
if(!g_volume_mount_finish(volume, result, &error)) {
if(error->domain != G_IO_ERROR || error->code != G_IO_ERROR_FAILED_HANDLED) {
gchar *volume_name = g_volume_get_name(volume);
gchar *primary = g_markup_printf_escaped(_("Failed to mount \"%s\""),
volume_name);
xfce_message_dialog(toplevel ? GTK_WINDOW(toplevel) : NULL,
_("Mount Failed"), GTK_STOCK_DIALOG_ERROR,
primary, error->message,
GTK_STOCK_CLOSE, GTK_RESPONSE_ACCEPT, NULL);
g_free(primary);
g_free(volume_name);
}
g_error_free(error);
} else {
GMount *mount = g_volume_get_mount(volume);
GFile *file = NULL;
GFileInfo *info = NULL;
if(mount) {
file = g_mount_get_root(mount);
info = g_file_query_info(file,
XFDESKTOP_FILE_INFO_NAMESPACE,
G_FILE_QUERY_INFO_NONE,
NULL, NULL);
g_object_unref(mount);
}
if(file && info) {
gboolean activated = FALSE;
if(icon->priv->file)
g_object_unref(icon->priv->file);
icon->priv->file = g_object_ref(file);
xfdesktop_file_icon_update_file_info(XFDESKTOP_FILE_ICON(icon), info);
activated = GPOINTER_TO_UINT(g_object_get_qdata(G_OBJECT(icon),
xfdesktop_volume_icon_activated_quark));
if(activated) {
XfdesktopIcon *icon_p = XFDESKTOP_ICON(icon);
XFDESKTOP_ICON_CLASS(xfdesktop_volume_icon_parent_class)->activated(icon_p);
}
g_object_set_qdata(G_OBJECT(icon), xfdesktop_volume_icon_activated_quark, NULL);
} else {
if(icon->priv->file)
g_object_unref(icon->priv->file);
icon->priv->file = NULL;
xfdesktop_file_icon_update_file_info(XFDESKTOP_FILE_ICON(icon), NULL);
}
if(file)
g_object_unref(file);
if(info)
g_object_unref(info);
}
}
static void
list_volumes (GList *volumes,
int indent,
gboolean only_with_no_drive)
{
GList *l, *mounts;
int c, i;
GMount *mount;
GVolume *volume;
GDrive *drive;
char *name;
char *uuid;
GFile *activation_root;
char **ids;
GIcon *icon;
char *type_name;
const gchar *sort_key;
for (c = 0, l = volumes; l != NULL; l = l->next, c++)
{
volume = (GVolume *) l->data;
if (only_with_no_drive)
{
drive = g_volume_get_drive (volume);
if (drive != NULL)
{
g_object_unref (drive);
continue;
}
}
name = g_volume_get_name (volume);
g_print ("%*sVolume(%d): %s\n", indent, "", c, name);
g_free (name);
type_name = get_type_name (volume);
g_print ("%*sType: %s\n", indent+2, "", type_name);
g_free (type_name);
if (extra_detail)
{
ids = g_volume_enumerate_identifiers (volume);
if (ids && ids[0] != NULL)
{
g_print ("%*sids:\n", indent+2, "");
for (i = 0; ids[i] != NULL; i++)
{
char *id = g_volume_get_identifier (volume,
ids[i]);
g_print ("%*s %s: '%s'\n", indent+2, "", ids[i], id);
g_free (id);
}
}
g_strfreev (ids);
uuid = g_volume_get_uuid (volume);
if (uuid)
g_print ("%*suuid=%s\n", indent + 2, "", uuid);
activation_root = g_volume_get_activation_root (volume);
if (activation_root)
{
char *uri;
uri = g_file_get_uri (activation_root);
g_print ("%*sactivation_root=%s\n", indent + 2, "", uri);
g_free (uri);
g_object_unref (activation_root);
}
icon = g_volume_get_icon (volume);
if (icon)
{
if (G_IS_THEMED_ICON (icon))
show_themed_icon_names (G_THEMED_ICON (icon), indent + 2);
g_object_unref (icon);
}
g_print ("%*scan_mount=%d\n", indent + 2, "", g_volume_can_mount (volume));
g_print ("%*scan_eject=%d\n", indent + 2, "", g_volume_can_eject (volume));
g_print ("%*sshould_automount=%d\n", indent + 2, "", g_volume_should_automount (volume));
sort_key = g_volume_get_sort_key (volume);
if (sort_key != NULL)
g_print ("%*ssort_key=%s\n", indent + 2, "", sort_key);
g_free (uuid);
}
mount = g_volume_get_mount (volume);
if (mount)
{
mounts = g_list_prepend (NULL, mount);
list_mounts (mounts, indent + 2, FALSE);
g_list_free (mounts);
g_object_unref (mount);
}
}
}
GList *vfs_backend_list_volumes (void)
{
GVolumeMonitor *pVolumeMonitor = g_volume_monitor_get ();
GList *pIconsList = NULL;
Icon *pNewIcon;
//\___________________ On chope les disques connectes (lecteur de CD/disquette/etc) et on liste leurs volumes.
GList *pDrivesList = g_volume_monitor_get_connected_drives (pVolumeMonitor);
GList *pAssociatedVolumes;
GList *dl, *av;
GDrive *pDrive;
GVolume *pVolume;
for (dl = pDrivesList; dl != NULL; dl = dl->next)
{
pDrive = dl->data;
cd_message ("drive '%s'", g_drive_get_name (pDrive));
pAssociatedVolumes = g_drive_get_volumes (pDrive);
if (pAssociatedVolumes != NULL)
{
for (av = pAssociatedVolumes; av != NULL; av = av->next)
{
pVolume = av->data;
cd_message (" + volume '%s'", g_volume_get_name (pVolume));
pNewIcon = _cd_get_icon_for_volume (pVolume, NULL);
if (pNewIcon != NULL)
pIconsList = g_list_prepend (pIconsList, pNewIcon);
//g_object_unref (pVolume);
}
g_list_free (pAssociatedVolumes);
}
else // le disque n'a aucun volume montable
{
cd_message (" le disque n'a aucun volume montable");
/*if (g_drive_is_media_removable (pDrive) && ! g_drive_is_media_check_automatic (pDrive))
{
g_drive_get_icon (pDrive);
g_drive_get_name (pDrive);
}*/
}
//g_object_unref (pDrive);
}
g_list_free (pDrivesList);
//\___________________ On chope les volumes qui ne sont pas associes a un disque.
GList *pVolumesList = g_volume_monitor_get_volumes (pVolumeMonitor);
GList *v;
for (v = pVolumesList; v != NULL; v = v->next)
{
pVolume = v->data;
cd_message ("volume '%s'", g_volume_get_name (pVolume));
pDrive = g_volume_get_drive (pVolume);
if (pDrive != NULL) // on l'a deja liste dans la 1ere boucle.
{
cd_message (" drive '%s' est deja liste", g_drive_get_name (pDrive));
//g_object_unref (pDrive);
}
else
{
cd_message (" + volume '%s'\n", g_volume_get_name (pVolume));
if (pNewIcon != NULL)
pNewIcon = _cd_get_icon_for_volume (pVolume, NULL);
pIconsList = g_list_prepend (pIconsList, pNewIcon);
}
//g_object_unref (pVolume);
}
g_list_free (pVolumesList);
//\___________________ On chope les points de montage qui n'ont pas de volumes. (montage de mtab, ftp, etc)
GList *pMountsList = g_volume_monitor_get_mounts (pVolumeMonitor);
GMount *pMount;
GList *m;
for (m = pMountsList; m != NULL; m = m->next)
{
pMount = m->data;
cd_message ("mount '%s'", g_mount_get_name (pMount));
pVolume = g_mount_get_volume (pMount);
if (pVolume != NULL) // on l'a deja liste precedemment.
{
cd_message ("volume '%s' est deja liste", g_volume_get_name (pVolume));
//g_object_unref (pVolume);
}
else
{
cd_message ("+ volume '%s'", g_volume_get_name (pVolume));
if (pNewIcon != NULL)
pNewIcon = _cd_get_icon_for_volume (NULL, pMount);
pIconsList = g_list_prepend (pIconsList, pNewIcon);
}
//g_object_unref (pMount);
}
g_list_free (pMountsList);
return pIconsList;
}
static char* g_udisks_mount_get_name (GMount* base)
{
GUDisksMount* mnt = G_UDISKS_MOUNT(base);
return mnt->vol ? g_volume_get_name(G_VOLUME(mnt->vol)) : NULL;
}
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 VALUE
rg_name(VALUE self)
{
return CSTR2RVAL_FREE(g_volume_get_name(_SELF(self)));
}
/**
* 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;
GdkPixbuf *pixbuf = NULL;
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_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_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");
}
g_object_set (source, "name", display_name, NULL);
g_free (display_name);
if (icon == NULL) {
rb_debug ("no icon set");
pixbuf = NULL;
} else if (G_IS_THEMED_ICON (icon)) {
GtkIconTheme *theme;
const char * const *names;
gint size;
int i;
theme = gtk_icon_theme_get_default ();
gtk_icon_size_lookup (RB_SOURCE_ICON_SIZE, &size, NULL);
i = 0;
names = g_themed_icon_get_names (G_THEMED_ICON (icon));
while (names[i] != NULL && pixbuf == NULL) {
rb_debug ("looking up themed icon: %s", names[i]);
pixbuf = gtk_icon_theme_load_icon (theme, names[i], size, 0, NULL);
i++;
}
} else if (G_IS_LOADABLE_ICON (icon)) {
rb_debug ("loading of GLoadableIcons is not implemented yet");
pixbuf = NULL;
}
if (pixbuf != NULL) {
g_object_set (source, "pixbuf", pixbuf, NULL);
g_object_unref (pixbuf);
}
if (mount != NULL) {
g_object_unref (mount);
}
if (volume != NULL) {
g_object_unref (volume);
}
if (icon != NULL) {
g_object_unref (icon);
}
}
