gdrive.c 12.9 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/* 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 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, write to the
 * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA 02111-1307, USA.
 *
 * Author: Alexander Larsson <alexl@redhat.com>
21
 *         David Zeuthen <davidz@redhat.com>
22
23
 */

24
#include "config.h"
25
26
#include "gdrive.h"
#include "gsimpleasyncresult.h"
27
28
#include "gasyncresult.h"
#include "gioerror.h"
29
30
#include "glibintl.h"

31
32
#include "gioalias.h"

33
34
/**
 * SECTION:gdrive
35
 * @short_description: Virtual File System drive management
Matthias Clasen's avatar
Matthias Clasen committed
36
 * @include: gio/gio.h
37
 * 
38
39
40
41
 * #GDrive - this represent a piece of hardware connected to the machine.
 * Its generally only created for removable hardware or hardware with
 * removable media. 
 *
42
43
44
45
46
47
48
49
50
51
52
53
54
 * #GDrive is a container class for #GVolume objects that stem from
 * the same piece of media. As such, #GDrive abstracts a drive with
 * (or without) removable media and provides operations for querying
 * whether media is available, determing whether media change is
 * automatically detected and ejecting the media.
 *
 * If the #GDrive reports that media isn't automatically detected, one
 * can poll for media; typically one should not do this periodically
 * as a poll for media operation is potententially expensive and may
 * spin up the drive creating noise.
 *
 * For porting from GnomeVFS note that there is no equivalent of
 * #GDrive in that API.
55
56
 **/

57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
static void g_drive_base_init (gpointer g_class);
static void g_drive_class_init (gpointer g_class,
				 gpointer class_data);

GType
g_drive_get_type (void)
{
  static GType drive_type = 0;

  if (! drive_type)
    {
      static const GTypeInfo drive_info =
      {
        sizeof (GDriveIface), /* class_size */
	g_drive_base_init,   /* base_init */
	NULL,		/* base_finalize */
	g_drive_class_init,
	NULL,		/* class_finalize */
	NULL,		/* class_data */
	0,
	0,              /* n_preallocs */
	NULL
      };

      drive_type =
	g_type_register_static (G_TYPE_INTERFACE, I_("GDrive"),
				&drive_info, 0);

      g_type_interface_add_prerequisite (drive_type, G_TYPE_OBJECT);
    }

  return drive_type;
}

static void
g_drive_class_init (gpointer g_class,
Matthias Clasen's avatar
Matthias Clasen committed
93
                    gpointer class_data)
94
95
96
97
98
99
100
101
102
103
{
}

static void
g_drive_base_init (gpointer g_class)
{
  static gboolean initialized = FALSE;

  if (! initialized)
    {
104
105
      /**
      * GDrive::changed:
106
      * @drive: a #GDrive.
107
108
109
      * 
      * Emitted when the drive's state has changed.
      **/
110
111
112
113
114
115
116
117
      g_signal_new (I_("changed"),
                    G_TYPE_DRIVE,
                    G_SIGNAL_RUN_LAST,
                    G_STRUCT_OFFSET (GDriveIface, changed),
                    NULL, NULL,
                    g_cclosure_marshal_VOID__VOID,
                    G_TYPE_NONE, 0);

118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
      /**
      * GDrive::disconnected:
      * @drive: a #GDrive.
      * 
      * This signal is emitted when the #GDrive have been
      * disconnected. If the recipient is holding references to the
      * object they should release them so the object can be
      * finalized.
      **/
      g_signal_new (I_("disconnected"),
                    G_TYPE_DRIVE,
                    G_SIGNAL_RUN_LAST,
                    G_STRUCT_OFFSET (GDriveIface, disconnected),
                    NULL, NULL,
                    g_cclosure_marshal_VOID__VOID,
                    G_TYPE_NONE, 0);

      /**
      * GDrive::eject-button:
      * @drive: a #GDrive.
      * 
      * Emitted when the physical eject button (if any) of a drive have been pressed.
      * 
      **/
      g_signal_new (I_("eject-button"),
                    G_TYPE_DRIVE,
                    G_SIGNAL_RUN_LAST,
                    G_STRUCT_OFFSET (GDriveIface, eject_button),
                    NULL, NULL,
                    g_cclosure_marshal_VOID__VOID,
                    G_TYPE_NONE, 0);

150
151
152
153
154
155
156
157
      initialized = TRUE;
    }
}

/**
 * g_drive_get_name:
 * @drive: a #GDrive.
 * 
Matthias Clasen's avatar
Matthias Clasen committed
158
 * Gets the name of @drive.
159
 *
Matthias Clasen's avatar
Matthias Clasen committed
160
161
 * Returns: a string containing @drive's name. The returned 
 *     string should be freed when no longer needed.
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
 **/
char *
g_drive_get_name (GDrive *drive)
{
  GDriveIface *iface;

  g_return_val_if_fail (G_IS_DRIVE (drive), NULL);

  iface = G_DRIVE_GET_IFACE (drive);

  return (* iface->get_name) (drive);
}

/**
 * g_drive_get_icon:
 * @drive: a #GDrive.
 * 
 * Gets the icon for @drive.
 * 
 * Returns: #GIcon for the @drive.
 **/
GIcon *
g_drive_get_icon (GDrive *drive)
{
  GDriveIface *iface;
  
  g_return_val_if_fail (G_IS_DRIVE (drive), NULL);

  iface = G_DRIVE_GET_IFACE (drive);

  return (* iface->get_icon) (drive);
}

/**
 * g_drive_has_volumes:
 * @drive: a #GDrive.
 * 
199
 * Check if @drive has any mountable volumes.
200
 * 
201
 * Returns: %TRUE if the @drive contains volumes, %FALSE otherwise.
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
 **/
gboolean
g_drive_has_volumes (GDrive *drive)
{
  GDriveIface *iface;

  g_return_val_if_fail (G_IS_DRIVE (drive), FALSE);

  iface = G_DRIVE_GET_IFACE (drive);

  return (* iface->has_volumes) (drive);
}

/**
 * g_drive_get_volumes:
 * @drive: a #GDrive.
 * 
219
 * Get a list of mountable volumes for @drive.
Matthias Clasen's avatar
Matthias Clasen committed
220
221
222
 *
 * The returned list should be freed with g_list_free(), after
 * its elements have been unreffed with g_object_unref().
223
224
 * 
 * Returns: #GList containing any #GVolume<!---->s on the given @drive.
225
226
227
228
229
230
231
232
233
234
235
236
237
238
 **/
GList *
g_drive_get_volumes (GDrive *drive)
{
  GDriveIface *iface;

  g_return_val_if_fail (G_IS_DRIVE (drive), NULL);

  iface = G_DRIVE_GET_IFACE (drive);

  return (* iface->get_volumes) (drive);
}

/**
239
 * g_drive_is_media_check_automatic:
240
241
 * @drive: a #GDrive.
 * 
242
 * Checks if @drive is capabable of automatically detecting media changes.
243
 * 
244
 * Returns: %TRUE if the @drive is capabable of automatically detecting media changes, %FALSE otherwise.
245
246
 **/
gboolean
247
g_drive_is_media_check_automatic (GDrive *drive)
248
249
250
251
252
253
254
{
  GDriveIface *iface;

  g_return_val_if_fail (G_IS_DRIVE (drive), FALSE);

  iface = G_DRIVE_GET_IFACE (drive);

255
  return (* iface->is_media_check_automatic) (drive);
256
257
258
}

/**
259
 * g_drive_is_media_removable:
260
261
 * @drive: a #GDrive.
 * 
262
 * Checks if the @drive supports removable media.
263
 * 
264
 * Returns: %TRUE if @drive supports removable media, %FALSE otherwise.
265
266
 **/
gboolean
267
g_drive_is_media_removable (GDrive *drive)
268
269
270
271
272
273
274
{
  GDriveIface *iface;

  g_return_val_if_fail (G_IS_DRIVE (drive), FALSE);

  iface = G_DRIVE_GET_IFACE (drive);

275
276
  return (* iface->is_media_removable) (drive);
}
277

278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
/**
 * g_drive_has_media:
 * @drive: a #GDrive.
 * 
 * Checks if the @drive has media. Note that the OS may not be polling
 * the drive for media changes; see g_drive_is_media_check_automatic()
 * for more details.
 * 
 * Returns: %TRUE if @drive has media, %FALSE otherwise.
 **/
gboolean
g_drive_has_media (GDrive *drive)
{
  GDriveIface *iface;

  g_return_val_if_fail (G_IS_DRIVE (drive), FALSE);

  iface = G_DRIVE_GET_IFACE (drive);

  return (* iface->has_media) (drive);
298
299
300
301
302
303
}

/**
 * g_drive_can_eject:
 * @drive: pointer to a #GDrive.
 * 
304
305
 * Checks if a drive can be ejected.
 * 
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
 * Returns: %TRUE if the @drive can be ejected. %FALSE otherwise.
 **/
gboolean
g_drive_can_eject (GDrive *drive)
{
  GDriveIface *iface;

  g_return_val_if_fail (G_IS_DRIVE (drive), FALSE);

  iface = G_DRIVE_GET_IFACE (drive);

  if (iface->can_eject == NULL)
    return FALSE;

  return (* iface->can_eject) (drive);
}

/**
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
 * g_drive_can_poll_for_media:
 * @drive: a #GDrive.
 * 
 * Checks if a drive can be polled for media changes.
 * 
 * Returns: %TRUE if the @drive can be polled for media changes. %FALSE otherwise.
 **/
gboolean
g_drive_can_poll_for_media (GDrive *drive)
{
  GDriveIface *iface;

  g_return_val_if_fail (G_IS_DRIVE (drive), FALSE);

  iface = G_DRIVE_GET_IFACE (drive);

  if (iface->poll_for_media == NULL)
    return FALSE;

  return (* iface->can_poll_for_media) (drive);
}

/**
 * g_drive_eject:
348
 * @drive: a #GDrive.
349
 * @flags: flags affecting the unmount if required for eject
350
 * @cancellable: optional #GCancellable object, %NULL to ignore.
351
 * @callback: a #GAsyncReadyCallback, or %NULL.
352
353
 * @user_data: a #gpointer.
 * 
354
355
 * Ejects a drive.
 * 
356
357
 **/
void
358
g_drive_eject (GDrive              *drive,
359
	       GMountUnmountFlags   flags,
Matthias Clasen's avatar
Matthias Clasen committed
360
361
362
	       GCancellable        *cancellable,
	       GAsyncReadyCallback  callback,
	       gpointer             user_data)
363
364
365
366
367
368
369
{
  GDriveIface *iface;

  g_return_if_fail (G_IS_DRIVE (drive));

  iface = G_DRIVE_GET_IFACE (drive);

370
  if (iface->eject == NULL)
371
372
373
    {
      g_simple_async_report_error_in_idle (G_OBJECT (drive), callback, user_data,
					   G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
374
					   _("drive doesn't implement eject"));
375
376
377
378
      
      return;
    }
  
379
  (* iface->eject) (drive, flags, cancellable, callback, user_data);
380
381
382
}

/**
383
 * g_drive_eject_finish
384
 * @drive: a #GDrive.
385
386
387
 * @result: a #GAsyncResult.
 * @error: a #GError.
 * 
388
 * Finishes ejecting a drive.
389
 * 
390
391
 * Returns: %TRUE if the drive has been ejected successfully,
 * %FALSE otherwise.
392
393
 **/
gboolean
394
g_drive_eject_finish (GDrive        *drive,
Matthias Clasen's avatar
Matthias Clasen committed
395
396
		      GAsyncResult  *result,
		      GError       **error)
397
398
399
400
401
402
403
404
405
406
407
408
409
410
{
  GDriveIface *iface;

  g_return_val_if_fail (G_IS_DRIVE (drive), FALSE);
  g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);

  if (G_IS_SIMPLE_ASYNC_RESULT (result))
    {
      GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
      if (g_simple_async_result_propagate_error (simple, error))
	return FALSE;
    }
  
  iface = G_DRIVE_GET_IFACE (drive);
411
412
  
  return (* iface->eject_finish) (drive, result, error);
413
414
415
}

/**
416
 * g_drive_poll_for_media:
417
 * @drive: a #GDrive.
418
 * @cancellable: optional #GCancellable object, %NULL to ignore.
419
 * @callback: a #GAsyncReadyCallback, or %NULL.
420
421
 * @user_data: a #gpointer.
 * 
422
 * Polls @drive to see if media has been inserted or removed.
423
 * 
424
425
 **/
void
426
427
428
429
g_drive_poll_for_media (GDrive              *drive,
                        GCancellable        *cancellable,
                        GAsyncReadyCallback  callback,
                        gpointer             user_data)
430
431
432
433
434
435
436
{
  GDriveIface *iface;

  g_return_if_fail (G_IS_DRIVE (drive));

  iface = G_DRIVE_GET_IFACE (drive);

437
  if (iface->poll_for_media == NULL)
438
439
440
    {
      g_simple_async_report_error_in_idle (G_OBJECT (drive), callback, user_data,
					   G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
441
					   _("drive doesn't implement polling for media"));
442
443
444
445
      
      return;
    }
  
446
  (* iface->poll_for_media) (drive, cancellable, callback, user_data);
447
448
449
}

/**
450
 * g_drive_poll_for_media_finish
451
452
453
454
 * @drive: a #GDrive.
 * @result: a #GAsyncResult.
 * @error: a #GError.
 * 
455
 * Finishes poll_for_mediaing a drive.
456
 * 
457
 * Returns: %TRUE if the drive has been poll_for_mediaed successfully,
458
459
460
 * %FALSE otherwise.
 **/
gboolean
461
462
463
g_drive_poll_for_media_finish (GDrive        *drive,
                               GAsyncResult  *result,
                               GError       **error)
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
{
  GDriveIface *iface;

  g_return_val_if_fail (G_IS_DRIVE (drive), FALSE);
  g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);

  if (G_IS_SIMPLE_ASYNC_RESULT (result))
    {
      GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
      if (g_simple_async_result_propagate_error (simple, error))
	return FALSE;
    }
  
  iface = G_DRIVE_GET_IFACE (drive);
  
479
  return (* iface->poll_for_media_finish) (drive, result, error);
480
}
481

Matthias Clasen's avatar
Matthias Clasen committed
482
483
484
485
486
487
488
489
490
491
492
/**
 * g_drive_get_identifier:
 * @drive: a #GDrive
 * @kind: the kind of identifier to return
 *
 * Gets the identifier of the given kind for @drive.
 *
 * Returns: a newly allocated string containing the
 *   requested identfier, or %NULL if the #GDrive
 *   doesn't have this kind of identifier
 */
493
char *
Matthias Clasen's avatar
Matthias Clasen committed
494
495
g_drive_get_identifier (GDrive     *drive,
			const char *kind)
496
497
498
499
500
501
502
503
504
505
506
507
508
509
{
  GDriveIface *iface;

  g_return_val_if_fail (G_IS_DRIVE (drive), NULL);
  g_return_val_if_fail (kind != NULL, NULL);

  iface = G_DRIVE_GET_IFACE (drive);

  if (iface->get_identifier == NULL)
    return NULL;
  
  return (* iface->get_identifier) (drive, kind);
}

Matthias Clasen's avatar
Matthias Clasen committed
510
511
512
513
514
515
516
517
518
519
520
/**
 * g_drive_enumerate_identifiers:
 * @drive: a #GDrive
 *
 * Gets the kinds of identifiers that @drive has. 
 * Use g_drive_get_identifer() to obtain the identifiers
 * themselves.
 *
 * Returns: a %NULL-terminated array of strings containing
 *   kinds of identifiers. Use g_strfreev() to free.
 */
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
char **
g_drive_enumerate_identifiers (GDrive *drive)
{
  GDriveIface *iface;

  g_return_val_if_fail (G_IS_DRIVE (drive), NULL);
  iface = G_DRIVE_GET_IFACE (drive);

  if (iface->enumerate_identifiers == NULL)
    return NULL;
  
  return (* iface->enumerate_identifiers) (drive);
}


536
537
#define __G_DRIVE_C__
#include "gioaliasdef.c"