static gboolean
default_can_eject (RBDeviceSource *source)
{
gboolean result = FALSE;
GVolume *volume = NULL;
GMount *mount = 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);
}
if (volume != NULL) {
result = g_volume_can_eject (volume);
g_object_unref (volume);
if (mount != NULL) {
g_object_unref (mount);
}
} else if (mount != NULL) {
result = g_mount_can_eject (mount) || g_mount_can_unmount (mount);
if (mount != NULL) {
g_object_unref (mount);
}
}
return result;
}
static gboolean
rb_removable_media_manager_source_can_eject (RBRemovableMediaManager *mgr)
{
RBRemovableMediaManagerPrivate *priv = GET_PRIVATE (mgr);
GVolume *volume;
GMount *mount;
gboolean result;
if (RB_IS_REMOVABLE_MEDIA_SOURCE (priv->selected_source) == FALSE) {
return FALSE;
}
g_object_get (priv->selected_source, "volume", &volume, NULL);
if (volume != NULL) {
result = g_volume_can_eject (volume);
g_object_unref (volume);
return result;
}
g_object_get (priv->selected_source, "mount", &mount, NULL);
if (mount != NULL) {
result = g_mount_can_eject (mount) || g_mount_can_unmount (mount);
g_object_unref (mount);
return result;
}
return FALSE;
}
static void
rb_removable_media_manager_cmd_eject_medium (GtkAction *action, RBRemovableMediaManager *mgr)
{
RBRemovableMediaManagerPrivate *priv = GET_PRIVATE (mgr);
RBRemovableMediaSource *source = RB_REMOVABLE_MEDIA_SOURCE (priv->selected_source);
GVolume *volume;
GMount *mount;
/* try ejecting based on volume first, then based on the mount,
* and finally try unmounting.
*/
g_object_get (source, "volume", &volume, NULL);
if (volume != NULL) {
if (g_volume_can_eject (volume)) {
rb_debug ("ejecting volume");
g_volume_eject (volume,
G_MOUNT_UNMOUNT_NONE,
NULL,
(GAsyncReadyCallback) rb_removable_media_manager_eject_cb,
g_object_ref (mgr));
} else {
/* this should never happen; the eject command will be
* insensitive if the selected source cannot be ejected.
*/
rb_debug ("don't know what to do with this volume");
}
g_object_unref (volume);
return;
}
g_object_get (source, "mount", &mount, NULL);
if (mount != NULL) {
if (g_mount_can_eject (mount)) {
rb_debug ("ejecting mount");
g_mount_eject (mount,
G_MOUNT_UNMOUNT_NONE,
NULL,
(GAsyncReadyCallback) rb_removable_media_manager_eject_cb,
g_object_ref (mgr));
} else if (g_mount_can_unmount (mount)) {
rb_debug ("unmounting mount");
g_mount_unmount (mount,
G_MOUNT_UNMOUNT_NONE,
NULL,
(GAsyncReadyCallback) rb_removable_media_manager_unmount_cb,
g_object_ref (mgr));
} else {
/* this should never happen; the eject command will be
* insensitive if the selected source cannot be ejected.
*/
rb_debug ("don't know what to do with this mount");
}
g_object_unref (mount);
}
}
gboolean
brasero_gio_operation_eject_volume (GVolume *gvolume,
GCancellable *cancel,
gboolean wait,
GError **error)
{
gboolean result;
if (!g_volume_can_eject (gvolume)) {
BRASERO_MEDIA_LOG ("GVolume cannot be ejected");
return FALSE;
}
if (wait) {
gulong eject_sig;
BraseroGioOperation *op;
op = g_new0 (BraseroGioOperation, 1);
op->cancel = cancel;
eject_sig = g_signal_connect (gvolume,
"removed",
G_CALLBACK (brasero_gio_operation_removed_cb),
op);
/* Ref gvolume as it could be unreffed
* while we are in the loop */
g_object_ref (gvolume);
g_volume_eject_with_operation (gvolume,
G_MOUNT_UNMOUNT_NONE,
NULL,
cancel,
brasero_gio_operation_eject_finish,
op);
result = brasero_gio_operation_wait_for_operation_end (op, error);
g_signal_handler_disconnect (gvolume, eject_sig);
brasero_gio_operation_destroy (op);
g_object_unref (gvolume);
}
else {
g_volume_eject_with_operation (gvolume,
G_MOUNT_UNMOUNT_NONE,
NULL,
cancel,
NULL,
NULL);
result = TRUE;
}
return result;
}
void GioLister::UnmountDevice(const QString &id) {
QMutexLocker l(&mutex_);
if (!devices_.contains(id))
return;
const DeviceInfo& info = devices_[id];
if (!info.mount)
return;
if (info.volume) {
if (g_volume_can_eject(info.volume)) {
g_volume_eject_with_operation(
info.volume,
G_MOUNT_UNMOUNT_NONE,
NULL,
NULL,
(GAsyncReadyCallback) VolumeEjectFinished,
NULL);
g_object_unref(info.volume);
return;
}
}
if (g_mount_can_eject(info.mount)) {
g_mount_eject_with_operation(
info.mount,
G_MOUNT_UNMOUNT_NONE,
NULL,
NULL,
(GAsyncReadyCallback) MountEjectFinished,
NULL);
} else if (g_mount_can_unmount(info.mount)) {
g_mount_unmount_with_operation(
info.mount,
G_MOUNT_UNMOUNT_NONE,
NULL,
NULL,
(GAsyncReadyCallback) MountUnmountFinished,
NULL);
}
}
static void
xfdesktop_volume_icon_menu_eject(GtkWidget *widget,
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;
GMount *mount;
GMountOperation *operation = NULL;
volume = xfdesktop_volume_icon_peek_volume(icon);
mount = g_volume_get_mount(volume);
if(!mount)
return;
if(g_volume_can_eject(volume)) {
#ifdef HAVE_LIBNOTIFY
xfdesktop_notify_eject(volume);
#endif
operation = gtk_mount_operation_new(toplevel ? GTK_WINDOW(toplevel) : NULL);
gtk_mount_operation_set_screen(GTK_MOUNT_OPERATION(operation),
icon->priv->gscreen);
g_volume_eject_with_operation(volume,
G_MOUNT_UNMOUNT_NONE,
operation,
NULL,
xfdesktop_volume_icon_eject_finish,
g_object_ref(icon));
} else {
/* If we can't eject the volume try to unmount it */
xfdesktop_volume_icon_menu_unmount(widget, user_data);
}
g_object_unref(mount);
if(operation != NULL)
g_object_unref(operation);
}
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);
}
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);
}
}
}
GtkWidget* place_item_get_menu(PlaceItem* item)
{
GtkWidget* menu = NULL;
FmFileMenu* file_menu;
GtkUIManager* ui = gtk_ui_manager_new();
GtkActionGroup* act_grp = act_grp = gtk_action_group_new("Popup");
gtk_action_group_set_translation_domain(act_grp, GETTEXT_PACKAGE);
/* FIXME: merge with FmFileMenu when possible */
if(item->type == PLACE_PATH)
{
if(item->bm_item)
{
gtk_action_group_add_actions(act_grp, bm_menu_actions, G_N_ELEMENTS(bm_menu_actions), item);
gtk_ui_manager_add_ui_from_string(ui, bookmark_menu_xml, -1, NULL);
}
else if(fm_path_is_trash_root(item->path))
{
gtk_action_group_add_actions(act_grp, trash_menu_actions, G_N_ELEMENTS(trash_menu_actions), item);
gtk_ui_manager_add_ui_from_string(ui, trash_menu_xml, -1, NULL);
}
}
else if(item->type == PLACE_VOL)
{
GtkAction* act;
GMount* mnt;
gtk_action_group_add_actions(act_grp, vol_menu_actions, G_N_ELEMENTS(vol_menu_actions), item);
gtk_ui_manager_add_ui_from_string(ui, vol_menu_xml, -1, NULL);
mnt = g_volume_get_mount(item->vol);
if(mnt) /* mounted */
{
g_object_unref(mnt);
act = gtk_action_group_get_action(act_grp, "Mount");
gtk_action_set_sensitive(act, FALSE);
}
else /* not mounted */
{
act = gtk_action_group_get_action(act_grp, "Unmount");
gtk_action_set_sensitive(act, FALSE);
}
if(g_volume_can_eject(item->vol))
act = gtk_action_group_get_action(act_grp, "Unmount");
else
act = gtk_action_group_get_action(act_grp, "Eject");
gtk_action_set_visible(act, FALSE);
}
else
goto _out;
gtk_ui_manager_insert_action_group(ui, act_grp, 0);
menu = gtk_ui_manager_get_widget(ui, "/popup");
if(menu)
{
g_signal_connect(menu, "selection-done", G_CALLBACK(gtk_widget_destroy), NULL);
g_object_weak_ref(G_OBJECT(menu), g_object_unref, g_object_ref(ui));
}
_out:
g_object_unref(act_grp);
g_object_unref(ui);
return menu;
}
static VALUE
rg_can_eject_p(VALUE self)
{
return CBOOL2RVAL(g_volume_can_eject(_SELF(self)));
}
gboolean on_button_release(GtkWidget* widget, GdkEventButton* evt)
{
FmPlacesView* view = FM_PLACES_VIEW(widget);
if(view->clicked_row)
{
if(evt->button == 1)
{
GtkTreePath* tp;
GtkTreeViewColumn* col;
int cell_x;
if(gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(view), evt->x, evt->y, &tp, &col, &cell_x, NULL))
{
/* check if we release the button on the row we previously clicked. */
if(gtk_tree_path_compare(tp, view->clicked_row) == 0)
{
/* check if we click on the "eject" icon. */
int start, cell_w;
gtk_tree_view_column_cell_get_position(col, view->mount_indicator_renderer,
&start, &cell_w);
if(cell_x > start && cell_x < (start + cell_w)) /* click on eject icon */
{
GtkTreeIter it;
/* do eject if needed */
if(gtk_tree_model_get_iter(GTK_TREE_MODEL(model), &it, tp))
{
FmPlaceItem* item;
gtk_tree_model_get(GTK_TREE_MODEL(model), &it, FM_PLACES_MODEL_COL_INFO, &item, -1);
if(item && item->vol_mounted)
{
GtkWidget* toplevel = gtk_widget_get_toplevel(view);
/* eject the volume */
if(g_volume_can_eject(item->vol))
fm_eject_volume(toplevel, item->vol, TRUE);
else /* not ejectable, do unmount */
{
GMount* mnt = g_volume_get_mount(item->vol);
if(mnt)
{
fm_unmount_mount(toplevel, mnt, TRUE);
g_object_unref(mnt);
}
}
gtk_tree_path_free(tp);
gtk_tree_path_free(view->clicked_row);
view->clicked_row = NULL;
return TRUE;
}
}
}
/* activate the clicked row. */
gtk_tree_view_row_activated(GTK_TREE_VIEW(view), view->clicked_row, col);
}
gtk_tree_path_free(tp);
}
}
gtk_tree_path_free(view->clicked_row);
view->clicked_row = NULL;
}
return GTK_WIDGET_CLASS(fm_places_view_parent_class)->button_release_event(widget, evt);
}
static gboolean
xfdesktop_volume_icon_populate_context_menu(XfdesktopIcon *icon,
GtkWidget *menu)
{
XfdesktopVolumeIcon *volume_icon = XFDESKTOP_VOLUME_ICON(icon);
GVolume *volume = volume_icon->priv->volume;
GtkWidget *mi, *img;
GMount *mount;
const gchar *icon_name, *icon_label;
icon_name = GTK_STOCK_OPEN;
img = gtk_image_new_from_stock(GTK_STOCK_OPEN, GTK_ICON_SIZE_MENU);
gtk_widget_show(img);
mi = gtk_image_menu_item_new_with_mnemonic(_("_Open"));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(mi), img);
gtk_widget_show(mi);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);
g_signal_connect_swapped(G_OBJECT(mi), "activate",
G_CALLBACK(xfdesktop_icon_activated), icon);
mi = gtk_separator_menu_item_new();
gtk_widget_show(mi);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);
mount = g_volume_get_mount(volume);
if(mount && g_volume_can_eject(volume)) {
icon_name = "media-eject";
icon_label = _("E_ject Volume");
xfdesktop_volume_icon_add_context_menu_option(icon, icon_name, icon_label,
menu, G_CALLBACK(xfdesktop_volume_icon_menu_eject));
}
if(mount && g_mount_can_unmount(mount)) {
icon_name = NULL;
icon_label = _("_Unmount Volume");
xfdesktop_volume_icon_add_context_menu_option(icon, icon_name, icon_label,
menu, G_CALLBACK(xfdesktop_volume_icon_menu_unmount));
}
if(!mount && g_volume_can_mount(volume)) {
icon_name = NULL;
icon_label = _("_Mount Volume");
xfdesktop_volume_icon_add_context_menu_option(icon, icon_name, icon_label,
menu, G_CALLBACK(xfdesktop_volume_icon_menu_mount));
}
if(mount)
g_object_unref(mount);
mi = gtk_separator_menu_item_new();
gtk_widget_show(mi);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);
icon_name = GTK_STOCK_PROPERTIES;
icon_label = _("P_roperties...");
if(!volume_icon->priv->file_info)
xfdesktop_volume_icon_add_context_menu_option(icon, icon_name, icon_label,
menu, NULL);
else {
xfdesktop_volume_icon_add_context_menu_option(icon, icon_name, icon_label,
menu, G_CALLBACK(xfdesktop_volume_icon_menu_properties));
}
return TRUE;
}
static void
default_eject (RBDeviceSource *source)
{
GVolume *volume = NULL;
GMount *mount = 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);
}
/* try ejecting based on volume first, then based on the mount,
* and finally try unmounting.
*/
if (volume != NULL) {
if (g_volume_can_eject (volume)) {
rb_debug ("ejecting volume");
g_volume_eject_with_operation (volume,
G_MOUNT_UNMOUNT_NONE,
NULL,
NULL,
(GAsyncReadyCallback) eject_cb,
NULL);
} else {
/* this should never happen; the eject command will be
* insensitive if the selected source cannot be ejected.
*/
rb_debug ("don't know what to do with this volume");
}
} else if (mount != NULL) {
if (g_mount_can_eject (mount)) {
rb_debug ("ejecting mount");
g_mount_eject_with_operation (mount,
G_MOUNT_UNMOUNT_NONE,
NULL,
NULL,
(GAsyncReadyCallback) eject_cb,
NULL);
} else if (g_mount_can_unmount (mount)) {
rb_debug ("unmounting mount");
g_mount_unmount_with_operation (mount,
G_MOUNT_UNMOUNT_NONE,
NULL,
NULL,
(GAsyncReadyCallback) unmount_cb,
NULL);
} else {
/* this should never happen; the eject command will be
* insensitive if the selected source cannot be ejected.
*/
rb_debug ("don't know what to do with this mount");
}
}
if (volume != NULL) {
g_object_unref (volume);
}
if (mount != NULL) {
g_object_unref (mount);
}
}
static void
_tile_eject_cb (MpdStorageDeviceTile *tile,
MpdDevicesTile *self)
{
MpdDevicesTilePrivate *priv = GET_PRIVATE (self);
char const *uri;
GList *mounts;
GList *iter;
uri = mpd_storage_device_tile_get_mount_point (tile);
mounts = g_volume_monitor_get_mounts (priv->monitor);
iter = g_list_find_custom (mounts, uri, (GCompareFunc) _find_mount_cb);
if (iter)
{
GMount *mount = G_MOUNT (iter->data);
GDrive *drive;
GVolume *vol;
gboolean ejected = TRUE;
drive = g_mount_get_drive (mount);
vol = g_mount_get_volume (mount);
if (drive && g_drive_can_eject (drive)) {
g_debug ("%s() ejecting drive %s", __FUNCTION__, uri);
g_drive_eject_with_operation (drive,
G_MOUNT_UNMOUNT_NONE, NULL, NULL,
(GAsyncReadyCallback)_drive_eject_cb,
tile);
} else if (vol && g_volume_can_eject (vol)) {
g_debug ("%s() ejecting volume %s", __FUNCTION__, uri);
g_volume_eject_with_operation (vol,
G_MOUNT_UNMOUNT_NONE, NULL, NULL,
(GAsyncReadyCallback)_vol_eject_cb,
tile);
} else if (g_mount_can_eject (mount)) {
g_debug ("%s() ejecting mount %s", __FUNCTION__, uri);
g_mount_eject_with_operation (mount,
G_MOUNT_UNMOUNT_NONE, NULL, NULL,
(GAsyncReadyCallback) _mount_eject_cb,
tile);
} else if (g_mount_can_unmount (mount)) {
g_debug ("%s() unmounting mount %s", __FUNCTION__, uri);
g_mount_unmount_with_operation (mount,
G_MOUNT_UNMOUNT_NONE, NULL, NULL,
(GAsyncReadyCallback) _mount_unmount_cb,
tile);
} else {
ejected = FALSE;
g_warning ("Eject or unmount not possible");
}
mx_widget_set_disabled (MX_WIDGET (tile), ejected);
/* TODO: inform user of ejection with text inside the tile:
* For that (and other reasons) this code really should be inside
* MpdStorageDeviceTile */
/* TODO: we want to start a 2s timeout here, and if not done sync'ing when
* expired show the message "Ejecting ..." */
if (drive) {
g_object_unref (drive);
}
if (vol) {
g_object_unref (vol);
}
}
g_list_foreach (mounts, (GFunc) g_object_unref, NULL);
g_list_free (mounts);
}