int main(int argc, char** argv) {
GVolumeMonitor* vm;
//State state = {NULL};
GList* volumes;
GFile* usb_root = NULL;
vm = g_volume_monitor_get();
volumes = g_volume_monitor_get_volumes(vm);
while (volumes && (usb_root == NULL)) {
usb_root = get_volume_root(volumes->data);
if (usb_root != NULL) {
break;
}
volumes = volumes->next;
}
g_list_free_full(volumes, g_object_unref);
gtk_init(&argc, &argv);
if (usb_root == NULL) {
GtkWidget* window = gtk_window_new(GTK_WINDOW_POPUP);
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
GtkWidget* label = gtk_label_new("Bitte USB-Stick einstecken!");
gtk_container_add(GTK_CONTAINER(window), label);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER_ALWAYS);
gtk_widget_show_all(window);
g_signal_connect(vm, "mount-added", G_CALLBACK(on_mount_added), window);
//g_signal_connect(vm, "volume-added", G_CALLBACK(on_volume_added), window);
} else {
g_signal_connect(vm, "mount-removed", G_CALLBACK(on_mount_removed), NULL);
start_gui(usb_root);
}
gtk_main();
return 0;
}
static gboolean fm_volume_manager_delay_init(gpointer user_data)
{
GList* vols, *l;
vol_mon = g_volume_monitor_get();
if(G_UNLIKELY(!vol_mon))
goto _end;
g_signal_connect(vol_mon, "volume-added", G_CALLBACK(on_vol_added), NULL);
#ifdef G_ENABLE_DEBUG
g_signal_connect(vol_mon, "volume-removed", G_CALLBACK(on_vol_removed), NULL);
g_signal_connect(vol_mon, "volume-changed", G_CALLBACK(on_vol_changed), NULL);
#endif
if(app_config->mount_on_startup)
{
/* try to automount all volumes */
vols = g_volume_monitor_get_volumes(vol_mon);
for(l=vols;l;l=l->next)
{
GVolume* vol = G_VOLUME(l->data);
if(g_volume_should_automount(vol))
automount_volume(vol, TRUE);
g_object_unref(vol);
}
g_list_free(vols);
}
_end:
on_idle_handler = 0;
return FALSE;
}
GVolume *
tvm_g_volume_monitor_get_volume_for_kind (GVolumeMonitor *monitor,
const gchar *kind,
const gchar *identifier)
{
GVolume *volume = NULL;
GList *volumes;
GList *lp;
gchar *value;
g_return_val_if_fail (G_IS_VOLUME_MONITOR (monitor), NULL);
g_return_val_if_fail (kind != NULL && *kind != '\0', NULL);
g_return_val_if_fail (identifier != NULL && *identifier != '\0', NULL);
volumes = g_volume_monitor_get_volumes (monitor);
for (lp = volumes; volume == NULL && lp != NULL; lp = lp->next)
{
value = g_volume_get_identifier (lp->data, kind);
if (value != NULL)
{
if (g_strcmp0 (value, identifier) == 0)
volume = g_object_ref (lp->data);
g_free (value);
}
g_object_unref (lp->data);
}
g_list_free (volumes);
return volume;
}
static GList *
get_volumes (GVolumeMonitor *volume_monitor)
{
GUnionVolumeMonitor *monitor;
GVolumeMonitor *child_monitor;
GList *res;
GList *l;
monitor = G_UNION_VOLUME_MONITOR (volume_monitor);
res = NULL;
g_rec_mutex_lock (&the_volume_monitor_mutex);
for (l = monitor->monitors; l != NULL; l = l->next)
{
child_monitor = l->data;
res = g_list_concat (res, g_volume_monitor_get_volumes (child_monitor));
}
g_rec_mutex_unlock (&the_volume_monitor_mutex);
return res;
}
void GioLister::Init() {
monitor_.reset_without_add(g_volume_monitor_get());
// Get existing volumes
GList* const volumes = g_volume_monitor_get_volumes(monitor_);
for (GList* p=volumes; p; p=p->next) {
GVolume* volume = static_cast<GVolume*>(p->data);
VolumeAdded(volume);
g_object_unref(volume);
}
g_list_free(volumes);
// Get existing mounts
GList* const mounts = g_volume_monitor_get_mounts(monitor_);
for (GList* p=mounts; p; p=p->next) {
GMount* mount = static_cast<GMount*>(p->data);
MountAdded(mount);
g_object_unref(mount);
}
g_list_free(mounts);
// Connect signals from the monitor
CHECKED_GCONNECT(monitor_, "volume-added", &VolumeAddedCallback, this);
CHECKED_GCONNECT(monitor_, "volume-removed", &VolumeRemovedCallback, this);
CHECKED_GCONNECT(monitor_, "mount-added", &MountAddedCallback, this);
CHECKED_GCONNECT(monitor_, "mount-changed", &MountChangedCallback, this);
CHECKED_GCONNECT(monitor_, "mount-removed", &MountRemovedCallback, this);
}
static void
list_monitor_items(void)
{
GVolumeMonitor *volume_monitor;
GList *drives, *volumes, *mounts;
volume_monitor = g_volume_monitor_get();
/* populate gvfs network mounts */
iterate_gmain();
drives = g_volume_monitor_get_connected_drives (volume_monitor);
list_drives (drives, 0);
g_list_foreach (drives, (GFunc)g_object_unref, NULL);
g_list_free (drives);
volumes = g_volume_monitor_get_volumes (volume_monitor);
list_volumes (volumes, 0, TRUE);
g_list_foreach (volumes, (GFunc)g_object_unref, NULL);
g_list_free (volumes);
mounts = g_volume_monitor_get_mounts (volume_monitor);
list_mounts (mounts, 0, TRUE);
g_list_foreach (mounts, (GFunc)g_object_unref, NULL);
g_list_free (mounts);
g_object_unref (volume_monitor);
}
void init_ASMount(ASFlagType flags, const char *cmd)
{
memset( &AppState, 0x00, sizeof(AppState));
AppState.flags = flags ;
AppState.tileWidth = DEFAULT_TILE_WIDTH;
AppState.tileHeight = DEFAULT_TILE_HEIGHT;
createMainWindow();
reloadButtons();
AppState.volumes = create_asbidirlist (ASVolume_destroy);
g_type_init();
GVolumeMonitor * monitor = g_volume_monitor_get();
g_signal_connect_object (monitor, "mount-added", G_CALLBACK (mount_added), NULL, 0);
g_signal_connect_object (monitor, "mount-changed", G_CALLBACK (mount_changed), NULL, 0);
g_signal_connect_object (monitor, "mount-removed", G_CALLBACK (mount_removed), NULL, 0);
g_signal_connect_object (monitor, "volume-added", G_CALLBACK (volume_added), NULL, 0);
g_signal_connect_object (monitor, "volume-changed", G_CALLBACK (volume_changed), NULL, 0);
g_signal_connect_object (monitor, "volume-removed", G_CALLBACK (volume_removed), NULL, 0);
GList *tmp;
GList *list = g_volume_monitor_get_volumes(G_VOLUME_MONITOR(monitor));
show_activity ("Adding volumes...");
for (tmp = list; tmp != NULL; tmp = tmp->next) {
ASVolume *v = ASVolume_newGVolume (tmp->data);
if (v)
append_bidirelem (AppState.volumes, v);
else
g_object_unref (tmp->data);
}
g_list_free (list);
#if 1
show_activity ("Adding mounts...");
list = g_volume_monitor_get_mounts(G_VOLUME_MONITOR(monitor));
for (tmp = list; tmp != NULL; tmp = tmp->next) {
ASVolume *v = ASVolume_newGMount (tmp->data);
if (v)
append_bidirelem (AppState.volumes, v);
else
g_object_unref (tmp->data);
}
g_list_free (list);
#endif
AppState.volumeMonitor = monitor;
redecorateVolumes ();
}
static GList* g_udisks_drive_get_volumes (GDrive* base)
{
/* FIXME: is it a better idea to save all volumes in GUDisksDrive instead? */
GUDisksDrive* drv = G_UDISKS_DRIVE(base);
GList* vols = g_volume_monitor_get_volumes(G_VOLUME_MONITOR(drv->mon));
GList* l;
GList* ret = NULL;
for(l = vols;l;l=l->next)
{
GUDisksVolume* vol = G_UDISKS_VOLUME(l->data);
if(vol->drive == drv)
ret = g_list_prepend(ret, vol);
else
g_object_unref(vol);
}
g_list_free(vols);
return ret;
}
static void
mount_with_device_file (const char *device_file)
{
GVolumeMonitor *volume_monitor;
GList *volumes;
GList *l;
volume_monitor = g_volume_monitor_get();
volumes = g_volume_monitor_get_volumes (volume_monitor);
for (l = volumes; l != NULL; l = l->next)
{
GVolume *volume = G_VOLUME (l->data);
gchar *id;
id = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);
if (g_strcmp0 (id, device_file) == 0)
{
GMountOperation *op;
op = new_mount_op ();
g_volume_mount (volume,
G_MOUNT_MOUNT_NONE,
op,
NULL,
mount_with_device_file_cb,
id);
outstanding_mounts++;
}
else
g_free (id);
}
g_list_free_full (volumes, g_object_unref);
if (outstanding_mounts == 0)
{
print_error ("%s: %s", device_file, _("No volume for device file"));
success = FALSE;
}
g_object_unref (volume_monitor);
}
static void
mount_with_device_file (const char *device_file)
{
GVolumeMonitor *volume_monitor;
GList *volumes;
GList *l;
volume_monitor = g_volume_monitor_get();
volumes = g_volume_monitor_get_volumes (volume_monitor);
for (l = volumes; l != NULL; l = l->next)
{
GVolume *volume = G_VOLUME (l->data);
if (g_strcmp0 (g_volume_get_identifier (volume,
G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE), device_file) == 0)
{
GMountOperation *op;
op = new_mount_op ();
g_volume_mount (volume,
G_MOUNT_MOUNT_NONE,
op,
NULL,
mount_with_device_file_cb,
op);
outstanding_mounts++;
}
}
g_list_foreach (volumes, (GFunc) g_object_unref, NULL);
g_list_free (volumes);
if (outstanding_mounts == 0)
{
g_print (_("No volume for device file %s\n"), device_file);
return;
}
g_object_unref (volume_monitor);
}
static void
test_volumes (void)
{
GList *volumes, *l;
volumes = g_volume_monitor_get_volumes (monitor);
for (l = volumes; l; l = l->next)
{
GVolume *volume = l->data;
GDrive *drive;
drive = g_volume_get_drive (volume);
do_volume_tests (drive, volume);
g_object_unref (drive);
}
g_list_foreach (volumes, (GFunc)g_object_unref, NULL);
g_list_free (volumes);
}
static void
test_volumes (void)
{
GList *volumes, *l;
volumes = g_volume_monitor_get_volumes (monitor);
for (l = volumes; l; l = l->next)
{
GVolume *volume = l->data;
GDrive *drive;
drive = g_volume_get_drive (volume);
do_volume_tests (drive, volume);
if (drive != NULL)
g_object_unref (drive);
}
g_list_free_full (volumes, g_object_unref);
}
static GMount *
totem_get_mount_for_dvd (const char *uri)
{
GMount *mount;
char *path;
mount = NULL;
path = g_strdup (uri + strlen ("dvd://"));
/* If it's a device, we need to find the volume that corresponds to it,
* and then the mount for the volume */
if (g_str_has_prefix (path, "/dev/")) {
GVolumeMonitor *volume_monitor;
GList *volumes, *l;
volume_monitor = g_volume_monitor_get ();
volumes = g_volume_monitor_get_volumes (volume_monitor);
g_object_unref (volume_monitor);
for (l = volumes; l != NULL; l = l->next) {
char *id;
id = g_volume_get_identifier (l->data, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);
if (g_strcmp0 (id, path) == 0) {
g_free (id);
mount = g_volume_get_mount (l->data);
break;
}
g_free (id);
}
g_list_foreach (volumes, (GFunc) g_object_unref, NULL);
g_list_free (volumes);
} else {
mount = totem_get_mount_for_uri (path);
g_free (path);
}
/* We have a path to the file itself */
return mount;
}
/* this is loosely based on update_places() from caja-places-sidebar.c */
static void
panel_place_menu_item_append_local_gio (PanelPlaceMenuItem *place_item,
GtkWidget *menu)
{
GList *l;
GList *ll;
GList *drives;
GDrive *drive;
GList *volumes;
GVolume *volume;
GList *mounts;
GMount *mount;
GSList *items;
GSList *sl;
PanelGioItem *item;
GtkWidget *add_menu;
items = NULL;
/* first go through all connected drives */
drives = g_volume_monitor_get_connected_drives (place_item->priv->volume_monitor);
for (l = drives; l != NULL; l = l->next) {
drive = l->data;
volumes = g_drive_get_volumes (drive);
if (volumes != NULL) {
for (ll = volumes; ll != NULL; ll = ll->next) {
volume = ll->data;
mount = g_volume_get_mount (volume);
item = g_slice_new (PanelGioItem);
if (mount != NULL) {
item->type = PANEL_GIO_MOUNT;
item->u.mount = mount;
} else {
/* Do show the unmounted volumes; this
* is so the user can mount it (in case
* automounting is off).
*
* Also, even if automounting is
* enabled, this gives a visual cue
* that the user should remember to
* yank out the media if he just
* unmounted it.
*/
item->type = PANEL_GIO_VOLUME;
item->u.volume = g_object_ref (volume);
}
items = g_slist_prepend (items, item);
g_object_unref (volume);
}
g_list_free (volumes);
} else {
if (g_drive_is_media_removable (drive) &&
!g_drive_is_media_check_automatic (drive)) {
/* If the drive has no mountable volumes and we
* cannot detect media change.. we display the
* drive so the user can manually poll the
* drive by clicking on it..."
*
* This is mainly for drives like floppies
* where media detection doesn't work.. but
* it's also for human beings who like to turn
* off media detection in the OS to save
* battery juice.
*/
item = g_slice_new (PanelGioItem);
item->type = PANEL_GIO_DRIVE;
item->u.drive = g_object_ref (drive);
items = g_slist_prepend (items, item);
}
}
g_object_unref (drive);
}
g_list_free (drives);
/* add all volumes that is not associated with a drive */
volumes = g_volume_monitor_get_volumes (place_item->priv->volume_monitor);
for (l = volumes; l != NULL; l = l->next) {
volume = l->data;
drive = g_volume_get_drive (volume);
if (drive != NULL) {
g_object_unref (volume);
g_object_unref (drive);
continue;
}
mount = g_volume_get_mount (volume);
item = g_slice_new (PanelGioItem);
if (mount != NULL) {
item->type = PANEL_GIO_MOUNT;
item->u.mount = mount;
} else {
/* see comment above in why we add an icon for an
* unmounted mountable volume */
item->type = PANEL_GIO_VOLUME;
item->u.volume = g_object_ref (volume);
}
items = g_slist_prepend (items, item);
g_object_unref (volume);
}
g_list_free (volumes);
/* add mounts that has no volume (/etc/mtab mounts, ftp, sftp,...) */
mounts = g_volume_monitor_get_mounts (place_item->priv->volume_monitor);
for (l = mounts; l != NULL; l = l->next) {
GFile *root;
mount = l->data;
if (g_mount_is_shadowed (mount)) {
g_object_unref (mount);
continue;
}
volume = g_mount_get_volume (mount);
if (volume != NULL) {
g_object_unref (volume);
g_object_unref (mount);
continue;
}
root = g_mount_get_root (mount);
if (!g_file_is_native (root)) {
g_object_unref (root);
g_object_unref (mount);
continue;
}
g_object_unref (root);
item = g_slice_new (PanelGioItem);
item->type = PANEL_GIO_MOUNT;
item->u.mount = mount;
items = g_slist_prepend (items, item);
}
g_list_free (mounts);
/* now that we have everything, add the items inline or in a submenu */
items = g_slist_reverse (items);
if (g_slist_length (items) <= MAX_ITEMS_OR_SUBMENU) {
add_menu = menu;
} else {
GtkWidget *item;
item = gtk_image_menu_item_new ();
setup_menu_item_with_icon (item, panel_menu_icon_get_size (),
PANEL_ICON_REMOVABLE_MEDIA,
NULL, NULL,
_("Removable Media"));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
add_menu = create_empty_menu ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), add_menu);
}
for (sl = items; sl; sl = sl->next) {
item = sl->data;
switch (item->type) {
case PANEL_GIO_DRIVE:
panel_menu_item_append_drive (add_menu, item->u.drive);
g_object_unref (item->u.drive);
break;
case PANEL_GIO_VOLUME:
panel_menu_item_append_volume (add_menu, item->u.volume);
g_object_unref (item->u.volume);
break;
case PANEL_GIO_MOUNT:
panel_menu_item_append_mount (add_menu, item->u.mount);
g_object_unref (item->u.mount);
break;
default:
g_assert_not_reached ();
}
g_slice_free (PanelGioItem, item);
}
g_slist_free (items);
}
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 void init_model()
{
if(G_UNLIKELY(!model))
{
GtkTreeIter it;
PlaceItem* item;
GList *vols, *l;
GIcon* gicon;
FmIcon* icon;
GFile* gf;
GdkPixbuf* pix;
theme_change_handler = g_signal_connect(gtk_icon_theme_get_default(), "changed",
G_CALLBACK(update_icons), NULL);
use_trash_change_handler = g_signal_connect(fm_config, "changed::use_trash",
G_CALLBACK(on_use_trash_changed), NULL);
pane_icon_size_change_handler = g_signal_connect(fm_config, "changed::pane_icon_size",
G_CALLBACK(on_pane_icon_size_changed), NULL);
model = gtk_list_store_new(N_COLS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_POINTER);
g_object_weak_ref(G_OBJECT(model), on_model_destroy, NULL);
item = g_slice_new0(PlaceItem);
item->type = PLACE_PATH;
item->path = fm_path_ref(fm_path_get_home());
item->icon = fm_icon_from_name("user-home");
gtk_list_store_append(model, &it);
pix = fm_icon_get_pixbuf(item->icon, fm_config->pane_icon_size);
gtk_list_store_set(model, &it, COL_ICON, pix, COL_LABEL, item->path->name, COL_INFO, item, -1);
g_object_unref(pix);
/* Only show desktop in side pane when the user has a desktop dir. */
if(g_file_test(g_get_user_special_dir(G_USER_DIRECTORY_DESKTOP), G_FILE_TEST_IS_DIR))
{
item = g_slice_new0(PlaceItem);
item->type = PLACE_PATH;
item->path = fm_path_ref(fm_path_get_desktop());
item->icon = fm_icon_from_name("user-desktop");
gtk_list_store_append(model, &it);
pix = fm_icon_get_pixbuf(item->icon, fm_config->pane_icon_size);
gtk_list_store_set(model, &it, COL_ICON, pix, COL_LABEL, _("Desktop"), COL_INFO, item, -1);
g_object_unref(pix);
}
if(fm_config->use_trash)
create_trash();
item = g_slice_new0(PlaceItem);
item->type = PLACE_PATH;
item->path = fm_path_ref(fm_path_get_apps_menu());
item->icon = fm_icon_from_name("system-software-install");
gtk_list_store_append(model, &it);
pix = fm_icon_get_pixbuf(item->icon, fm_config->pane_icon_size);
gtk_list_store_set(model, &it, COL_ICON, pix, COL_LABEL, _("Applications"), COL_INFO, item, -1);
g_object_unref(pix);
/* volumes */
vol_mon = g_volume_monitor_get();
g_signal_connect(vol_mon, "volume-added", G_CALLBACK(on_vol_added), NULL);
g_signal_connect(vol_mon, "volume-removed", G_CALLBACK(on_vol_removed), NULL);
g_signal_connect(vol_mon, "volume-changed", G_CALLBACK(on_vol_changed), NULL);
/* separator */
gtk_list_store_append(model, &sep_it);
vols = g_volume_monitor_get_volumes(vol_mon);
for(l=vols;l;l=l->next)
{
GVolume* vol = G_VOLUME(l->data);
add_vol(vol);
g_object_unref(vol);
}
g_list_free(vols);
bookmarks = fm_bookmarks_get(); /* bookmarks */
g_signal_connect(bookmarks, "changed", G_CALLBACK(on_bookmarks_changed), NULL);
add_bookmarks();
}
else
g_object_ref(model);
}
int
main (int argc, char *argv[])
{
int ret;
GError *error;
MduPool *pool;
MduDevice *device;
MduDevice *device_to_unmount;
MduDevice *device_to_mount;
MduPresentable *volume;
gchar *volume_name;
gchar *confirmation_secondary;
GtkWidget *dialog;
gint response;
gchar *fs_type;
gchar *fs_label;
gboolean encrypt;
gchar *passphrase;
gboolean save_passphrase_in_keyring;
gboolean save_passphrase_in_keyring_session;
GMainLoop *loop;
GVolumeMonitor *gvolume_monitor;
GList *l;
GList *gvolumes;
GVolume *gvolume;
GMount *gmount;
gboolean take_ownership;
FormatData *format_data;
MduPresentable *toplevel;
gchar *drive_name;
gchar *format_desc;
gchar *formatting_desc;
gchar *size_str;
gint grace_timeout_id;
ret = 1;
pool = NULL;
device = NULL;
device_to_unmount = NULL;
device_to_mount = NULL;
volume = NULL;
volume_name = NULL;
confirmation_secondary = NULL;
dialog = NULL;
fs_type = NULL;
fs_label = NULL;
passphrase = NULL;
loop = NULL;
volume = NULL;
gmount = NULL;
gvolume_monitor = NULL;
gvolumes = NULL;
gvolume = NULL;
gmount = NULL;
format_data = NULL;
toplevel = NULL;
drive_name = NULL;
format_desc = NULL;
formatting_desc = NULL;
size_str = NULL;
#if !GLIB_CHECK_VERSION (2, 32, 0)
g_thread_init (NULL);
#endif
/* Initialize gettext support */
bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
/* Initialize gtk */
error = NULL;
if (! gtk_init_with_args (&argc, &argv, NULL, entries, GETTEXT_PACKAGE, &error)) {
g_printerr ("Could not parse arguments: %s\n", error->message);
g_error_free (error);
goto out;
}
loop = g_main_loop_new (NULL, FALSE);
g_set_prgname ("mdu-format-tool");
g_set_application_name (_("Mate Disk Utility formatting tool"));
if (device_file == NULL) {
g_printerr ("Incorrect usage. Try --help.\n");
goto out;
}
pool = mdu_pool_new ();
if (pool == NULL) {
g_warning ("Unable to get device pool");
goto out;
}
device = mdu_pool_get_by_device_file (pool, device_file);
if (device == NULL) {
g_printerr ("No device for %s\n", device_file);
goto out;
}
/* if the user specified a luks device, find the slave backing device */
if (mdu_device_is_luks_cleartext (device)) {
const gchar *slave;
slave = mdu_device_luks_cleartext_get_slave (device);
g_object_ref (device);
device = mdu_pool_get_by_object_path (pool, slave);
/* don't support LUKS in LUKS... */
g_assert (!mdu_device_is_luks_cleartext (device));
}
volume = mdu_pool_get_volume_by_device (pool, device);
if (volume == NULL) {
g_printerr ("%s is not a volume\n", device_file);
goto out;
}
volume_name = mdu_presentable_get_name (volume);
toplevel = mdu_presentable_get_toplevel (MDU_PRESENTABLE (volume));
if (toplevel != NULL && MDU_IS_DRIVE (toplevel)) {
drive_name = mdu_presentable_get_name (toplevel);
}
size_str = mdu_util_get_size_for_display (mdu_device_get_size (device),
FALSE,
FALSE);
if (drive_name != NULL) {
if (mdu_device_is_partition (device)) {
/* Translators: First argument is the partition number, second argument is the drive name,
* third argument is the size (e.g. 10 GB)
*/
format_desc = g_strdup_printf (_("Format partition %d of %s (%s)"),
mdu_device_partition_get_number (device),
drive_name,
size_str);
/* Translators: First argument is the partition number, second argument is the drive name,
* third argument is the size (e.g. 10 GB)
*/
formatting_desc = g_strdup_printf (_("Formatting partition %d of %s (%s)"),
mdu_device_partition_get_number (device),
drive_name,
size_str);
} else {
/* Translators: First argument is the drive name, second argument is the size (e.g. 10 GB) */
format_desc = g_strdup_printf (_("Format %s (%s)"),
drive_name,
size_str);
/* Translators: First argument is the drive name, second argument is the size (e.g. 10 GB) */
formatting_desc = g_strdup_printf (_("Formatting %s (%s)"),
drive_name,
size_str);
}
} else {
/* Translators: First argument is the size (e.g. 10 GB), second is the device (e.g. /dev/md0) */
format_desc = g_strdup_printf (_("Format %s Volume (%s)"),
size_str,
mdu_device_get_device_file (device));
/* Translators: First argument is the size (e.g. 10 GB), second is the device (e.g. /dev/md0) */
formatting_desc = g_strdup_printf (_("Formatting %s Volume (%s)"),
size_str,
mdu_device_get_device_file (device));
}
dialog = mdu_format_dialog_new (NULL, /* no parent window */
volume,
MDU_FORMAT_DIALOG_FLAGS_SIMPLE |
MDU_FORMAT_DIALOG_FLAGS_DISK_UTILITY_BUTTON);
gtk_window_set_title (GTK_WINDOW (dialog), format_desc);
gtk_window_set_icon_name (GTK_WINDOW (dialog), "caja-mdu");
gtk_widget_show_all (dialog);
response = gtk_dialog_run (GTK_DIALOG (dialog));
switch (response) {
case GTK_RESPONSE_OK:
break;
case GTK_RESPONSE_ACCEPT:
gtk_widget_destroy (dialog);
dialog = NULL;
launch_mate_disk (device_file);
goto out;
default: /* explicit fallthrough */
case GTK_RESPONSE_CANCEL:
goto out;
}
fs_type = mdu_format_dialog_get_fs_type (MDU_FORMAT_DIALOG (dialog));
fs_label = mdu_format_dialog_get_fs_label (MDU_FORMAT_DIALOG (dialog));
encrypt = mdu_format_dialog_get_encrypt (MDU_FORMAT_DIALOG (dialog));
gtk_widget_destroy (dialog);
dialog = NULL;
/* Ask for passphrase if needed */
passphrase = NULL;
save_passphrase_in_keyring = FALSE;
save_passphrase_in_keyring_session = FALSE;
if (encrypt) {
passphrase = mdu_util_dialog_ask_for_new_secret (NULL,
&save_passphrase_in_keyring,
&save_passphrase_in_keyring_session);
if (passphrase == NULL)
goto out;
}
take_ownership = (g_strcmp0 (fs_type, "vfat") != 0);
format_data = g_new0 (FormatData, 1);
format_data->loop = loop;
format_data->error = NULL;
dialog = mdu_format_progress_dialog_new (NULL,
device,
_("Preparing..."));
gtk_window_set_title (GTK_WINDOW (dialog), formatting_desc);
gtk_widget_show_all (dialog);
g_signal_connect (dialog, "response", G_CALLBACK (on_progress_dialog_response), format_data);
/* first a small 2.5 sec window to allow the user to cancel before initiating */
grace_timeout_id = g_timeout_add (2500, on_grace_timeout, format_data);
g_main_loop_run (loop);
g_source_remove (grace_timeout_id);
if (format_data->error != NULL &&
format_data->error->domain == G_IO_ERROR &&
format_data->error->code == G_IO_ERROR_CANCELLED) {
/* cancelled already, we are done */
goto out;
}
/* then unmount the mount if needed; we use GIO for this to handle tearing
* down LUKS; first determine the device to unmount
*/
if (mdu_device_is_luks (device)) {
const gchar *holder;
holder = mdu_device_luks_get_holder (device);
device_to_unmount = mdu_pool_get_by_object_path (pool, holder);
} else {
device_to_unmount = g_object_ref (device);
}
g_assert (device_to_unmount != NULL);
gvolume_monitor = g_volume_monitor_get ();
gvolumes = g_volume_monitor_get_volumes (gvolume_monitor);
for (l = gvolumes; l != NULL; l = l->next) {
GVolume *v = G_VOLUME (l->data);
if (g_strcmp0 (g_volume_get_identifier (v, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE),
mdu_device_get_device_file (device_to_unmount)) == 0) {
gvolume = g_object_ref (v);
break;
}
}
if (gvolume != NULL) {
gmount = g_volume_get_mount (gvolume);
if (gmount != NULL) {
GMountOperation *mount_op;
mdu_format_progress_dialog_set_text (MDU_FORMAT_PROGRESS_DIALOG (dialog),
_("Unmounting..."));
mount_op = gtk_mount_operation_new (GTK_WINDOW (dialog));
g_mount_unmount_with_operation (gmount,
G_MOUNT_UNMOUNT_NONE,
mount_op,
NULL,
unmount_cb,
format_data);
g_object_unref (mount_op);
g_main_loop_run (format_data->loop);
if (format_data->error != NULL) {
if (!(format_data->error->domain == G_IO_ERROR &&
format_data->error->code == G_IO_ERROR_FAILED_HANDLED)) {
gchar *primary;
primary = g_strdup_printf (_("Unable to format '%s'"), volume_name);
show_error_dialog (NULL,
primary,
format_data->error->message);
g_free (primary);
}
g_error_free (format_data->error);
goto out;
}
}
}
/* and now, kick off the operation */
mdu_format_progress_dialog_set_text (MDU_FORMAT_PROGRESS_DIALOG (dialog),
_("Formatting..."));
mdu_device_op_filesystem_create (device,
fs_type,
fs_label,
passphrase,
take_ownership,
fs_create_cb,
format_data);
again:
g_main_loop_run (loop);
if (format_data->error != NULL) {
gtk_widget_destroy (dialog);
dialog = NULL;
if (format_data->error->domain == G_IO_ERROR &&
format_data->error->code == G_IO_ERROR_CANCELLED) {
mdu_format_progress_dialog_set_text (MDU_FORMAT_PROGRESS_DIALOG (dialog),
_("Cancelling..."));
/* cancel the job; no callback since op_filesystem_create will return an error */
mdu_device_op_cancel_job (device,
NULL,
NULL);
goto again;
} else {
show_error_dialog (NULL,
_("Error formatting volume"),
format_data->error->message);
g_error_free (format_data->error);
}
goto out;
}
/* ugh, DeviceKit-disks bug - spin around in the mainloop for some time to ensure we
* have gotten all changes
*/
mdu_format_progress_dialog_set_text (MDU_FORMAT_PROGRESS_DIALOG (dialog),
_("Mounting volume..."));
g_timeout_add (1500, on_hack_timeout, loop);
g_main_loop_run (loop);
/* OK, peachy, now mount the volume and open a window */
if (passphrase != NULL) {
const gchar *cleartext_objpath;
g_assert (mdu_device_is_luks (device));
cleartext_objpath = mdu_device_luks_get_holder (device);
device_to_mount = mdu_pool_get_by_object_path (pool, cleartext_objpath);
} else {
device_to_mount = g_object_ref (device);
}
mdu_device_op_filesystem_mount (device_to_mount,
NULL,
fs_mount_cb,
format_data);
g_main_loop_run (loop);
gtk_widget_destroy (dialog);
dialog = NULL;
if (format_data->error != NULL) {
show_error_dialog (NULL,
_("Error mounting device"),
format_data->error->message);
g_error_free (format_data->error);
goto out;
}
/* open file manager */
launch_file_manager (format_data->mount_point);
g_free (format_data->mount_point);
/* save passphrase in keyring if requested */
if (passphrase != NULL && (save_passphrase_in_keyring || save_passphrase_in_keyring_session)) {
if (!mdu_util_save_secret (device,
passphrase,
save_passphrase_in_keyring_session)) {
show_error_dialog (NULL,
_("Error storing passphrase in keyring"),
"");
goto out;
}
}
ret = 0;
out:
if (toplevel != NULL)
g_object_unref (toplevel);
g_free (drive_name);
g_free (size_str);
g_free (format_desc);
g_free (formatting_desc);
if (gmount != NULL)
g_object_unref (gmount);
if (gvolume != NULL)
g_object_unref (gvolume);
g_list_foreach (gvolumes, (GFunc) g_object_unref, NULL);
if (gvolume_monitor != NULL)
g_object_unref (gvolume_monitor);
g_free (confirmation_secondary);
g_free (volume_name);
g_free (passphrase);
g_free (fs_type);
g_free (fs_label);
g_free (device_file);
if (loop != NULL)
g_main_loop_unref (loop);
if (dialog != NULL)
gtk_widget_destroy (dialog);
if (volume != NULL)
g_object_unref (volume);
if (device != NULL)
g_object_unref (device);
if (device_to_unmount != NULL)
g_object_unref (device_to_unmount);
if (device_to_mount != NULL)
g_object_unref (device_to_mount);
if (pool != NULL)
g_object_unref (pool);
if (format_data != NULL)
g_free (format_data);
return ret;
}
static void
grl_optical_media_source_browse (GrlSource *source,
GrlSourceBrowseSpec *bs)
{
GList *drives;
GList *volumes;
GList *l;
GrlOpticalMediaSourcePrivate *priv = GRL_OPTICAL_MEDIA_SOURCE (source)->priv;
BrowseData *data;
GList *media_list;
GRL_DEBUG ("%s", __FUNCTION__);
media_list = NULL;
/* Get the drives */
drives = g_volume_monitor_get_connected_drives (priv->monitor);
for (l = drives; l != NULL; l = l->next) {
GDrive *drive = l->data;
media_list = add_drive (media_list, drive, GRL_OPTICAL_MEDIA_SOURCE (source));
g_object_unref (drive);
}
g_list_free (drives);
/* Look for mounted ISO images */
volumes = g_volume_monitor_get_volumes (priv->monitor);
for (l = volumes; l != NULL; l = l->next) {
GVolume *volume = l->data;
char *path;
path = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);
if (path != NULL && g_str_has_prefix (path, "/dev/loop"))
media_list = add_volume (media_list, volume, NULL, GRL_OPTICAL_MEDIA_SOURCE (source));
g_free (path);
g_object_unref (volume);
}
g_list_free (volumes);
/* Got nothing? */
if (media_list == NULL) {
/* Tell the caller we're done */
bs->callback (bs->source,
bs->operation_id,
NULL,
0,
bs->user_data,
NULL);
return;
}
media_list = g_list_reverse (media_list);
/* And go to resolve all those devices */
data = g_new0 (BrowseData, 1);
data->source = source;
data->bs = bs;
data->media_list = media_list;
data->cancellable = g_cancellable_new ();
grl_operation_set_data (bs->operation_id, data->cancellable);
data->parser = totem_pl_parser_new ();
g_object_set (data->parser, "recurse", FALSE, NULL);
g_signal_connect (G_OBJECT (data->parser), "entry-parsed",
G_CALLBACK (entry_parsed_cb), data);
resolve_disc_urls (data);
}
static void fm_places_model_init(FmPlacesModel *self)
{
GType types[] = {GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_POINTER};
GtkTreeIter it;
GtkTreePath* tp;
FmPlaceItem* item;
GList *vols, *l;
GIcon* gicon;
FmIcon* icon;
GFile* gf;
GdkPixbuf* pix;
FmFileInfoJob* job = fm_file_info_job_new(NULL, FM_FILE_INFO_JOB_FOLLOW_SYMLINK);
GtkListStore* model = GTK_LIST_STORE(self);
gtk_list_store_set_column_types(GTK_LIST_STORE(self), FM_PLACES_MODEL_N_COLS, types);
self->theme_change_handler = g_signal_connect_swapped(gtk_icon_theme_get_default(), "changed",
G_CALLBACK(update_icons), self);
self->use_trash_change_handler = g_signal_connect(fm_config, "changed::use_trash",
G_CALLBACK(on_use_trash_changed), self);
self->pane_icon_size_change_handler = g_signal_connect(fm_config, "changed::pane_icon_size",
G_CALLBACK(on_pane_icon_size_changed), self);
icon = fm_icon_from_name("media-eject");
pix = fm_icon_get_pixbuf(icon, fm_config->pane_icon_size);
fm_icon_unref(icon);
self->eject_icon = pix;
item = g_slice_new0(FmPlaceItem);
item->type = FM_PLACES_ITEM_PATH;
item->fi = fm_file_info_new();
item->fi->path = fm_path_ref(fm_path_get_home());
item->fi->icon = fm_icon_from_name("user-home");
gtk_list_store_append(model, &it);
pix = fm_icon_get_pixbuf(item->fi->icon, fm_config->pane_icon_size);
gtk_list_store_set(model, &it, FM_PLACES_MODEL_COL_ICON, pix, FM_PLACES_MODEL_COL_LABEL, item->fi->path->name, FM_PLACES_MODEL_COL_INFO, item, -1);
g_object_unref(pix);
fm_file_info_job_add(job, item->fi->path);
/* Only show desktop in side pane when the user has a desktop dir. */
if(g_file_test(g_get_user_special_dir(G_USER_DIRECTORY_DESKTOP), G_FILE_TEST_IS_DIR))
{
item = g_slice_new0(FmPlaceItem);
item->type = FM_PLACES_ITEM_PATH;
item->fi = fm_file_info_new();
item->fi->path = fm_path_ref(fm_path_get_desktop());
item->fi->icon = fm_icon_from_name("user-desktop");
gtk_list_store_append(model, &it);
pix = fm_icon_get_pixbuf(item->fi->icon, fm_config->pane_icon_size);
gtk_list_store_set(model, &it, FM_PLACES_MODEL_COL_ICON, pix, FM_PLACES_MODEL_COL_LABEL, _("Desktop"), FM_PLACES_MODEL_COL_INFO, item, -1);
g_object_unref(pix);
fm_file_info_job_add(job, item->fi->path);
}
if(fm_config->use_trash)
create_trash_item(self); /* FIXME: how to handle trash can? */
item = g_slice_new0(FmPlaceItem);
item->type = FM_PLACES_ITEM_PATH;
item->fi = fm_file_info_new();
item->fi->path = fm_path_ref(fm_path_get_apps_menu());
item->fi->icon = fm_icon_from_name("system-software-install");
gtk_list_store_append(model, &it);
pix = fm_icon_get_pixbuf(item->fi->icon, fm_config->pane_icon_size);
gtk_list_store_set(model, &it, FM_PLACES_MODEL_COL_ICON, pix, FM_PLACES_MODEL_COL_LABEL, _("Applications"), FM_PLACES_MODEL_COL_INFO, item, -1);
g_object_unref(pix);
/* fm_file_info_job_add(job, item->fi->path); */
/* volumes */
self->vol_mon = g_volume_monitor_get();
g_signal_connect(self->vol_mon, "volume-added", G_CALLBACK(on_vol_added), self);
g_signal_connect(self->vol_mon, "volume-removed", G_CALLBACK(on_vol_removed), self);
g_signal_connect(self->vol_mon, "volume-changed", G_CALLBACK(on_vol_changed), self);
g_signal_connect(self->vol_mon, "mount-added", G_CALLBACK(on_mount_added), self);
/* separator */
gtk_list_store_append(model, &self->sep_it);
/* add volumes to side-pane */
vols = g_volume_monitor_get_volumes(self->vol_mon);
for(l=vols;l;l=l->next)
{
GVolume* vol = G_VOLUME(l->data);
add_vol(self, vol, job);
g_object_unref(vol);
}
g_list_free(vols);
/* get the path of separator */
self->sep_tp = gtk_tree_model_get_path(GTK_TREE_MODEL(self), &self->sep_it);
self->bookmarks = fm_bookmarks_get(); /* bookmarks */
g_signal_connect(self->bookmarks, "changed", G_CALLBACK(on_bookmarks_changed), self);
/* add bookmarks to side pane */
add_bookmarks(self, job);
g_signal_connect(job, "finished", G_CALLBACK(on_file_info_job_finished), self);
self->jobs = g_slist_prepend(self->jobs, job);
fm_job_run_async(FM_JOB(job));
}
/**
* rb_removable_media_manager_scan:
* @manager: the #RBRemovableMediaManager
*
* Initiates a new scan of all attached media. Newly activated plugins that use
* the create-source-volume or create-source-mount signals should call this if
* the 'scanned' property is %TRUE. Otherwise, the first scan will catch any
* existing volumes or mounts that the plugin is interested in.
*/
void
rb_removable_media_manager_scan (RBRemovableMediaManager *manager)
{
RBRemovableMediaManagerPrivate *priv = GET_PRIVATE (manager);
GHashTableIter iter;
GList *list, *it;
gpointer hkey, hvalue;
priv->scanned = TRUE;
/* check volumes first */
list = g_volume_monitor_get_volumes (priv->volume_monitor);
/* - check for volumes that have disappeared */
g_hash_table_iter_init (&iter, priv->volume_mapping);
while (g_hash_table_iter_next (&iter, &hkey, &hvalue)) {
GVolume *volume = G_VOLUME (hkey);
if (g_list_index (list, volume) == -1) {
/* volume has vanished */
rb_removable_media_manager_remove_volume (manager, volume);
}
}
/* - check for newly added volumes */
for (it = list; it != NULL; it = g_list_next (it)) {
GVolume *volume = G_VOLUME (it->data);
rb_removable_media_manager_add_volume (manager, volume);
g_object_unref (volume);
}
g_list_free (list);
/* check mounts */
list = g_volume_monitor_get_mounts (priv->volume_monitor);
/* - check for mounts that have disappeared */
g_hash_table_iter_init (&iter, priv->mount_mapping);
while (g_hash_table_iter_next (&iter, &hkey, &hvalue)) {
GMount *mount = G_MOUNT (hkey);
if (g_list_index (list, mount) == -1) {
rb_removable_media_manager_remove_mount (manager, mount);
}
}
/* - check for newly added mounts */
for (it = list; it != NULL; it = g_list_next (it)) {
GMount *mount = G_MOUNT (it->data);
rb_removable_media_manager_add_mount (manager, mount);
g_object_unref (mount);
}
g_list_free (list);
/* - check devices */
#if defined(HAVE_GUDEV)
list = g_udev_client_query_by_subsystem (priv->gudev_client, "usb");
for (it = list; it != NULL; it = g_list_next (it)) {
/* pretend the device was just added */
uevent_cb (priv->gudev_client, "add", G_UDEV_DEVICE (it->data), manager);
}
g_list_free (list);
#endif
}
static void
test_disc (gconstpointer data)
{
TotemDiscMediaType type;
GError *error = NULL;
char *mrl = NULL;
const char *device = (const char*) data;
type = totem_cd_detect_type_with_url (device, &mrl, &error);
if (type == MEDIA_TYPE_ERROR) {
GList *or, *list;
GVolumeMonitor *mon;
g_message ("Error getting media type: %s", error ? error->message : "unknown reason");
g_message ("List of connected drives:");
mon = g_volume_monitor_get ();
for (or = list = g_volume_monitor_get_connected_drives (mon); list != NULL; list = list->next) {
char *device_id;
device_id = g_drive_get_identifier ((GDrive *) list->data, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);
g_message ("\t%s", device_id);
g_free (device_id);
g_object_unref (list->data);
}
if (or == NULL)
g_message ("\tNo connected drives!");
else
g_list_free (or);
g_message ("List of volumes:");
for (or = list = g_volume_monitor_get_volumes (mon); list != NULL; list = list->next) {
char *device_id;
device_id = g_volume_get_identifier ((GVolume *) list->data, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);
if (g_volume_get_mount ((GVolume *) list->data) == NULL)
g_message ("\t%s", device_id);
else
g_message ("\t%s (mounted)", device_id);
g_free (device_id);
g_object_unref (list->data);
}
if (or == NULL)
g_message ("\tNo volumes!");
else
g_list_free (or);
return;
}
if (type != MEDIA_TYPE_DATA)
g_message ("%s contains a %s.", device, totem_cd_get_human_readable_name (type));
else
g_message ("%s contains a data disc", device);
g_assert (mrl != NULL);
g_message ("MRL for directory is \"%s\".", mrl);
g_free (mrl);
return;
}
static VALUE
rg_volumes(VALUE self)
{
return GLIST2ARY_FREE(g_volume_monitor_get_volumes(_SELF(self)));
}
