static void
monitor (void)
{
GMainLoop *loop;
GVolumeMonitor *volume_monitor;
loop = g_main_loop_new (NULL, FALSE);
volume_monitor = g_volume_monitor_get ();
g_signal_connect (volume_monitor, "mount-added", (GCallback) monitor_mount_added, NULL);
g_signal_connect (volume_monitor, "mount-removed", (GCallback) monitor_mount_removed, NULL);
g_signal_connect (volume_monitor, "mount-changed", (GCallback) monitor_mount_changed, NULL);
g_signal_connect (volume_monitor, "mount-pre-unmount", (GCallback) monitor_mount_pre_unmount, NULL);
g_signal_connect (volume_monitor, "volume-added", (GCallback) monitor_volume_added, NULL);
g_signal_connect (volume_monitor, "volume-removed", (GCallback) monitor_volume_removed, NULL);
g_signal_connect (volume_monitor, "volume-changed", (GCallback) monitor_volume_changed, NULL);
g_signal_connect (volume_monitor, "drive-connected", (GCallback) monitor_drive_connected, NULL);
g_signal_connect (volume_monitor, "drive-disconnected", (GCallback) monitor_drive_disconnected, NULL);
g_signal_connect (volume_monitor, "drive-changed", (GCallback) monitor_drive_changed, NULL);
g_signal_connect (volume_monitor, "drive-eject-button", (GCallback) monitor_drive_eject_button, NULL);
g_print ("Monitoring events. Press Ctrl+C to quit.\n");
g_main_loop_run (main_loop);
}
void fileops_empty_trash ()
{
GList* trash_list = NULL;
GVolumeMonitor* vol_monitor = g_volume_monitor_get ();
GList* mount_list = g_volume_monitor_get_mounts (vol_monitor);
g_object_unref (vol_monitor);
//iterate through all mounts
GList* l;
for (l = mount_list; l != NULL; l = l->next)
{
trash_list = g_list_concat (trash_list,
_get_trash_dirs_for_mount (l->data));
}
g_list_free_full (mount_list, g_object_unref);
//add 'trash:' prefix
trash_list = g_list_prepend (trash_list,
g_file_new_for_uri ("trash:"));
g_io_scheduler_push_job (_empty_trash_job,
trash_list,
NULL,
0,
NULL);
}
static void
print_mounts (const char *prefix)
{
GList *l;
GList *mounts;
GVolumeMonitor *volume_monitor;
volume_monitor = g_volume_monitor_get ();
mounts = g_volume_monitor_get_mounts (volume_monitor);
if (mounts != NULL)
{
for (l = mounts; l != NULL; l = l->next)
{
GMount *mount = l->data;
GFile *mount_root;
char *uri;
mount_root = g_mount_get_root (mount);
uri = g_file_get_uri (mount_root);
if (prefix == NULL ||
g_str_has_prefix (uri, prefix))
g_print ("%s\n", uri);
g_free (uri);
g_object_unref (mount_root);
g_object_unref (mount);
}
g_list_free (mounts);
}
g_object_unref (volume_monitor);
if (prefix == NULL || g_str_has_prefix ("file:///", prefix))
g_print ("file:///\n");
}
static const char* get_icon_for_path(const char* path)
{
GVolumeMonitor *monitor;
GList *mounts;
uint i;
GMount *mount;
GIcon *icon;
const char* name = "";
monitor = g_volume_monitor_get ();
mounts = g_volume_monitor_get_mounts (monitor);
for (i = 0; i < g_list_length (mounts); i++) {
mount = G_MOUNT (g_list_nth_data(mounts, i));
if (strcmp(g_mount_get_name(mount), path))
continue;
icon = g_mount_get_icon (mount);
if (!icon)
continue;
name = g_icon_to_string (icon);
g_object_unref (icon);
}
g_list_free_full (mounts, g_object_unref);
return name;
}
static char *
shell_util_get_file_display_name_if_mount (GFile *file)
{
GFile *compare;
GVolumeMonitor *monitor;
GList *mounts, *l;
char *ret;
ret = NULL;
/* compare with all mounts */
monitor = g_volume_monitor_get ();
mounts = g_volume_monitor_get_mounts (monitor);
for (l = mounts; l != NULL; l = l->next)
{
GMount *mount;
mount = G_MOUNT(l->data);
compare = g_mount_get_root (mount);
if (!ret && g_file_equal (file, compare))
ret = g_mount_get_name (mount);
g_object_unref (mount);
}
g_list_free (mounts);
g_object_unref (monitor);
return ret;
}
static void
mpd_devices_tile_init (MpdDevicesTile *self)
{
MpdDevicesTilePrivate *priv = GET_PRIVATE (self);
ClutterActor *tile;
GList *mounts;
priv->tiles = g_hash_table_new (g_direct_hash, g_direct_equal);
priv->vbox = mx_box_layout_new ();
mx_box_layout_set_enable_animations (MX_BOX_LAYOUT (priv->vbox),
TRUE);
mx_box_layout_set_orientation (MX_BOX_LAYOUT (priv->vbox),
MX_ORIENTATION_VERTICAL);
clutter_container_add_actor (CLUTTER_CONTAINER (self), priv->vbox);
tile = mpd_default_device_tile_new ();
clutter_container_add_actor (CLUTTER_CONTAINER (priv->vbox), tile);
priv->monitor = g_volume_monitor_get ();
g_signal_connect (priv->monitor, "mount-added",
G_CALLBACK (_monitor_mount_added_cb), self);
g_signal_connect (priv->monitor, "mount-changed",
G_CALLBACK (_monitor_mount_changed_cb), self);
g_signal_connect (priv->monitor, "mount-removed",
G_CALLBACK (_monitor_mount_removed_cb), self);
mounts = g_volume_monitor_get_mounts (priv->monitor);
g_list_foreach (mounts, (GFunc) _add_mount_cb, self);
g_list_free (mounts);
}
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;
}
static GDrive *_cd_find_drive_from_name (const gchar *cName)
{
g_return_val_if_fail (cName != NULL, NULL);
cd_message ("%s (%s)", __func__, cName);
GVolumeMonitor *pVolumeMonitor = g_volume_monitor_get ();
GDrive *pFoundDrive = NULL;
//\___________________ 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 *dl;
GDrive *pDrive;
gchar *cDriveName;
for (dl = pDrivesList; dl != NULL; dl = dl->next)
{
pDrive = dl->data;
if (pFoundDrive == NULL)
{
cDriveName = g_drive_get_name (pDrive);
cd_message (" drive '%s'", cDriveName);
if (cDriveName != NULL && strcmp (cDriveName, cName) == 0)
pFoundDrive = pDrive;
else
g_object_unref (pDrive);
//g_free (cDriveName);
}
else
g_object_unref (pDrive);
}
g_list_free (pDrivesList);
return pFoundDrive;
}
void fileops_empty_trash ()
{
if (pool == NULL) {
pool = g_thread_pool_new(_empty_trash_job, NULL, -1, FALSE, NULL);
atexit(destroy_thread_pool);
}
GList* trash_list = NULL;
GVolumeMonitor* vol_monitor = g_volume_monitor_get ();
GList* mount_list = g_volume_monitor_get_mounts (vol_monitor);
g_object_unref (vol_monitor);
//iterate through all mounts
GList* l;
for (l = mount_list; l != NULL; l = l->next)
{
trash_list = g_list_concat (trash_list,
_get_trash_dirs_for_mount (l->data));
}
g_list_free_full (mount_list, g_object_unref);
//add 'trash:' prefix
trash_list = g_list_prepend (trash_list,
g_file_new_for_uri ("trash:"));
g_thread_pool_push(pool, trash_list, NULL);
}
static void
nemo_main_application_continue_startup (NemoApplication *app)
{
NemoMainApplication *self = NEMO_MAIN_APPLICATION (app);
/* create DBus manager */
self->priv->dbus_manager = nemo_dbus_manager_new ();
self->priv->fdb_manager = nemo_freedesktop_dbus_new ();
/* Check the user's ~/.config/nemo directory and post warnings
* if there are problems.
*/
nemo_application_check_required_directory (app, nemo_get_user_directory ());
/* register views */
nemo_icon_view_register ();
nemo_list_view_register ();
nemo_icon_view_compact_register ();
#if defined(ENABLE_EMPTY_VIEW) && ENABLE_EMPTY_VIEW
nemo_empty_view_register ();
#endif
/* Watch for unmounts so we can close open windows */
/* TODO-gio: This should be using the UNMOUNTED feature of GFileMonitor instead */
self->priv->volume_monitor = g_volume_monitor_get ();
g_signal_connect_object (self->priv->volume_monitor, "mount_removed",
G_CALLBACK (mount_removed_callback), self, 0);
g_signal_connect_object (self->priv->volume_monitor, "mount_added",
G_CALLBACK (mount_added_callback), self, 0);
g_signal_connect_swapped (nemo_window_state, "changed::" NEMO_WINDOW_STATE_START_WITH_MENU_BAR,
G_CALLBACK (menu_state_changed_callback), self);
}
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
rhythmdb_init_monitoring (RhythmDB *db)
{
db->priv->monitored_directories = g_hash_table_new_full (g_file_hash, (GEqualFunc) g_file_equal,
(GDestroyNotify) g_object_unref,
(GDestroyNotify)g_file_monitor_cancel);
db->priv->changed_files = g_hash_table_new_full (rb_refstring_hash, rb_refstring_equal,
(GDestroyNotify) rb_refstring_unref,
NULL);
db->priv->volume_monitor = g_volume_monitor_get ();
g_signal_connect (G_OBJECT (db->priv->volume_monitor),
"mount-added",
G_CALLBACK (rhythmdb_mount_added_cb),
db);
g_signal_connect (G_OBJECT (db->priv->volume_monitor),
"mount-removed",
G_CALLBACK (rhythmdb_mount_removed_cb),
db);
g_signal_connect (G_OBJECT (db->priv->volume_monitor),
"mount-pre-unmount",
G_CALLBACK (rhythmdb_mount_removed_cb),
db);
}
static void
unmount_all_with_scheme (const char *scheme)
{
GVolumeMonitor *volume_monitor;
GList *mounts;
GList *l;
volume_monitor = g_volume_monitor_get();
/* populate gvfs network mounts */
iterate_gmain();
mounts = g_volume_monitor_get_mounts (volume_monitor);
for (l = mounts; l != NULL; l = l->next) {
GMount *mount = G_MOUNT (l->data);
GFile *root;
root = g_mount_get_root (mount);
if (g_file_has_uri_scheme (root, scheme)) {
unmount (root);
}
g_object_unref (root);
}
g_list_foreach (mounts, (GFunc)g_object_unref, NULL);
g_list_free (mounts);
g_object_unref (volume_monitor);
}
static void
tracker_storage_init (TrackerStorage *storage)
{
TrackerStoragePrivate *priv;
g_message ("Initializing Storage...");
priv = TRACKER_STORAGE_GET_PRIVATE (storage);
priv->mounts = g_node_new (NULL);
priv->mounts_by_uuid = g_hash_table_new_full (g_str_hash,
g_str_equal,
(GDestroyNotify) g_free,
NULL);
priv->unmount_watchdogs = g_hash_table_new_full (NULL, NULL, NULL,
(GDestroyNotify) g_source_remove);
priv->volume_monitor = g_volume_monitor_get ();
/* Volume and property notification callbacks */
g_signal_connect_object (priv->volume_monitor, "mount-removed",
G_CALLBACK (mount_removed_cb), storage, 0);
g_signal_connect_object (priv->volume_monitor, "mount-pre-unmount",
G_CALLBACK (mount_pre_removed_cb), storage, 0);
g_signal_connect_object (priv->volume_monitor, "mount-added",
G_CALLBACK (mount_added_cb), storage, 0);
g_message ("Mount monitors set up for to watch for added, removed and pre-unmounts...");
/* Get all mounts and set them up */
if (!mounts_setup (storage)) {
return;
}
}
NautilusMonitor *
nautilus_monitor_directory (GFile *location)
{
GFileMonitor *dir_monitor;
NautilusMonitor *ret;
ret = g_slice_new0 (NautilusMonitor);
dir_monitor = g_file_monitor_directory (location, G_FILE_MONITOR_WATCH_MOUNTS, NULL, NULL);
if (dir_monitor != NULL) {
ret->monitor = dir_monitor;
} else if (!g_file_is_native (location)) {
ret->location = g_object_ref (location);
ret->volume_monitor = g_volume_monitor_get ();
}
if (ret->monitor != NULL) {
g_signal_connect (ret->monitor, "changed",
G_CALLBACK (dir_changed), ret);
}
if (ret->volume_monitor != NULL) {
g_signal_connect (ret->volume_monitor, "mount-removed",
G_CALLBACK (mount_removed), ret);
}
/* We return a monitor even on failure, so we can avoid later trying again */
return ret;
}
/**
* pk_backend_initialize:
* This should only be run once per backend load, i.e. not every transaction
*/
void
pk_backend_initialize (GKeyFile *conf, PkBackend *backend)
{
gboolean ret;
GFile *file = NULL;
GError *error = NULL;
GKeyFile *key_file = NULL;
gchar *config_file = NULL;
GList *mounts;
/* use logging */
pk_debug_add_log_domain (G_LOG_DOMAIN);
pk_debug_add_log_domain ("Yum");
/* create private area */
priv = g_new0 (PkBackendYumPrivate, 1);
g_debug ("backend: initialize");
priv->spawn = pk_backend_spawn_new (conf);
pk_backend_spawn_set_filter_stderr (priv->spawn, pk_backend_stderr_cb);
pk_backend_spawn_set_filter_stdout (priv->spawn, pk_backend_stdout_cb);
pk_backend_spawn_set_name (priv->spawn, "yum");
pk_backend_spawn_set_allow_sigkill (priv->spawn, FALSE);
/* coldplug the mounts */
priv->volume_monitor = g_volume_monitor_get ();
mounts = g_volume_monitor_get_mounts (priv->volume_monitor);
g_list_foreach (mounts, (GFunc) pk_backend_mount_add, NULL);
g_list_foreach (mounts, (GFunc) g_object_unref, NULL);
g_list_free (mounts);
/* setup a file monitor on the repos directory */
file = g_file_new_for_path (YUM_REPOS_DIRECTORY);
priv->monitor = g_file_monitor_directory (file, G_FILE_MONITOR_NONE, NULL, &error);
if (priv->monitor != NULL) {
g_signal_connect (priv->monitor, "changed", G_CALLBACK (pk_backend_yum_repos_changed_cb), backend);
} else {
g_warning ("failed to setup monitor: %s", error->message);
g_error_free (error);
}
/* read the config file */
key_file = g_key_file_new ();
config_file = g_build_filename (SYSCONFDIR, "PackageKit", "Yum.conf", NULL);
g_debug ("loading configuration from %s", config_file);
ret = g_key_file_load_from_file (key_file, config_file, G_KEY_FILE_NONE, &error);
if (!ret) {
g_warning ("failed to load Yum.conf: %s", error->message);
g_error_free (error);
goto out;
}
out:
g_free (config_file);
if (key_file != NULL)
g_key_file_free (key_file);
if (file != NULL)
g_object_unref (file);
}
static void
init_volume_monitor (GsmApplication *app)
{
GVolumeMonitor *monitor = g_volume_monitor_get ();
g_signal_connect (monitor, "mount-added", G_CALLBACK (mount_changed), app);
g_signal_connect (monitor, "mount-changed", G_CALLBACK (mount_changed), app);
g_signal_connect (monitor, "mount-removed", G_CALLBACK (mount_changed), app);
}
void
totem_setup_file_monitoring (Totem *totem)
{
totem->monitor = g_volume_monitor_get ();
g_signal_connect (G_OBJECT (totem->monitor),
"mount-pre-unmount",
G_CALLBACK (totem_action_on_unmount),
totem);
}
int32_t dt_camera_import_backup_job_run(dt_job_t *job)
{
// copy sourcefile to each found destination
dt_camera_import_backup_t *t = (dt_camera_import_backup_t *)job->param;
GVolumeMonitor *vmgr= g_volume_monitor_get();
GList *mounts=g_volume_monitor_get_mounts(vmgr);
GMount *mount=NULL;
GFile *root=NULL;
if( mounts !=NULL )
do
{
mount=G_MOUNT(mounts->data);
if( ( root=g_mount_get_root( mount ) ) != NULL )
{
// Got the mount point lets check for backup folder
gchar *backuppath=NULL;
gchar *rootpath=g_file_get_path(root);
backuppath=g_build_path(G_DIR_SEPARATOR_S,rootpath,dt_conf_get_string("plugins/capture/backup/foldername"),(char *)NULL);
g_free(rootpath);
if( g_file_test(backuppath,G_FILE_TEST_EXISTS)==TRUE)
{
// Found a backup storage, lets copy file here..
gchar *destinationfile=g_build_filename(G_DIR_SEPARATOR_S,backuppath,t->destinationfile,(char *)NULL);
if( g_mkdir_with_parents(g_path_get_dirname(destinationfile),0755) >= 0 )
{
gchar *content;
gsize size;
if( g_file_get_contents(t->sourcefile,&content,&size,NULL) == TRUE )
{
GError *err=NULL;
if( g_file_set_contents(destinationfile,content,size,&err) != TRUE)
{
fprintf(stderr,"Failed to set content of file with reason: %s\n",err->message);
g_error_free(err);
}
g_free(content);
}
}
g_free(destinationfile);
}
g_free(backuppath);
}
}
while( (mounts=g_list_next(mounts)) !=NULL);
// Release volume manager
g_object_unref(vmgr);
return 0;
}
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 void
grl_optical_media_source_init (GrlOpticalMediaSource *source)
{
source->priv = GRL_OPTICAL_MEDIA_SOURCE_GET_PRIVATE (source);
source->priv->cancellable = g_cancellable_new ();
source->priv->monitor = g_volume_monitor_get ();
source->priv->monitor_signal_ids[0] = g_signal_connect (G_OBJECT (source->priv->monitor), "mount-added",
G_CALLBACK (on_g_volume_monitor_added_event), source);
source->priv->monitor_signal_ids[1] = g_signal_connect (G_OBJECT (source->priv->monitor), "mount-changed",
G_CALLBACK (on_g_volume_monitor_changed_event), source);
source->priv->monitor_signal_ids[2] = g_signal_connect (G_OBJECT (source->priv->monitor), "mount-removed",
G_CALLBACK (on_g_volume_monitor_removed_event), source);
}
static void
fr_file_selector_dialog_finalize (GObject *object)
{
FrFileSelectorDialog *self;
self = FR_FILE_SELECTOR_DIALOG (object);
g_signal_handlers_disconnect_by_data (g_volume_monitor_get (), self);
g_object_unref (self->priv->builder);
_g_object_unref (self->priv->current_folder);
g_object_unref (self->priv->settings);
G_OBJECT_CLASS (fr_file_selector_dialog_parent_class)->finalize (object);
}
int
main (int argc, char *argv[])
{
GVolumeMonitor *monitor;
GFile *file;
GMount *mount;
bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
gtk_init (&argc, &argv);
if (argc != 2)
{
goto out;
}
/* instantiate monitor so we get the "unmounted" signal properly */
monitor = g_volume_monitor_get ();
if (monitor == NULL)
{
goto out;
}
file = g_file_new_for_commandline_arg (argv[1]);
if (file == NULL)
{
g_object_unref (monitor);
goto out;
}
mount = g_file_find_enclosing_mount (file, NULL, NULL);
if (mount == NULL)
{
g_object_unref (file);
g_object_unref (monitor);
goto out;
}
present_autorun_for_software_dialog (mount);
g_object_unref (file);
g_object_unref (monitor);
g_object_unref (mount);
out:
return 0;
}
int
main (int argc,
char *argv[])
{
g_autoptr (GVolumeMonitor) monitor = NULL;
g_autoptr (GFile) file = NULL;
g_autoptr (GMount) mount = NULL;
g_autoptr (GError) error = NULL;
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
gtk_init (&argc, &argv);
if (argc != 2)
{
g_print ("Usage: %s mount-uri\n", argv[0]);
goto out;
}
/* instantiate monitor so we get the "unmounted" signal properly */
monitor = g_volume_monitor_get ();
if (monitor == NULL)
{
g_warning ("Unable to connect to the volume monitor");
goto out;
}
file = g_file_new_for_commandline_arg (argv[1]);
if (file == NULL)
{
g_warning ("Unable to parse mount URI");
goto out;
}
mount = g_file_find_enclosing_mount (file, NULL, &error);
if (mount == NULL)
{
g_warning ("Unable to find device for URI: %s", error->message);
goto out;
}
present_autorun_for_software_dialog (mount);
out:
return 0;
}
/**
* mcm_profile_store_init:
**/
static void
mcm_profile_store_init (McmProfileStore *profile_store)
{
profile_store->priv = MCM_PROFILE_STORE_GET_PRIVATE (profile_store);
profile_store->priv->profile_array = g_ptr_array_new_with_free_func ((GDestroyNotify) g_object_unref);
profile_store->priv->monitor_array = g_ptr_array_new_with_free_func ((GDestroyNotify) g_object_unref);
profile_store->priv->directory_array = g_ptr_array_new_with_free_func ((GDestroyNotify) g_free);
profile_store->priv->settings = g_settings_new (MCM_SETTINGS_SCHEMA);
/* watch for volumes to be connected */
profile_store->priv->volume_monitor = g_volume_monitor_get ();
g_signal_connect (profile_store->priv->volume_monitor,
"mount-added",
G_CALLBACK(mcm_profile_store_volume_monitor_mount_added_cb),
profile_store);
}
// -------------------------------------------------------------------------------- //
//
// -------------------------------------------------------------------------------- //
guGIO_VolumeMonitor::guGIO_VolumeMonitor( guMainFrame * mainframe )
{
m_MainFrame = mainframe;
m_MountedVolumes = new guGIO_MountArray();
m_VolumeMonitor = g_volume_monitor_get();
if( m_VolumeMonitor )
{
m_VolumeAddedId = g_signal_connect( m_VolumeMonitor, "volume-added", G_CALLBACK( VolumeAdded ), this );
m_VolumeRemovedId = g_signal_connect( m_VolumeMonitor, "volume-removed", G_CALLBACK( VolumeRemoved ), this );
m_MountAddedId = g_signal_connect( m_VolumeMonitor, "mount-added", G_CALLBACK( MountAdded ), this );
m_MountPreUnmountId = g_signal_connect( m_VolumeMonitor, "mount-pre-unmount", G_CALLBACK( MountRemoved ), this );
m_MountRemovedId = g_signal_connect( m_VolumeMonitor, "mount-removed", G_CALLBACK( MountRemoved ), this );
}
GetCurrentMounts();
}
void
watch_volumes(signal_user_data_t *ud)
{
#if !defined(_WIN32)
GVolumeMonitor *gvm;
gvm = g_volume_monitor_get();
g_signal_connect(gvm, "drive-changed", (GCallback)drive_changed_cb, ud);
#else
GdkWindow *window;
GtkWidget *widget;
widget = GHB_WIDGET(ud->builder, "hb_window");
window = gtk_widget_get_parent_window(widget);
gdk_window_add_filter(window, win_message_cb, ud);
#endif
}
static GMount *
find_mount_for_device (GUdevDevice *device)
{
GMount *mount = NULL;
const char *device_file;
GVolumeMonitor *volmon;
GList *mounts;
GList *i;
device_file = g_udev_device_get_device_file (device);
if (device_file == NULL) {
return NULL;
}
volmon = g_volume_monitor_get ();
mounts = g_volume_monitor_get_mounts (volmon);
g_object_unref (volmon);
for (i = mounts; i != NULL; i = i->next) {
GVolume *v;
v = g_mount_get_volume (G_MOUNT (i->data));
if (v != NULL) {
char *devname = NULL;
gboolean match;
devname = g_volume_get_identifier (v, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);
g_object_unref (v);
if (devname == NULL)
continue;
match = g_str_equal (devname, device_file);
g_free (devname);
if (match) {
mount = G_MOUNT (i->data);
g_object_ref (G_OBJECT (mount));
break;
}
}
}
g_list_foreach (mounts, (GFunc)g_object_unref, NULL);
g_list_free (mounts);
return mount;
}