## BraseroDrive

BraseroDrive

## Synopsis

    enum                BraseroDriveCaps;
    void                brasero_drive_reprobe               (BraseroDrive *drive);
    BraseroMedium *     brasero_drive_get_medium            (BraseroDrive *drive);
    GDrive *            brasero_drive_get_gdrive            (BraseroDrive *drive);
    const gchar *       brasero_drive_get_udi               (BraseroDrive *drive);
    gboolean            brasero_drive_is_fake               (BraseroDrive *drive);
    gchar *             brasero_drive_get_display_name      (BraseroDrive *drive);
    const gchar *       brasero_drive_get_device            (BraseroDrive *drive);
    const gchar *       brasero_drive_get_block_device      (BraseroDrive *drive);
    gchar *             brasero_drive_get_bus_target_lun_string
                                                            (BraseroDrive *drive);
    BraseroDriveCaps    brasero_drive_get_caps              (BraseroDrive *drive);
    gboolean            brasero_drive_can_write             (BraseroDrive *drive);
    gboolean            brasero_drive_can_eject             (BraseroDrive *drive);
    gboolean            brasero_drive_eject                 (BraseroDrive *drive,
                                                             gboolean wait,
                                                             GError **error);
    gboolean            brasero_drive_is_door_open          (BraseroDrive *drive);
    gboolean            brasero_drive_can_use_exclusively   (BraseroDrive *drive);
    gboolean            brasero_drive_lock                  (BraseroDrive *drive,
                                                             const gchar *reason,
                                                             gchar **reason_for_failure);
    gboolean            brasero_drive_unlock                (BraseroDrive *drive);

## Description

## Details

### enum BraseroDriveCaps

    typedef enum {
    	BRASERO_DRIVE_CAPS_NONE			= 0,
    	BRASERO_DRIVE_CAPS_CDR			= 1,
    	BRASERO_DRIVE_CAPS_CDRW			= 1 << 1,
    	BRASERO_DRIVE_CAPS_DVDR			= 1 << 2,
    	BRASERO_DRIVE_CAPS_DVDRW		= 1 << 3,
    	BRASERO_DRIVE_CAPS_DVDR_PLUS		= 1 << 4,
    	BRASERO_DRIVE_CAPS_DVDRW_PLUS		= 1 << 5,
    	BRASERO_DRIVE_CAPS_DVDR_PLUS_DL		= 1 << 6,
    	BRASERO_DRIVE_CAPS_DVDRW_PLUS_DL	= 1 << 7,
    	BRASERO_DRIVE_CAPS_DVDRAM		= 1 << 9,
    	BRASERO_DRIVE_CAPS_BDR			= 1 << 8,
    	BRASERO_DRIVE_CAPS_BDRW			= 1 << 9
    } BraseroDriveCaps;

### brasero_drive_reprobe ()

    void                brasero_drive_reprobe               (BraseroDrive *drive);

Reprobes the drive contents. Useful when an operation has just been performed (blanking, burning, ...) and medium status should be updated.

NOTE: This operation does not block.

`drive` : | a BraseroDrive

### brasero_drive_get_medium ()

    BraseroMedium *     brasero_drive_get_medium            (BraseroDrive *drive);

Gets the medium currently inserted in the drive. If there is no medium or if the medium is not probed yet then it returns NULL.

`drive` : | a BraseroDrive
Returns : | a BraseroMedium object or NULL. No need to unref after use.

### brasero_drive_get_gdrive ()

    GDrive *            brasero_drive_get_gdrive            (BraseroDrive *drive);

Returns the GDrive corresponding to this BraseroDrive

`drive` : | a BraseroDrive
Returns : | a GDrive or NULL. Unref after use.

### brasero_drive_get_udi ()

    const gchar *       brasero_drive_get_udi               (BraseroDrive *drive);

Gets a string holding the HAL udi corresponding to this device. It can be used to uniquely identify the drive.

`drive` : | a BraseroDrive
Returns : | a string holding the HAL udi. Not to be freed

### brasero_drive_is_fake ()

    gboolean            brasero_drive_is_fake               (BraseroDrive *drive);

Returns whether or not the drive is a fake one. There is only one and corresponds to a file which is used when the user wants to burn to a file.

`drive` : | a BraseroDrive
Returns : | `TRUE` or `FALSE`.

### brasero_drive_get_display_name ()

    gchar *             brasero_drive_get_display_name      (BraseroDrive *drive);

Gets a string holding the name for the drive. That string can be then displayed in a user interface.

`drive` : | a BraseroDrive
Returns : | a string holding the name

### brasero_drive_get_device ()

    const gchar *       brasero_drive_get_device            (BraseroDrive *drive);

Gets a string holding the device path for the drive.

`drive` : | a BraseroDrive
Returns : | a string holding the device path

### brasero_drive_get_block_device ()

    const gchar *       brasero_drive_get_block_device      (BraseroDrive *drive);

Gets a string holding the block device path for the drive. This can be used on some other OS, like Solaris, for burning operations instead of the device path.

`drive` : | a BraseroDrive
Returns : | a string holding the block device path

### brasero_drive_get_bus_target_lun_string ()

    gchar *             brasero_drive_get_bus_target_lun_string
                                                            (BraseroDrive *drive);

Returns the bus, target, lun ("{bus},{target},{lun}") as a string which is sometimes needed by some backends like cdrecord.

`drive` : | a BraseroDrive
Returns : | a string or NULL. The string must be freed when not needed

### brasero_drive_get_caps ()

    BraseroDriveCaps    brasero_drive_get_caps              (BraseroDrive *drive);

Returns what type(s) of disc the drive can write to.

`drive` : | a BraseroDrive
Returns : | a BraseroDriveCaps.

### brasero_drive_can_write ()

    gboolean            brasero_drive_can_write             (BraseroDrive *drive);

Returns whether the disc can burn any disc at all.

`drive` : | a BraseroDrive
Returns : | a gboolean. TRUE if the drive can write a disc and FALSE otherwise

### brasero_drive_can_eject ()

    gboolean            brasero_drive_can_eject             (BraseroDrive *drive);

Returns whether the drive can eject media.

`drive` : | BraseroDrive
Returns : | a gboolean. TRUE if the media can be ejected, FALSE otherwise.

### brasero_drive_eject ()

    gboolean            brasero_drive_eject                 (BraseroDrive *drive,
                                                             gboolean wait,
                                                             GError **error);

Open the drive tray or ejects the media if there is any inside.

`drive` : | BraseroDrive
`wait` : | gboolean whether to wait for the completion of the operation (with a GMainLoop)
`error` : | GError
Returns : | a gboolean. TRUE on success, FALSE otherwise.

### brasero_drive_is_door_open ()

    gboolean            brasero_drive_is_door_open          (BraseroDrive *drive);

Returns whether or not the drive door is open.

`drive` : | a BraseroDrive
Returns : | `TRUE` or `FALSE`.

### brasero_drive_can_use_exclusively ()

    gboolean            brasero_drive_can_use_exclusively   (BraseroDrive *drive);

Returns whether or not the drive can be used exclusively, that is whether or not it is currently used by another application.

`drive` : | a BraseroDrive
Returns : | `TRUE` or `FALSE`.

### brasero_drive_lock ()

    gboolean            brasero_drive_lock                  (BraseroDrive *drive,
                                                             const gchar *reason,
                                                             gchar **reason_for_failure);

Locks a BraseroDrive. Ejection shouldn't be possible any more.

`drive` : | a BraseroDrive
`reason` : | a string to indicate what the drive was locked for
`reason_for_failure` : | a string to hold the reason why the locking failed
Returns : | `TRUE` if the drive was successfully locked or `FALSE`.

### brasero_drive_unlock ()

    gboolean            brasero_drive_unlock                (BraseroDrive *drive);

Unlocks a BraseroDrive.

`drive` : | a BraseroDrive
Returns : | `TRUE` if the drive was successfully unlocked or `FALSE`.