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  * The returned list should be freed with g_list_free(), but
 243  * its elements need not be freed.
 244  *
 245  * Returns: a #GList of connected #GDrives - free with g_list_free().
 246  **/
 247 GList *
 248 g_volume_monitor_get_connected_drives (GVolumeMonitor *volume_monitor)
 249 {
 250   GVolumeMonitorClass *class;
 251
 252   g_return_val_if_fail (G_IS_VOLUME_MONITOR (volume_monitor), NULL);
 253
 254   class = G_VOLUME_MONITOR_GET_CLASS (volume_monitor);
 255
 256   return class->get_connected_drives (volume_monitor);
 257 }
 258
 259 /**
 260  * g_volume_monitor_get_volumes:
 261  * @volume_monitor: a #GVolumeMonitor.
 262  *
 263  * Gets a list of the volumes on the system.
 264  *
 265  * The returned list should be freed with g_list_free(), but
 266  * its elements need not be freed.
 267  *
 268  * Returns: a #GList of #GVolume - free with g_list_free().
 269  **/
 270 GList *
 271 g_volume_monitor_get_volumes (GVolumeMonitor *volume_monitor)
 272 {
 273   GVolumeMonitorClass *class;
 274
 275   g_return_val_if_fail (G_IS_VOLUME_MONITOR (volume_monitor), NULL);
 276
 277   class = G_VOLUME_MONITOR_GET_CLASS (volume_monitor);
 278
 279   return class->get_volumes (volume_monitor);
 280 }
 281
 282 /**
 283  * g_volume_monitor_get_mounts:
 284  * @volume_monitor: a #GVolumeMonitor.
 285  *
 286  * Gets a list of the mounts on the system.
 287  *
 288  * The returned list should be freed with g_list_free(), but
 289  * its elements need not be freed.
 290  *
 291  * Returns: a #GList of #GMount - free with g_list_free().
 292  **/
 293 GList *
 294 g_volume_monitor_get_mounts (GVolumeMonitor *volume_monitor)
 295 {
 296   GVolumeMonitorClass *class;
 297
 298   g_return_val_if_fail (G_IS_VOLUME_MONITOR (volume_monitor), NULL);
 299
 300   class = G_VOLUME_MONITOR_GET_CLASS (volume_monitor);
 301
 302   return class->get_mounts (volume_monitor);
 303 }
 304
 305 /**
 306  * g_volume_monitor_get_volume_for_uuid:
 307  * @volume_monitor: a #GVolumeMonitor.
 308  * @uuid: the UUID to look for
 309  *
 310  * Finds a #GVolume object by it's UUID (see g_volume_get_uuid())
 311  *
 312  * Returns: a #GVolume or %NULL if no such volume is available.
 313  **/
 314 GVolume *
 315 g_volume_monitor_get_volume_for_uuid   (GVolumeMonitor *volume_monitor,
 316                                         const char     *uuid)
 317 {
 318   GVolumeMonitorClass *class;
 319
 320   g_return_val_if_fail (G_IS_VOLUME_MONITOR (volume_monitor), NULL);
 321   g_return_val_if_fail (uuid != NULL, NULL);
 322
 323   class = G_VOLUME_MONITOR_GET_CLASS (volume_monitor);
 324
 325   return class->get_volume_for_uuid (volume_monitor, uuid);
 326 }
 327
 328 /**
 329  * g_volume_monitor_get_mount_for_uuid:
 330  * @volume_monitor: a #GVolumeMonitor.
 331  * @uuid: the UUID to look for
 332  *
 333  * Finds a #GMount object by it's UUID (see g_mount_get_uuid())
 334  *
 335  * Returns: a #GMount or %NULL if no such mount is available.
 336  **/
 337 GMount *
 338 g_volume_monitor_get_mount_for_uuid   (GVolumeMonitor *volume_monitor,
 339                                        const char     *uuid)
 340 {
 341   GVolumeMonitorClass *class;
 342
 343   g_return_val_if_fail (G_IS_VOLUME_MONITOR (volume_monitor), NULL);
 344   g_return_val_if_fail (uuid != NULL, NULL);
 345
 346   class = G_VOLUME_MONITOR_GET_CLASS (volume_monitor);
 347
 348   return class->get_mount_for_uuid (volume_monitor, uuid);
 349 }
 350
 351
 352 #define __G_VOLUME_MONITOR_C__
 353 #include "gioaliasdef.c"