Import Upstream version 2.72.4
This commit is contained in:
evinadmin
commit
4ef3ff9793
2003 changed files with 1332420 additions and 0 deletions
635
gio/gunionvolumemonitor.c
Normal file
635
gio/gunionvolumemonitor.c
Normal file
|
|
@ -0,0 +1,635 @@
|
|||
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
|
||||
|
||||
/* GIO - GLib Input, Output and Streaming Library
|
||||
*
|
||||
* Copyright (C) 2006-2007 Red Hat, Inc.
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General
|
||||
* Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
|
||||
*
|
||||
* Author: Alexander Larsson <alexl@redhat.com>
|
||||
* David Zeuthen <davidz@redhat.com>
|
||||
*/
|
||||
|
||||
#include "config.h"
|
||||
|
||||
#include <string.h>
|
||||
|
||||
#include <glib.h>
|
||||
#include "gunionvolumemonitor.h"
|
||||
#include "gmountprivate.h"
|
||||
#include "giomodule-priv.h"
|
||||
#ifdef G_OS_UNIX
|
||||
#include "gunixvolumemonitor.h"
|
||||
#endif
|
||||
#include "gnativevolumemonitor.h"
|
||||
|
||||
#include "glibintl.h"
|
||||
|
||||
|
||||
struct _GUnionVolumeMonitor {
|
||||
GVolumeMonitor parent;
|
||||
|
||||
GList *monitors;
|
||||
};
|
||||
|
||||
static void g_union_volume_monitor_remove_monitor (GUnionVolumeMonitor *union_monitor,
|
||||
GVolumeMonitor *child_monitor);
|
||||
|
||||
|
||||
#define g_union_volume_monitor_get_type _g_union_volume_monitor_get_type
|
||||
G_DEFINE_TYPE (GUnionVolumeMonitor, g_union_volume_monitor, G_TYPE_VOLUME_MONITOR)
|
||||
|
||||
static GRecMutex the_volume_monitor_mutex;
|
||||
|
||||
static GUnionVolumeMonitor *the_volume_monitor = NULL;
|
||||
|
||||
static void
|
||||
g_union_volume_monitor_finalize (GObject *object)
|
||||
{
|
||||
GUnionVolumeMonitor *monitor;
|
||||
GVolumeMonitor *child_monitor;
|
||||
|
||||
monitor = G_UNION_VOLUME_MONITOR (object);
|
||||
|
||||
while (monitor->monitors != NULL)
|
||||
{
|
||||
child_monitor = monitor->monitors->data;
|
||||
g_union_volume_monitor_remove_monitor (monitor,
|
||||
child_monitor);
|
||||
g_object_unref (child_monitor);
|
||||
}
|
||||
|
||||
G_OBJECT_CLASS (g_union_volume_monitor_parent_class)->finalize (object);
|
||||
}
|
||||
|
||||
static void
|
||||
g_union_volume_monitor_dispose (GObject *object)
|
||||
{
|
||||
GUnionVolumeMonitor *monitor;
|
||||
GVolumeMonitor *child_monitor;
|
||||
GList *l;
|
||||
|
||||
monitor = G_UNION_VOLUME_MONITOR (object);
|
||||
|
||||
g_rec_mutex_lock (&the_volume_monitor_mutex);
|
||||
the_volume_monitor = NULL;
|
||||
|
||||
for (l = monitor->monitors; l != NULL; l = l->next)
|
||||
{
|
||||
child_monitor = l->data;
|
||||
g_object_run_dispose (G_OBJECT (child_monitor));
|
||||
}
|
||||
|
||||
g_rec_mutex_unlock (&the_volume_monitor_mutex);
|
||||
|
||||
G_OBJECT_CLASS (g_union_volume_monitor_parent_class)->dispose (object);
|
||||
}
|
||||
|
||||
static GList *
|
||||
get_mounts (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_mounts (child_monitor));
|
||||
}
|
||||
|
||||
g_rec_mutex_unlock (&the_volume_monitor_mutex);
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
static GList *
|
||||
get_connected_drives (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_connected_drives (child_monitor));
|
||||
}
|
||||
|
||||
g_rec_mutex_unlock (&the_volume_monitor_mutex);
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
static GVolume *
|
||||
get_volume_for_uuid (GVolumeMonitor *volume_monitor, const char *uuid)
|
||||
{
|
||||
GUnionVolumeMonitor *monitor;
|
||||
GVolumeMonitor *child_monitor;
|
||||
GVolume *volume;
|
||||
GList *l;
|
||||
|
||||
monitor = G_UNION_VOLUME_MONITOR (volume_monitor);
|
||||
|
||||
volume = NULL;
|
||||
|
||||
g_rec_mutex_lock (&the_volume_monitor_mutex);
|
||||
|
||||
for (l = monitor->monitors; l != NULL; l = l->next)
|
||||
{
|
||||
child_monitor = l->data;
|
||||
|
||||
volume = g_volume_monitor_get_volume_for_uuid (child_monitor, uuid);
|
||||
if (volume != NULL)
|
||||
break;
|
||||
|
||||
}
|
||||
|
||||
g_rec_mutex_unlock (&the_volume_monitor_mutex);
|
||||
|
||||
return volume;
|
||||
}
|
||||
|
||||
static GMount *
|
||||
get_mount_for_uuid (GVolumeMonitor *volume_monitor, const char *uuid)
|
||||
{
|
||||
GUnionVolumeMonitor *monitor;
|
||||
GVolumeMonitor *child_monitor;
|
||||
GMount *mount;
|
||||
GList *l;
|
||||
|
||||
monitor = G_UNION_VOLUME_MONITOR (volume_monitor);
|
||||
|
||||
mount = NULL;
|
||||
|
||||
g_rec_mutex_lock (&the_volume_monitor_mutex);
|
||||
|
||||
for (l = monitor->monitors; l != NULL; l = l->next)
|
||||
{
|
||||
child_monitor = l->data;
|
||||
|
||||
mount = g_volume_monitor_get_mount_for_uuid (child_monitor, uuid);
|
||||
if (mount != NULL)
|
||||
break;
|
||||
|
||||
}
|
||||
|
||||
g_rec_mutex_unlock (&the_volume_monitor_mutex);
|
||||
|
||||
return mount;
|
||||
}
|
||||
|
||||
static void
|
||||
g_union_volume_monitor_class_init (GUnionVolumeMonitorClass *klass)
|
||||
{
|
||||
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
|
||||
GVolumeMonitorClass *monitor_class = G_VOLUME_MONITOR_CLASS (klass);
|
||||
|
||||
gobject_class->finalize = g_union_volume_monitor_finalize;
|
||||
gobject_class->dispose = g_union_volume_monitor_dispose;
|
||||
|
||||
monitor_class->get_connected_drives = get_connected_drives;
|
||||
monitor_class->get_volumes = get_volumes;
|
||||
monitor_class->get_mounts = get_mounts;
|
||||
monitor_class->get_volume_for_uuid = get_volume_for_uuid;
|
||||
monitor_class->get_mount_for_uuid = get_mount_for_uuid;
|
||||
}
|
||||
|
||||
static void
|
||||
child_volume_added (GVolumeMonitor *child_monitor,
|
||||
GVolume *child_volume,
|
||||
GUnionVolumeMonitor *union_monitor)
|
||||
{
|
||||
g_signal_emit_by_name (union_monitor,
|
||||
"volume-added",
|
||||
child_volume);
|
||||
}
|
||||
|
||||
static void
|
||||
child_volume_removed (GVolumeMonitor *child_monitor,
|
||||
GVolume *child_volume,
|
||||
GUnionVolumeMonitor *union_monitor)
|
||||
{
|
||||
g_signal_emit_by_name (union_monitor,
|
||||
"volume-removed",
|
||||
child_volume);
|
||||
}
|
||||
|
||||
static void
|
||||
child_volume_changed (GVolumeMonitor *child_monitor,
|
||||
GVolume *child_volume,
|
||||
GUnionVolumeMonitor *union_monitor)
|
||||
{
|
||||
g_signal_emit_by_name (union_monitor,
|
||||
"volume-changed",
|
||||
child_volume);
|
||||
}
|
||||
|
||||
static void
|
||||
child_mount_added (GVolumeMonitor *child_monitor,
|
||||
GMount *child_mount,
|
||||
GUnionVolumeMonitor *union_monitor)
|
||||
{
|
||||
g_signal_emit_by_name (union_monitor,
|
||||
"mount-added",
|
||||
child_mount);
|
||||
}
|
||||
|
||||
static void
|
||||
child_mount_removed (GVolumeMonitor *child_monitor,
|
||||
GMount *child_mount,
|
||||
GUnionVolumeMonitor *union_monitor)
|
||||
{
|
||||
g_signal_emit_by_name (union_monitor,
|
||||
"mount-removed",
|
||||
child_mount);
|
||||
}
|
||||
|
||||
static void
|
||||
child_mount_pre_unmount (GVolumeMonitor *child_monitor,
|
||||
GMount *child_mount,
|
||||
GUnionVolumeMonitor *union_monitor)
|
||||
{
|
||||
g_signal_emit_by_name (union_monitor,
|
||||
"mount-pre-unmount",
|
||||
child_mount);
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
child_mount_changed (GVolumeMonitor *child_monitor,
|
||||
GMount *child_mount,
|
||||
GUnionVolumeMonitor *union_monitor)
|
||||
{
|
||||
g_signal_emit_by_name (union_monitor,
|
||||
"mount-changed",
|
||||
child_mount);
|
||||
}
|
||||
|
||||
static void
|
||||
child_drive_connected (GVolumeMonitor *child_monitor,
|
||||
GDrive *child_drive,
|
||||
GUnionVolumeMonitor *union_monitor)
|
||||
{
|
||||
g_signal_emit_by_name (union_monitor,
|
||||
"drive-connected",
|
||||
child_drive);
|
||||
}
|
||||
|
||||
static void
|
||||
child_drive_disconnected (GVolumeMonitor *child_monitor,
|
||||
GDrive *child_drive,
|
||||
GUnionVolumeMonitor *union_monitor)
|
||||
{
|
||||
g_signal_emit_by_name (union_monitor,
|
||||
"drive-disconnected",
|
||||
child_drive);
|
||||
}
|
||||
|
||||
static void
|
||||
child_drive_changed (GVolumeMonitor *child_monitor,
|
||||
GDrive *child_drive,
|
||||
GUnionVolumeMonitor *union_monitor)
|
||||
{
|
||||
g_signal_emit_by_name (union_monitor,
|
||||
"drive-changed",
|
||||
child_drive);
|
||||
}
|
||||
|
||||
static void
|
||||
child_drive_eject_button (GVolumeMonitor *child_monitor,
|
||||
GDrive *child_drive,
|
||||
GUnionVolumeMonitor *union_monitor)
|
||||
{
|
||||
g_signal_emit_by_name (union_monitor,
|
||||
"drive-eject-button",
|
||||
child_drive);
|
||||
}
|
||||
|
||||
static void
|
||||
child_drive_stop_button (GVolumeMonitor *child_monitor,
|
||||
GDrive *child_drive,
|
||||
GUnionVolumeMonitor *union_monitor)
|
||||
{
|
||||
g_signal_emit_by_name (union_monitor,
|
||||
"drive-stop-button",
|
||||
child_drive);
|
||||
}
|
||||
|
||||
static void
|
||||
g_union_volume_monitor_add_monitor (GUnionVolumeMonitor *union_monitor,
|
||||
GVolumeMonitor *volume_monitor)
|
||||
{
|
||||
if (g_list_find (union_monitor->monitors, volume_monitor))
|
||||
return;
|
||||
|
||||
union_monitor->monitors =
|
||||
g_list_prepend (union_monitor->monitors,
|
||||
g_object_ref (volume_monitor));
|
||||
|
||||
g_signal_connect (volume_monitor, "volume-added", (GCallback)child_volume_added, union_monitor);
|
||||
g_signal_connect (volume_monitor, "volume-removed", (GCallback)child_volume_removed, union_monitor);
|
||||
g_signal_connect (volume_monitor, "volume-changed", (GCallback)child_volume_changed, union_monitor);
|
||||
g_signal_connect (volume_monitor, "mount-added", (GCallback)child_mount_added, union_monitor);
|
||||
g_signal_connect (volume_monitor, "mount-removed", (GCallback)child_mount_removed, union_monitor);
|
||||
g_signal_connect (volume_monitor, "mount-pre-unmount", (GCallback)child_mount_pre_unmount, union_monitor);
|
||||
g_signal_connect (volume_monitor, "mount-changed", (GCallback)child_mount_changed, union_monitor);
|
||||
g_signal_connect (volume_monitor, "drive-connected", (GCallback)child_drive_connected, union_monitor);
|
||||
g_signal_connect (volume_monitor, "drive-disconnected", (GCallback)child_drive_disconnected, union_monitor);
|
||||
g_signal_connect (volume_monitor, "drive-changed", (GCallback)child_drive_changed, union_monitor);
|
||||
g_signal_connect (volume_monitor, "drive-eject-button", (GCallback)child_drive_eject_button, union_monitor);
|
||||
g_signal_connect (volume_monitor, "drive-stop-button", (GCallback)child_drive_stop_button, union_monitor);
|
||||
}
|
||||
|
||||
static void
|
||||
g_union_volume_monitor_remove_monitor (GUnionVolumeMonitor *union_monitor,
|
||||
GVolumeMonitor *child_monitor)
|
||||
{
|
||||
GList *l;
|
||||
|
||||
l = g_list_find (union_monitor->monitors, child_monitor);
|
||||
if (l == NULL)
|
||||
return;
|
||||
|
||||
union_monitor->monitors = g_list_delete_link (union_monitor->monitors, l);
|
||||
|
||||
g_signal_handlers_disconnect_by_func (child_monitor, child_volume_added, union_monitor);
|
||||
g_signal_handlers_disconnect_by_func (child_monitor, child_volume_removed, union_monitor);
|
||||
g_signal_handlers_disconnect_by_func (child_monitor, child_volume_changed, union_monitor);
|
||||
g_signal_handlers_disconnect_by_func (child_monitor, child_mount_added, union_monitor);
|
||||
g_signal_handlers_disconnect_by_func (child_monitor, child_mount_removed, union_monitor);
|
||||
g_signal_handlers_disconnect_by_func (child_monitor, child_mount_pre_unmount, union_monitor);
|
||||
g_signal_handlers_disconnect_by_func (child_monitor, child_mount_changed, union_monitor);
|
||||
g_signal_handlers_disconnect_by_func (child_monitor, child_drive_connected, union_monitor);
|
||||
g_signal_handlers_disconnect_by_func (child_monitor, child_drive_disconnected, union_monitor);
|
||||
g_signal_handlers_disconnect_by_func (child_monitor, child_drive_changed, union_monitor);
|
||||
g_signal_handlers_disconnect_by_func (child_monitor, child_drive_eject_button, union_monitor);
|
||||
g_signal_handlers_disconnect_by_func (child_monitor, child_drive_stop_button, union_monitor);
|
||||
}
|
||||
|
||||
static GType
|
||||
get_default_native_class (gpointer data)
|
||||
{
|
||||
return _g_io_module_get_default_type (G_NATIVE_VOLUME_MONITOR_EXTENSION_POINT_NAME,
|
||||
"GIO_USE_VOLUME_MONITOR",
|
||||
G_STRUCT_OFFSET (GVolumeMonitorClass, is_supported));
|
||||
}
|
||||
|
||||
/* We return the class, with a ref taken.
|
||||
* This way we avoid unloading the class/module
|
||||
* between selecting the type and creating the
|
||||
* instance on the first call.
|
||||
*/
|
||||
static GNativeVolumeMonitorClass *
|
||||
get_native_class (void)
|
||||
{
|
||||
static GOnce once_init = G_ONCE_INIT;
|
||||
GTypeClass *type_class;
|
||||
|
||||
type_class = NULL;
|
||||
g_once (&once_init, (GThreadFunc)get_default_native_class, &type_class);
|
||||
|
||||
if (type_class == NULL && once_init.retval != GUINT_TO_POINTER(G_TYPE_INVALID))
|
||||
type_class = g_type_class_ref ((GType)once_init.retval);
|
||||
|
||||
return (GNativeVolumeMonitorClass *)type_class;
|
||||
}
|
||||
|
||||
static void
|
||||
g_union_volume_monitor_init (GUnionVolumeMonitor *union_monitor)
|
||||
{
|
||||
}
|
||||
|
||||
static void
|
||||
populate_union_monitor (GUnionVolumeMonitor *union_monitor)
|
||||
{
|
||||
GVolumeMonitor *monitor;
|
||||
GNativeVolumeMonitorClass *native_class;
|
||||
GVolumeMonitorClass *klass;
|
||||
GIOExtensionPoint *ep;
|
||||
GIOExtension *extension;
|
||||
GList *l;
|
||||
|
||||
native_class = get_native_class ();
|
||||
|
||||
if (native_class != NULL)
|
||||
{
|
||||
monitor = g_object_new (G_TYPE_FROM_CLASS (native_class), NULL);
|
||||
g_union_volume_monitor_add_monitor (union_monitor, monitor);
|
||||
g_object_unref (monitor);
|
||||
g_type_class_unref (native_class);
|
||||
}
|
||||
|
||||
ep = g_io_extension_point_lookup (G_VOLUME_MONITOR_EXTENSION_POINT_NAME);
|
||||
for (l = g_io_extension_point_get_extensions (ep); l != NULL; l = l->next)
|
||||
{
|
||||
extension = l->data;
|
||||
|
||||
klass = G_VOLUME_MONITOR_CLASS (g_io_extension_ref_class (extension));
|
||||
if (klass->is_supported == NULL || klass->is_supported())
|
||||
{
|
||||
monitor = g_object_new (g_io_extension_get_type (extension), NULL);
|
||||
g_union_volume_monitor_add_monitor (union_monitor, monitor);
|
||||
g_object_unref (monitor);
|
||||
}
|
||||
g_type_class_unref (klass);
|
||||
}
|
||||
}
|
||||
|
||||
static GUnionVolumeMonitor *
|
||||
g_union_volume_monitor_new (void)
|
||||
{
|
||||
GUnionVolumeMonitor *monitor;
|
||||
|
||||
monitor = g_object_new (G_TYPE_UNION_VOLUME_MONITOR, NULL);
|
||||
|
||||
return monitor;
|
||||
}
|
||||
|
||||
/**
|
||||
* g_volume_monitor_get:
|
||||
*
|
||||
* Gets the volume monitor used by gio.
|
||||
*
|
||||
* Returns: (transfer full): a reference to the #GVolumeMonitor used by gio. Call
|
||||
* g_object_unref() when done with it.
|
||||
**/
|
||||
GVolumeMonitor *
|
||||
g_volume_monitor_get (void)
|
||||
{
|
||||
GVolumeMonitor *vm;
|
||||
|
||||
g_rec_mutex_lock (&the_volume_monitor_mutex);
|
||||
|
||||
if (the_volume_monitor)
|
||||
vm = G_VOLUME_MONITOR (g_object_ref (the_volume_monitor));
|
||||
else
|
||||
{
|
||||
the_volume_monitor = g_union_volume_monitor_new ();
|
||||
populate_union_monitor (the_volume_monitor);
|
||||
vm = G_VOLUME_MONITOR (the_volume_monitor);
|
||||
}
|
||||
|
||||
g_rec_mutex_unlock (&the_volume_monitor_mutex);
|
||||
|
||||
return vm;
|
||||
}
|
||||
|
||||
GMount *
|
||||
_g_mount_get_for_mount_path (const gchar *mount_path,
|
||||
GCancellable *cancellable)
|
||||
{
|
||||
GNativeVolumeMonitorClass *klass;
|
||||
GMount *mount;
|
||||
|
||||
klass = get_native_class ();
|
||||
if (klass == NULL)
|
||||
return NULL;
|
||||
|
||||
mount = NULL;
|
||||
|
||||
if (klass->get_mount_for_mount_path)
|
||||
mount = klass->get_mount_for_mount_path (mount_path, cancellable);
|
||||
|
||||
/* TODO: How do we know this succeeded? Keep in mind that the native
|
||||
* volume monitor may fail (e.g. not being able to connect to
|
||||
* udisks). Is the get_mount_for_mount_path() method allowed to
|
||||
* return NULL? Seems like it is ... probably the method needs
|
||||
* to take a boolean and write if it succeeds or not.. Messy.
|
||||
* Very messy.
|
||||
*/
|
||||
|
||||
g_type_class_unref (klass);
|
||||
|
||||
return mount;
|
||||
}
|
||||
|
||||
/**
|
||||
* g_volume_monitor_adopt_orphan_mount:
|
||||
* @mount: a #GMount object to find a parent for
|
||||
*
|
||||
* This function should be called by any #GVolumeMonitor
|
||||
* implementation when a new #GMount object is created that is not
|
||||
* associated with a #GVolume object. It must be called just before
|
||||
* emitting the @mount_added signal.
|
||||
*
|
||||
* If the return value is not %NULL, the caller must associate the
|
||||
* returned #GVolume object with the #GMount. This involves returning
|
||||
* it in its g_mount_get_volume() implementation. The caller must
|
||||
* also listen for the "removed" signal on the returned object
|
||||
* and give up its reference when handling that signal
|
||||
*
|
||||
* Similarly, if implementing g_volume_monitor_adopt_orphan_mount(),
|
||||
* the implementor must take a reference to @mount and return it in
|
||||
* its g_volume_get_mount() implemented. Also, the implementor must
|
||||
* listen for the "unmounted" signal on @mount and give up its
|
||||
* reference upon handling that signal.
|
||||
*
|
||||
* There are two main use cases for this function.
|
||||
*
|
||||
* One is when implementing a user space file system driver that reads
|
||||
* blocks of a block device that is already represented by the native
|
||||
* volume monitor (for example a CD Audio file system driver). Such
|
||||
* a driver will generate its own #GMount object that needs to be
|
||||
* associated with the #GVolume object that represents the volume.
|
||||
*
|
||||
* The other is for implementing a #GVolumeMonitor whose sole purpose
|
||||
* is to return #GVolume objects representing entries in the users
|
||||
* "favorite servers" list or similar.
|
||||
*
|
||||
* Returns: (transfer full): the #GVolume object that is the parent for @mount or %NULL
|
||||
* if no wants to adopt the #GMount.
|
||||
*
|
||||
* Deprecated: 2.20: Instead of using this function, #GVolumeMonitor
|
||||
* implementations should instead create shadow mounts with the URI of
|
||||
* the mount they intend to adopt. See the proxy volume monitor in
|
||||
* gvfs for an example of this. Also see g_mount_is_shadowed(),
|
||||
* g_mount_shadow() and g_mount_unshadow() functions.
|
||||
*/
|
||||
GVolume *
|
||||
g_volume_monitor_adopt_orphan_mount (GMount *mount)
|
||||
{
|
||||
GVolumeMonitor *child_monitor;
|
||||
GVolumeMonitorClass *child_monitor_class;
|
||||
GVolume *volume;
|
||||
GList *l;
|
||||
|
||||
g_return_val_if_fail (mount != NULL, NULL);
|
||||
|
||||
if (the_volume_monitor == NULL)
|
||||
return NULL;
|
||||
|
||||
volume = NULL;
|
||||
|
||||
g_rec_mutex_lock (&the_volume_monitor_mutex);
|
||||
|
||||
for (l = the_volume_monitor->monitors; l != NULL; l = l->next)
|
||||
{
|
||||
child_monitor = l->data;
|
||||
child_monitor_class = G_VOLUME_MONITOR_GET_CLASS (child_monitor);
|
||||
|
||||
if (child_monitor_class->adopt_orphan_mount != NULL)
|
||||
{
|
||||
volume = child_monitor_class->adopt_orphan_mount (mount, child_monitor);
|
||||
if (volume != NULL)
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
g_rec_mutex_unlock (&the_volume_monitor_mutex);
|
||||
|
||||
return volume;
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue