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