gio/gvolumemonitor.c

   1 /* GIO - GLib Input, Output and Streaming Library
   2  *
   3  * Copyright (C) 2006-2007 Red Hat, Inc.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General
  16  * Public License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  *
  20  * Author: Alexander Larsson <alexl@redhat.com>
  21  *         David Zeuthen <davidz@redhat.com>
  22  */
  23
  24 #include <config.h>
  25 #include "gvolumemonitor.h"
  26 #include "glibintl.h"
  27
  28 #include "gioalias.h"
  29
  30 /**
  31  * SECTION:gvolumemonitor
  32  * @short_description: Volume Monitor
  33  * @include: gio.h
  34  * @see_also: #GDirectoryMonitor, #GFileMonitor
  35  *
  36  * Monitors a mounted volume for changes.
  37  **/
  38
  39 G_DEFINE_TYPE (GVolumeMonitor, g_volume_monitor, G_TYPE_OBJECT);
  40
  41 enum {
  42   VOLUME_ADDED,
  43   VOLUME_REMOVED,
  44   VOLUME_CHANGED,
  45   MOUNT_ADDED,
  46   MOUNT_REMOVED,
  47   MOUNT_PRE_UNMOUNT,
  48   MOUNT_CHANGED,
  49   DRIVE_CONNECTED,
  50   DRIVE_DISCONNECTED,
  51   DRIVE_CHANGED,
  52   LAST_SIGNAL
  53 };
  54
  55 static guint signals[LAST_SIGNAL] = { 0 };
  56
  57
  58 static void
  59 g_volume_monitor_finalize (GObject *object)
  60 {
  61   GVolumeMonitor *monitor;
  62
  63   monitor = G_VOLUME_MONITOR (object);
  64
  65   if (G_OBJECT_CLASS (g_volume_monitor_parent_class)->finalize)
  66     (*G_OBJECT_CLASS (g_volume_monitor_parent_class)->finalize) (object);
  67 }
  68
  69 static void
  70 g_volume_monitor_class_init (GVolumeMonitorClass *klass)
  71 {
  72   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
  73
  74   gobject_class->finalize = g_volume_monitor_finalize;
  75
  76   /**
  77    * GVolumeMonitor::volume-added:
  78    * @volume_monitor: The volume monitor emitting the signal.
  79    * @volume: a #GVolume that was added.
  80    *
  81    * Emitted when a mountable volume is added to the system.
  82    **/
  83   signals[VOLUME_ADDED] = g_signal_new (I_("volume_added"),
  84                                         G_TYPE_VOLUME_MONITOR,
  85                                         G_SIGNAL_RUN_LAST,
  86                                         G_STRUCT_OFFSET (GVolumeMonitorClass, volume_added),
  87                                         NULL, NULL,
  88                                         g_cclosure_marshal_VOID__OBJECT,
  89                                         G_TYPE_NONE, 1, G_TYPE_VOLUME);
  90
  91   /**
  92    * GVolumeMonitor::volume-removed:
  93    * @volume_monitor: The volume monitor emitting the signal.
  94    * @volume: a #GVolume that was removed.
  95    *
  96    * Emitted when a mountable volume is removed from the system.
  97    **/
  98   signals[VOLUME_REMOVED] = g_signal_new (I_("volume_removed"),
  99                                           G_TYPE_VOLUME_MONITOR,
 100                                           G_SIGNAL_RUN_LAST,
 101                                           G_STRUCT_OFFSET (GVolumeMonitorClass, volume_removed),
 102                                           NULL, NULL,
 103                                           g_cclosure_marshal_VOID__OBJECT,
 104                                           G_TYPE_NONE, 1, G_TYPE_VOLUME);
 105
 106   /**
 107    * GVolumeMonitor::volume-changed:
 108    * @volume_monitor: The volume monitor emitting the signal.
 109    * @volume: a #GVolume that changed.
 110    *
 111    * Emitted when mountable volume is changed.
 112    **/
 113   signals[VOLUME_CHANGED] = g_signal_new (I_("volume_changed"),
 114                                           G_TYPE_VOLUME_MONITOR,
 115                                           G_SIGNAL_RUN_LAST,
 116                                           G_STRUCT_OFFSET (GVolumeMonitorClass, volume_changed),
 117                                           NULL, NULL,
 118                                           g_cclosure_marshal_VOID__OBJECT,
 119                                           G_TYPE_NONE, 1, G_TYPE_VOLUME);
 120
 121   /**
 122    * GVolumeMonitor::mount-added:
 123    * @volume_monitor: The volume monitor emitting the signal.
 124    * @mount: a #GMount that was added.
 125    *
 126    * Emitted when a mount is added.
 127    **/
 128   signals[MOUNT_ADDED] = g_signal_new (I_("mount_added"),
 129                                        G_TYPE_VOLUME_MONITOR,
 130                                        G_SIGNAL_RUN_LAST,
 131                                        G_STRUCT_OFFSET (GVolumeMonitorClass, mount_added),
 132                                        NULL, NULL,
 133                                        g_cclosure_marshal_VOID__OBJECT,
 134                                        G_TYPE_NONE, 1, G_TYPE_MOUNT);
 135
 136   /**
 137    * GVolumeMonitor::mount-removed:
 138    * @volume_monitor: The volume monitor emitting the signal.
 139    * @mount: a #GMount that was removed.
 140    *
 141    * Emitted when a mount is removed.
 142    **/
 143   signals[MOUNT_REMOVED] = g_signal_new (I_("mount_removed"),
 144                                          G_TYPE_VOLUME_MONITOR,
 145                                          G_SIGNAL_RUN_LAST,
 146                                          G_STRUCT_OFFSET (GVolumeMonitorClass, mount_removed),
 147                                          NULL, NULL,
 148                                          g_cclosure_marshal_VOID__OBJECT,
 149                                          G_TYPE_NONE, 1, G_TYPE_MOUNT);
 150
 151   /**
 152    * GVolumeMonitor::mount-pre-unmount:
 153    * @volume_monitor: The volume monitor emitting the signal.
 154    * @mount: a #GMount that is being unmounted.
 155    *
 156    * Emitted when a mount is about to be removed.
 157    **/
 158   signals[MOUNT_PRE_UNMOUNT] = g_signal_new (I_("mount_pre_unmount"),
 159                                              G_TYPE_VOLUME_MONITOR,
 160                                              G_SIGNAL_RUN_LAST,
 161                                              G_STRUCT_OFFSET (GVolumeMonitorClass, mount_pre_unmount),
 162                                              NULL, NULL,
 163                                              g_cclosure_marshal_VOID__OBJECT,
 164                                              G_TYPE_NONE, 1, G_TYPE_MOUNT);
 165
 166   /**
 167    * GVolumeMonitor::mount-changed:
 168    * @volume_monitor: The volume monitor emitting the signal.
 169    * @mount: a #GMount that changed.
 170    *
 171    * Emitted when a mount changes.
 172    **/
 173   signals[MOUNT_CHANGED] = g_signal_new (I_("mount_changed"),
 174                                          G_TYPE_VOLUME_MONITOR,
 175                                          G_SIGNAL_RUN_LAST,
 176                                          G_STRUCT_OFFSET (GVolumeMonitorClass, mount_changed),
 177                                          NULL, NULL,
 178                                          g_cclosure_marshal_VOID__OBJECT,
 179                                          G_TYPE_NONE, 1, G_TYPE_MOUNT);
 180
 181   /**
 182    * GVolumeMonitor::drive-connected:
 183    * @volume_monitor: The volume monitor emitting the signal.
 184    * @drive: a #GDrive that was connected.
 185    *
 186    * Emitted when a drive is connected to the system.
 187    **/
 188   signals[DRIVE_CONNECTED] = g_signal_new (I_("drive_connected"),
 189                                            G_TYPE_VOLUME_MONITOR,
 190                                            G_SIGNAL_RUN_LAST,
 191                                            G_STRUCT_OFFSET (GVolumeMonitorClass, drive_connected),
 192                                            NULL, NULL,
 193                                            g_cclosure_marshal_VOID__OBJECT,
 194                                            G_TYPE_NONE, 1, G_TYPE_DRIVE);
 195
 196   /**
 197    * GVolumeMonitor::drive-disconnected:
 198    * @volume_monitor: The volume monitor emitting the signal.
 199    * @drive: a #GDrive that was disconnected.
 200    *
 201    * Emitted when a drive is disconnected from the system.
 202    **/
 203   signals[DRIVE_DISCONNECTED] = g_signal_new (I_("drive_disconnected"),
 204                                               G_TYPE_VOLUME_MONITOR,
 205                                               G_SIGNAL_RUN_LAST,
 206                                               G_STRUCT_OFFSET (GVolumeMonitorClass, drive_disconnected),
 207                                               NULL, NULL,
 208                                               g_cclosure_marshal_VOID__OBJECT,
 209                                               G_TYPE_NONE, 1, G_TYPE_DRIVE);
 210
 211   /**
 212    * GVolumeMonitor::drive-changed:
 213    * @volume_monitor: The volume monitor emitting the signal.
 214    * @drive: the drive that changed
 215    *
 216    * Emitted when a drive changes.
 217    **/
 218   signals[DRIVE_CHANGED] = g_signal_new (I_("drive_changed"),
 219                                          G_TYPE_VOLUME_MONITOR,
 220                                          G_SIGNAL_RUN_LAST,
 221                                          G_STRUCT_OFFSET (GVolumeMonitorClass, drive_changed),
 222                                          NULL, NULL,
 223                                          g_cclosure_marshal_VOID__OBJECT,
 224                                          G_TYPE_NONE, 1, G_TYPE_DRIVE);
 225
 226 }
 227
 228 static void
 229 g_volume_monitor_init (GVolumeMonitor *monitor)
 230 {
 231 }
 232
 233
 234 /**
 235  * g_volume_monitor_get_connected_drives:
 236  * @volume_monitor: a #GVolumeMonitor.
 237  *
 238  * Gets a list of drives connected to the system.
 239  *
 240  * Returns: a #GList of connected #GDrives.
 241  **/
 242 GList *
 243 g_volume_monitor_get_connected_drives (GVolumeMonitor *volume_monitor)
 244 {
 245   GVolumeMonitorClass *class;
 246
 247   g_return_val_if_fail (G_IS_VOLUME_MONITOR (volume_monitor), NULL);
 248
 249   class = G_VOLUME_MONITOR_GET_CLASS (volume_monitor);
 250
 251   return class->get_connected_drives (volume_monitor);
 252 }
 253
 254 /**
 255  * g_volume_monitor_get_volumes:
 256  * @volume_monitor: a #GVolumeMonitor.
 257  *
 258  * Gets a list of the volumes on the system.
 259  *
 260  * Returns: a #GList of #GVolume.
 261  **/
 262 GList *
 263 g_volume_monitor_get_volumes (GVolumeMonitor *volume_monitor)
 264 {
 265   GVolumeMonitorClass *class;
 266
 267   g_return_val_if_fail (G_IS_VOLUME_MONITOR (volume_monitor), NULL);
 268
 269   class = G_VOLUME_MONITOR_GET_CLASS (volume_monitor);
 270
 271   return class->get_volumes (volume_monitor);
 272 }
 273
 274 /**
 275  * g_volume_monitor_get_mounts:
 276  * @volume_monitor: a #GVolumeMonitor.
 277  *
 278  * Gets a list of the mounts on the system.
 279  *
 280  * Returns: a #GList of #GMount.
 281  **/
 282 GList *
 283 g_volume_monitor_get_mounts (GVolumeMonitor *volume_monitor)
 284 {
 285   GVolumeMonitorClass *class;
 286
 287   g_return_val_if_fail (G_IS_VOLUME_MONITOR (volume_monitor), NULL);
 288
 289   class = G_VOLUME_MONITOR_GET_CLASS (volume_monitor);
 290
 291   return class->get_mounts (volume_monitor);
 292 }
 293
 294 /**
 295  * g_volume_monitor_get_volume_for_uuid:
 296  * @volume_monitor: a #GVolumeMonitor.
 297  *
 298  * Finds a #GVolume object by it's UUID (see g_volume_get_uuid())
 299  *
 300  * Returns: a #GVolume or %NULL if no such volume is available.
 301  **/
 302 GVolume *
 303 g_volume_monitor_get_volume_for_uuid   (GVolumeMonitor *volume_monitor,
 304                                         const char     *uuid)
 305 {
 306   GVolumeMonitorClass *class;
 307
 308   g_return_val_if_fail (G_IS_VOLUME_MONITOR (volume_monitor), NULL);
 309   g_return_val_if_fail (uuid != NULL, NULL);
 310
 311   class = G_VOLUME_MONITOR_GET_CLASS (volume_monitor);
 312
 313   return class->get_volume_for_uuid (volume_monitor, uuid);
 314 }
 315
 316 /**
 317  * g_volume_monitor_get_mount_for_uuid:
 318  * @volume_monitor: a #GVolumeMonitor.
 319  *
 320  * Finds a #GMount object by it's UUID (see g_mount_get_uuid())
 321  *
 322  * Returns: a #GMount or %NULL if no such mount is available.
 323  **/
 324 GMount *
 325 g_volume_monitor_get_mount_for_uuid   (GVolumeMonitor *volume_monitor,
 326                                        const char     *uuid)
 327 {
 328   GVolumeMonitorClass *class;
 329
 330   g_return_val_if_fail (G_IS_VOLUME_MONITOR (volume_monitor), NULL);
 331   g_return_val_if_fail (uuid != NULL, NULL);
 332
 333   class = G_VOLUME_MONITOR_GET_CLASS (volume_monitor);
 334
 335   return class->get_mount_for_uuid (volume_monitor, uuid);
 336 }
 337
 338
 339 #define __G_VOLUME_MONITOR_C__
 340 #include "gioaliasdef.c"