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: #GFileMonitor
  35  *
  36  * #GVolumeMonitor is for listing the user interesting devices and volumes
  37  * on the computer. In other words, what a file selector or file manager
  38  * would show in a sidebar.
  39 **/
  40
  41 G_DEFINE_TYPE (GVolumeMonitor, g_volume_monitor, G_TYPE_OBJECT);
  42
  43 enum {
  44   VOLUME_ADDED,
  45   VOLUME_REMOVED,
  46   VOLUME_CHANGED,
  47   MOUNT_ADDED,
  48   MOUNT_REMOVED,
  49   MOUNT_PRE_UNMOUNT,
  50   MOUNT_CHANGED,
  51   DRIVE_CONNECTED,
  52   DRIVE_DISCONNECTED,
  53   DRIVE_CHANGED,
  54   LAST_SIGNAL
  55 };
  56
  57 static guint signals[LAST_SIGNAL] = { 0 };
  58
  59
  60 static void
  61 g_volume_monitor_finalize (GObject *object)
  62 {
  63   GVolumeMonitor *monitor;
  64
  65   monitor = G_VOLUME_MONITOR (object);
  66
  67   if (G_OBJECT_CLASS (g_volume_monitor_parent_class)->finalize)
  68     (*G_OBJECT_CLASS (g_volume_monitor_parent_class)->finalize) (object);
  69 }
  70
  71 static void
  72 g_volume_monitor_class_init (GVolumeMonitorClass *klass)
  73 {
  74   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
  75
  76   gobject_class->finalize = g_volume_monitor_finalize;
  77
  78   /**
  79    * GVolumeMonitor::volume-added:
  80    * @volume_monitor: The volume monitor emitting the signal.
  81    * @volume: a #GVolume that was added.
  82    *
  83    * Emitted when a mountable volume is added to the system.
  84    **/
  85   signals[VOLUME_ADDED] = g_signal_new (I_("volume_added"),
  86                                         G_TYPE_VOLUME_MONITOR,
  87                                         G_SIGNAL_RUN_LAST,
  88                                         G_STRUCT_OFFSET (GVolumeMonitorClass, volume_added),
  89                                         NULL, NULL,
  90                                         g_cclosure_marshal_VOID__OBJECT,
  91                                         G_TYPE_NONE, 1, G_TYPE_VOLUME);
  92
  93   /**
  94    * GVolumeMonitor::volume-removed:
  95    * @volume_monitor: The volume monitor emitting the signal.
  96    * @volume: a #GVolume that was removed.
  97    *
  98    * Emitted when a mountable volume is removed from the system.
  99    **/
 100   signals[VOLUME_REMOVED] = g_signal_new (I_("volume_removed"),
 101                                           G_TYPE_VOLUME_MONITOR,
 102                                           G_SIGNAL_RUN_LAST,
 103                                           G_STRUCT_OFFSET (GVolumeMonitorClass, volume_removed),
 104                                           NULL, NULL,
 105                                           g_cclosure_marshal_VOID__OBJECT,
 106                                           G_TYPE_NONE, 1, G_TYPE_VOLUME);
 107
 108   /**
 109    * GVolumeMonitor::volume-changed:
 110    * @volume_monitor: The volume monitor emitting the signal.
 111    * @volume: a #GVolume that changed.
 112    *
 113    * Emitted when mountable volume is changed.
 114    **/
 115   signals[VOLUME_CHANGED] = g_signal_new (I_("volume_changed"),
 116                                           G_TYPE_VOLUME_MONITOR,
 117                                           G_SIGNAL_RUN_LAST,
 118                                           G_STRUCT_OFFSET (GVolumeMonitorClass, volume_changed),
 119                                           NULL, NULL,
 120                                           g_cclosure_marshal_VOID__OBJECT,
 121                                           G_TYPE_NONE, 1, G_TYPE_VOLUME);
 122
 123   /**
 124    * GVolumeMonitor::mount-added:
 125    * @volume_monitor: The volume monitor emitting the signal.
 126    * @mount: a #GMount that was added.
 127    *
 128    * Emitted when a mount is added.
 129    **/
 130   signals[MOUNT_ADDED] = g_signal_new (I_("mount_added"),
 131                                        G_TYPE_VOLUME_MONITOR,
 132                                        G_SIGNAL_RUN_LAST,
 133                                        G_STRUCT_OFFSET (GVolumeMonitorClass, mount_added),
 134                                        NULL, NULL,
 135                                        g_cclosure_marshal_VOID__OBJECT,
 136                                        G_TYPE_NONE, 1, G_TYPE_MOUNT);
 137
 138   /**
 139    * GVolumeMonitor::mount-removed:
 140    * @volume_monitor: The volume monitor emitting the signal.
 141    * @mount: a #GMount that was removed.
 142    *
 143    * Emitted when a mount is removed.
 144    **/
 145   signals[MOUNT_REMOVED] = g_signal_new (I_("mount_removed"),
 146                                          G_TYPE_VOLUME_MONITOR,
 147                                          G_SIGNAL_RUN_LAST,
 148                                          G_STRUCT_OFFSET (GVolumeMonitorClass, mount_removed),
 149                                          NULL, NULL,
 150                                          g_cclosure_marshal_VOID__OBJECT,
 151                                          G_TYPE_NONE, 1, G_TYPE_MOUNT);
 152
 153   /**
 154    * GVolumeMonitor::mount-pre-unmount:
 155    * @volume_monitor: The volume monitor emitting the signal.
 156    * @mount: a #GMount that is being unmounted.
 157    *
 158    * Emitted when a mount is about to be removed.
 159    **/
 160   signals[MOUNT_PRE_UNMOUNT] = g_signal_new (I_("mount_pre_unmount"),
 161                                              G_TYPE_VOLUME_MONITOR,
 162                                              G_SIGNAL_RUN_LAST,
 163                                              G_STRUCT_OFFSET (GVolumeMonitorClass, mount_pre_unmount),
 164                                              NULL, NULL,
 165                                              g_cclosure_marshal_VOID__OBJECT,
 166                                              G_TYPE_NONE, 1, G_TYPE_MOUNT);
 167
 168   /**
 169    * GVolumeMonitor::mount-changed:
 170    * @volume_monitor: The volume monitor emitting the signal.
 171    * @mount: a #GMount that changed.
 172    *
 173    * Emitted when a mount changes.
 174    **/
 175   signals[MOUNT_CHANGED] = g_signal_new (I_("mount_changed"),
 176                                          G_TYPE_VOLUME_MONITOR,
 177                                          G_SIGNAL_RUN_LAST,
 178                                          G_STRUCT_OFFSET (GVolumeMonitorClass, mount_changed),
 179                                          NULL, NULL,
 180                                          g_cclosure_marshal_VOID__OBJECT,
 181                                          G_TYPE_NONE, 1, G_TYPE_MOUNT);
 182
 183   /**
 184    * GVolumeMonitor::drive-connected:
 185    * @volume_monitor: The volume monitor emitting the signal.
 186    * @drive: a #GDrive that was connected.
 187    *
 188    * Emitted when a drive is connected to the system.
 189    **/
 190   signals[DRIVE_CONNECTED] = g_signal_new (I_("drive_connected"),
 191                                            G_TYPE_VOLUME_MONITOR,
 192                                            G_SIGNAL_RUN_LAST,
 193                                            G_STRUCT_OFFSET (GVolumeMonitorClass, drive_connected),
 194                                            NULL, NULL,
 195                                            g_cclosure_marshal_VOID__OBJECT,
 196                                            G_TYPE_NONE, 1, G_TYPE_DRIVE);
 197
 198   /**
 199    * GVolumeMonitor::drive-disconnected:
 200    * @volume_monitor: The volume monitor emitting the signal.
 201    * @drive: a #GDrive that was disconnected.
 202    *
 203    * Emitted when a drive is disconnected from the system.
 204    **/
 205   signals[DRIVE_DISCONNECTED] = g_signal_new (I_("drive_disconnected"),
 206                                               G_TYPE_VOLUME_MONITOR,
 207                                               G_SIGNAL_RUN_LAST,
 208                                               G_STRUCT_OFFSET (GVolumeMonitorClass, drive_disconnected),
 209                                               NULL, NULL,
 210                                               g_cclosure_marshal_VOID__OBJECT,
 211                                               G_TYPE_NONE, 1, G_TYPE_DRIVE);
 212
 213   /**
 214    * GVolumeMonitor::drive-changed:
 215    * @volume_monitor: The volume monitor emitting the signal.
 216    * @drive: the drive that changed
 217    *
 218    * Emitted when a drive changes.
 219    **/
 220   signals[DRIVE_CHANGED] = g_signal_new (I_("drive_changed"),
 221                                          G_TYPE_VOLUME_MONITOR,
 222                                          G_SIGNAL_RUN_LAST,
 223                                          G_STRUCT_OFFSET (GVolumeMonitorClass, drive_changed),
 224                                          NULL, NULL,
 225                                          g_cclosure_marshal_VOID__OBJECT,
 226                                          G_TYPE_NONE, 1, G_TYPE_DRIVE);
 227
 228 }
 229
 230 static void
 231 g_volume_monitor_init (GVolumeMonitor *monitor)
 232 {
 233 }
 234
 235
 236 /**
 237  * g_volume_monitor_get_connected_drives:
 238  * @volume_monitor: a #GVolumeMonitor.
 239  *
 240  * Gets a list of drives connected to the system.
 241  *
 242  * Returns: a #GList of connected #GDrives.
 243  **/
 244 GList *
 245 g_volume_monitor_get_connected_drives (GVolumeMonitor *volume_monitor)
 246 {
 247   GVolumeMonitorClass *class;
 248
 249   g_return_val_if_fail (G_IS_VOLUME_MONITOR (volume_monitor), NULL);
 250
 251   class = G_VOLUME_MONITOR_GET_CLASS (volume_monitor);
 252
 253   return class->get_connected_drives (volume_monitor);
 254 }
 255
 256 /**
 257  * g_volume_monitor_get_volumes:
 258  * @volume_monitor: a #GVolumeMonitor.
 259  *
 260  * Gets a list of the volumes on the system.
 261  *
 262  * Returns: a #GList of #GVolume.
 263  **/
 264 GList *
 265 g_volume_monitor_get_volumes (GVolumeMonitor *volume_monitor)
 266 {
 267   GVolumeMonitorClass *class;
 268
 269   g_return_val_if_fail (G_IS_VOLUME_MONITOR (volume_monitor), NULL);
 270
 271   class = G_VOLUME_MONITOR_GET_CLASS (volume_monitor);
 272
 273   return class->get_volumes (volume_monitor);
 274 }
 275
 276 /**
 277  * g_volume_monitor_get_mounts:
 278  * @volume_monitor: a #GVolumeMonitor.
 279  *
 280  * Gets a list of the mounts on the system.
 281  *
 282  * Returns: a #GList of #GMount.
 283  **/
 284 GList *
 285 g_volume_monitor_get_mounts (GVolumeMonitor *volume_monitor)
 286 {
 287   GVolumeMonitorClass *class;
 288
 289   g_return_val_if_fail (G_IS_VOLUME_MONITOR (volume_monitor), NULL);
 290
 291   class = G_VOLUME_MONITOR_GET_CLASS (volume_monitor);
 292
 293   return class->get_mounts (volume_monitor);
 294 }
 295
 296 /**
 297  * g_volume_monitor_get_volume_for_uuid:
 298  * @volume_monitor: a #GVolumeMonitor.
 299  * @uuid: the UUID to look for
 300  *
 301  * Finds a #GVolume object by it's UUID (see g_volume_get_uuid())
 302  *
 303  * Returns: a #GVolume or %NULL if no such volume is available.
 304  **/
 305 GVolume *
 306 g_volume_monitor_get_volume_for_uuid   (GVolumeMonitor *volume_monitor,
 307                                         const char     *uuid)
 308 {
 309   GVolumeMonitorClass *class;
 310
 311   g_return_val_if_fail (G_IS_VOLUME_MONITOR (volume_monitor), NULL);
 312   g_return_val_if_fail (uuid != NULL, NULL);
 313
 314   class = G_VOLUME_MONITOR_GET_CLASS (volume_monitor);
 315
 316   return class->get_volume_for_uuid (volume_monitor, uuid);
 317 }
 318
 319 /**
 320  * g_volume_monitor_get_mount_for_uuid:
 321  * @volume_monitor: a #GVolumeMonitor.
 322  * @uuid: the UUID to look for
 323  *
 324  * Finds a #GMount object by it's UUID (see g_mount_get_uuid())
 325  *
 326  * Returns: a #GMount or %NULL if no such mount is available.
 327  **/
 328 GMount *
 329 g_volume_monitor_get_mount_for_uuid   (GVolumeMonitor *volume_monitor,
 330                                        const char     *uuid)
 331 {
 332   GVolumeMonitorClass *class;
 333
 334   g_return_val_if_fail (G_IS_VOLUME_MONITOR (volume_monitor), NULL);
 335   g_return_val_if_fail (uuid != NULL, NULL);
 336
 337   class = G_VOLUME_MONITOR_GET_CLASS (volume_monitor);
 338
 339   return class->get_mount_for_uuid (volume_monitor, uuid);
 340 }
 341
 342
 343 #define __G_VOLUME_MONITOR_C__
 344 #include "gioaliasdef.c"