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