static void
brasero_medium_selection_update_no_disc_entry (BraseroMediumSelection *self,
GtkTreeModel *model,
GtkTreeIter *iter)
{
BraseroMediumMonitor *monitor;
GIcon *icon;
monitor = brasero_medium_monitor_get_default ();
if (brasero_medium_monitor_is_probing (monitor)) {
icon = g_themed_icon_new_with_default_fallbacks ("image-loading");
gtk_list_store_set (GTK_LIST_STORE (model), iter,
NAME_COL, _("Searching for available discs"),
ICON_COL, icon,
VISIBLE_TEXT_COL, TRUE,
VISIBLE_PROGRESS_COL, FALSE,
-1);
}
else {
icon = g_themed_icon_new_with_default_fallbacks ("drive-optical");
gtk_list_store_set (GTK_LIST_STORE (model), iter,
NAME_COL, _("No disc available"),
ICON_COL, icon,
VISIBLE_TEXT_COL, TRUE,
VISIBLE_PROGRESS_COL, FALSE,
-1);
}
g_object_unref (icon);
g_object_unref (monitor);
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (self), iter);
brasero_medium_selection_set_current_medium (self, iter);
}
static void
brasero_medium_selection_init (BraseroMediumSelection *object)
{
GtkListStore *model;
BraseroMediumMonitor *monitor;
BraseroMediumSelectionPrivate *priv;
priv = BRASERO_MEDIUM_SELECTION_PRIVATE (object);
monitor = brasero_medium_monitor_get_default ();
priv->added_sig = g_signal_connect (monitor,
"medium-added",
G_CALLBACK (brasero_medium_selection_medium_added_cb),
object);
priv->removed_sig = g_signal_connect (monitor,
"medium-removed",
G_CALLBACK (brasero_medium_selection_medium_removed_cb),
object);
g_object_unref (monitor);
/* get the list and fill the model */
model = gtk_list_store_new (NUM_COL,
G_TYPE_OBJECT,
G_TYPE_STRING,
G_TYPE_ICON,
G_TYPE_UINT,
G_TYPE_BOOLEAN,
G_TYPE_BOOLEAN);
gtk_combo_box_set_model (GTK_COMBO_BOX (object), GTK_TREE_MODEL (model));
g_object_unref (model);
}
static gboolean
drive_is_cd_device (GDrive *gdrive)
{
BraseroMediumMonitor *monitor;
BraseroDrive *drive;
gchar *device;
device = g_drive_get_identifier (gdrive, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);
if (!device)
return FALSE;
DEBUG_PRINT ("Got device: %s\n", device);
/* FIXME: since we call the monitor, the library should be initialized.
* To avoid all the initializing we'll be able to use the new GIO API
* (#594649 - Have a way to detect optical drives) */
ensure_initialized();
monitor = brasero_medium_monitor_get_default ();
drive = brasero_medium_monitor_get_drive (monitor, device);
g_object_unref (monitor);
g_free (device);
if (drive == NULL)
return FALSE;
g_object_unref (drive);
return TRUE;
}
static gboolean
volume_is_blank (GVolume *volume)
{
BraseroMediumMonitor *monitor;
BraseroMedium *medium;
BraseroDrive *drive;
gchar *device;
gboolean is_blank;
is_blank = FALSE;
device = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);
if (!device)
return FALSE;
DEBUG_PRINT ("Got device: %s\n", device);
monitor = brasero_medium_monitor_get_default ();
drive = brasero_medium_monitor_get_drive (monitor, device);
g_object_unref (monitor);
g_free (device);
if (drive == NULL)
return FALSE;
medium = brasero_drive_get_medium (drive);
is_blank = (brasero_medium_get_status (medium) & BRASERO_MEDIUM_BLANK);
g_object_unref (drive);
return is_blank;
}
static void
tool_dialog_run (BraseroToolDialog *dialog,
GtkWindow *toplevel,
NautilusMenuItem *item)
{
char *device_path;
BraseroDrive *drive;
BraseroMediumMonitor *monitor;
device_path = g_object_get_data (G_OBJECT (item), "drive_device_path");
if (!device_path) {
g_warning ("Drive device path not specified");
return;
}
monitor = brasero_medium_monitor_get_default ();
drive = brasero_medium_monitor_get_drive (monitor, device_path);
g_object_unref (monitor);
if (drive) {
brasero_tool_dialog_set_medium (BRASERO_TOOL_DIALOG (dialog),
brasero_drive_get_medium (drive));
g_object_unref (drive);
}
/* Get the icon for the window */
if (toplevel)
gtk_window_set_icon_name (GTK_WINDOW (dialog), gtk_window_get_icon_name (toplevel));
else
gtk_window_set_icon_name (GTK_WINDOW (dialog), "brasero");
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (GTK_WIDGET (dialog));
}
static void
copy_disc_activate_cb (NautilusMenuItem *item,
gpointer user_data)
{
char *device_path;
BraseroMediumMonitor *monitor;
BraseroTrackDisc *track;
BraseroDrive *drive;
ensure_initialized();
device_path = g_object_get_data (G_OBJECT (item), "drive_device_path");
monitor = brasero_medium_monitor_get_default ();
drive = brasero_medium_monitor_get_drive (monitor, device_path);
g_object_unref (monitor);
track = brasero_track_disc_new ();
brasero_track_disc_set_drive (track, drive);
g_object_unref (drive);
launch_brasero_on_window_track (BRASERO_TRACK (track),
_("Copy Disc"),
NULL,
GTK_WINDOW (user_data));
g_object_unref (track);
}
gboolean
sj_metadata_helper_check_media (const char *cdrom, GError **error)
{
#ifndef USE_TOTEM_PL_PARSER
BraseroMediumMonitor *monitor;
BraseroMedium *medium;
BraseroDrive *drive;
/* This initialize the library if it isn't done yet */
monitor = brasero_medium_monitor_get_default ();
if (brasero_medium_monitor_is_probing (monitor)) {
/* FIXME: would be nicer to only check if "cdrom" is being probed,
* but libbrasero doesn't seem to have an API for that
*/
g_set_error (error, SJ_ERROR, SJ_ERROR_CD_BUSY, _("Cannot read CD: %s"),
_("Devices haven't been all probed yet"));
return FALSE;
}
drive = brasero_medium_monitor_get_drive (monitor, cdrom);
if (drive == NULL) {
return FALSE;
}
medium = brasero_drive_get_medium (drive);
g_object_unref (drive);
if (!medium || !BRASERO_MEDIUM_VALID (brasero_medium_get_status (medium))) {
char *msg;
SjError err;
if (access (cdrom, W_OK) == 0) {
msg = g_strdup_printf (_("Device '%s' does not contain any media"), cdrom);
err = SJ_ERROR_CD_NO_MEDIA;
} else {
msg = g_strdup_printf (_("Device '%s' could not be opened. Check the access permissions on the device."), cdrom);
err = SJ_ERROR_CD_PERMISSION_ERROR;
}
g_set_error (error, SJ_ERROR, err, _("Cannot read CD: %s"), msg);
g_free (msg);
return FALSE;
}
#else
GError *totem_error = NULL;
totem_cd_detect_type (cdrom, &totem_error);
if (totem_error != NULL) {
g_set_error (error, SJ_ERROR, SJ_ERROR_CD_NO_MEDIA, _("Cannot read CD: %s"), totem_error->message);
g_error_free (totem_error);
return FALSE;
}
#endif /* !USE_TOTEM_PL_PARSER */
return TRUE;
}
static void
brasero_medium_selection_finalize (GObject *object)
{
BraseroMediumSelectionPrivate *priv;
BraseroMediumMonitor *monitor;
priv = BRASERO_MEDIUM_SELECTION_PRIVATE (object);
monitor = brasero_medium_monitor_get_default ();
g_signal_handler_disconnect (monitor, priv->added_sig);
g_signal_handler_disconnect (monitor, priv->removed_sig);
priv->removed_sig = 0;
priv->added_sig = 0;
g_object_unref (monitor);
G_OBJECT_CLASS (brasero_medium_selection_parent_class)->finalize (object);
}
static gboolean
rb_disc_recorder_has_burner (RBDiscRecorderPlugin *pi)
{
BraseroMediumMonitor *monitor;
GSList *drives;
/* Find all drives and check capabilities */
monitor = brasero_medium_monitor_get_default ();
drives = brasero_medium_monitor_get_drives (monitor, BRASERO_DRIVE_TYPE_WRITER);
g_object_unref (monitor);
g_slist_foreach (drives, (GFunc) g_object_unref, NULL);
g_slist_free (drives);
if (drives != NULL)
return TRUE;
return FALSE;
}
/**
* brasero_medium_selection_show_media_type:
* @selector: a #BraseroMediumSelection
* @type: a #BraseroMediaType
*
* Filters and displays media corresponding to @type.
**/
void
brasero_medium_selection_show_media_type (BraseroMediumSelection *selector,
BraseroMediaType type)
{
BraseroMediumSelectionPrivate *priv;
BraseroMediumMonitor *monitor;
GtkTreeModel *model;
GtkTreeIter iter;
GSList *list;
GSList *item;
g_return_if_fail (selector != NULL);
g_return_if_fail (BRASERO_IS_MEDIUM_SELECTION (selector));
priv = BRASERO_MEDIUM_SELECTION_PRIVATE (selector);
priv->type = type;
monitor = brasero_medium_monitor_get_default ();
list = brasero_medium_monitor_get_media (monitor, type);
g_object_unref (monitor);
model = gtk_combo_box_get_model (GTK_COMBO_BOX (selector));
if (gtk_tree_model_get_iter_first (model, &iter)) {
/* First filter */
do {
GSList *node;
BraseroMedium *medium;
gtk_tree_model_get (model, &iter,
MEDIUM_COL, &medium,
-1);
if (!medium) {
/* That's the dummy line saying there isn't any
* available medium for whatever action it is */
gtk_list_store_remove (GTK_LIST_STORE (model), &iter);
break;
}
node = g_slist_find (list, medium);
g_object_unref (medium);
if (!node) {
if (gtk_list_store_remove (GTK_LIST_STORE (model), &iter))
continue;
/* no more iter in the tree get out */
break;
}
g_object_unref (node->data);
list = g_slist_delete_link (list, node);
} while (gtk_tree_model_iter_next (model, &iter));
}
if (list) {
/* add remaining media */
for (item = list; item; item = item->next) {
gchar *medium_name;
GIcon *medium_icon;
BraseroMedium *medium;
medium = item->data;
gtk_list_store_insert_with_values (GTK_LIST_STORE (model), &iter,
-1,
MEDIUM_COL, medium,
-1);
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (selector), &iter);
medium_name = brasero_medium_selection_get_medium_string (selector, medium);
medium_icon = brasero_volume_get_icon (BRASERO_VOLUME (medium));
gtk_list_store_set (GTK_LIST_STORE (model), &iter,
NAME_COL, medium_name,
ICON_COL, medium_icon,
VISIBLE_TEXT_COL, TRUE,
VISIBLE_PROGRESS_COL, FALSE,
-1);
g_free (medium_name);
g_object_unref (medium_icon);
}
g_slist_foreach (list, (GFunc) g_object_unref, NULL);
g_slist_free (list);
}
if (!gtk_tree_model_get_iter_first (model, &iter)) {
brasero_medium_selection_add_no_disc_entry (selector);
return;
}
gtk_widget_set_sensitive (GTK_WIDGET (selector), TRUE);
if (gtk_combo_box_get_active (GTK_COMBO_BOX (selector)) == -1) {
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (selector), &iter);
brasero_medium_selection_set_current_medium (selector, &iter);
}
}
static void pattern_label_update (void)
{
char *file_pattern, *path_pattern;
char *file_value, *path_value, *example, *format;
char *media_type;
GstEncodingProfile *profile;
/* Disable -Wdiscarded-quantifiers to prevent warnings as we're
initalizing gchar* from const gchar*. This is safe as the strings
are never changed. */
SJ_BEGIN_IGNORE_DISCARDED_QUANTIFIERS
static const AlbumDetails sample_album = {
.title = "Help!", /* title */
.artist = "The Beatles", /* artist */
.artist_sortname = "Beatles, The", /* artist_sortname */
.genre = NULL, /* genre */
.number = 0, /* number of tracks*/
.disc_number = 1, /* disc number */
.tracks = NULL, /* track list */
.release_date = NULL, /* release date */
.album_id = NULL, /* album ID */
.artist_id = NULL /* artist ID */
};
static const TrackDetails sample_track = {
.album = (AlbumDetails*)&sample_album, /*album */
.number = 7, /* track number */
.title = "Ticket To Ride", /* title */
.artist = "The Beatles", /* artist */
.artist_sortname = "Beatles, The", /* artist_sortname */
.composer = "John Lennon and Paul McCartney", /* composer */
.composer_sortname = "Lennon, John", /* composer_sortname */
.duration = 0, /* duration */
.track_id = NULL, /* track ID */
.artist_id = NULL, /* artist ID */
};
SJ_END_IGNORE_DISCARDED_QUANTIFIERS
g_object_get (sj_extractor, "profile", &profile, NULL);
/* It's possible the profile isn't set, in which case do nothing */
if (!profile) {
return;
}
media_type = rb_gst_encoding_profile_get_media_type (profile);
gst_encoding_profile_unref (profile);
/* TODO: sucky. Replace with get-gconf-key-with-default mojo */
file_pattern = g_settings_get_string (sj_settings, SJ_SETTINGS_FILE_PATTERN);
if (file_pattern == NULL) {
file_pattern = g_strdup (sj_get_default_file_pattern ());
}
path_pattern = g_settings_get_string (sj_settings, SJ_SETTINGS_PATH_PATTERN);
if (path_pattern == NULL) {
path_pattern = g_strdup (sj_get_default_path_pattern ());
}
file_value = filepath_parse_pattern (file_pattern, &sample_track);
path_value = filepath_parse_pattern (path_pattern, &sample_track);
example = g_build_filename (G_DIR_SEPARATOR_S, path_value, file_value, NULL);
g_free (file_value);
g_free (file_pattern);
g_free (path_value);
g_free (path_pattern);
format = g_strconcat ("<small><i><b>",
_("Example Path: "),
"</b>",
example,
".",
rb_gst_media_type_to_extension (media_type),
"</i></small>", NULL);
g_free (example);
g_free (media_type);
gtk_label_set_markup (GTK_LABEL (path_example_label), format);
g_free (format);
}
static void settings_changed_cb (GSettings *settings, const gchar *key, gpointer combo)
{
char *value;
value = g_settings_get_string (settings, key);
if (!gtk_combo_box_set_active_id (combo, value))
gtk_combo_box_set_active_id (combo, NULL);
g_free (value);
pattern_label_update ();
}
/**
* Default device changed (either GSettings key or the widget)
*/
static void device_changed_cb (GSettings *settings, const gchar *key, gpointer user_data)
{
BraseroDrive *drive;
BraseroMediumMonitor *monitor;
char *value;
g_return_if_fail (strcmp (key, SJ_SETTINGS_DEVICE) == 0);
value = g_settings_get_string (settings, key);
if ((value != NULL) && (*value != '\0')) {
monitor = brasero_medium_monitor_get_default ();
drive = brasero_medium_monitor_get_drive (monitor, value);
brasero_drive_selection_set_active (BRASERO_DRIVE_SELECTION (cd_option), drive);
g_object_unref (drive);
g_object_unref (monitor);
} else {
/* FIXME: see the FIXME in sj-main.c around one of the
* device_changed_cb calls for a way to fix this
*/
g_warn_if_reached();
}
g_free (value);
}
static GList *
nautilus_disc_burn_get_file_items (NautilusMenuProvider *provider,
GtkWidget *window,
GList *selection)
{
GList *items = NULL;
NautilusMenuItem *item;
NautilusFileInfo *file_info;
GFile *file;
GMount *mount;
GVolume *volume;
GDrive *drive;
char *mime_type;
gboolean is_iso;
DEBUG_PRINT ("Getting file items\n");
if (!selection || selection->next != NULL) {
return NULL;
}
file_info = NAUTILUS_FILE_INFO (selection->data);
if (nautilus_file_info_is_gone (file_info)) {
return NULL;
}
file = nautilus_file_info_get_location (file_info);
if (file == NULL) {
DEBUG_PRINT ("No file found\n");
return NULL;
}
mime_type = nautilus_file_info_get_mime_type (file_info);
DEBUG_PRINT ("Mime type: %s\n", mime_type);
if (! mime_type) {
g_object_unref (file);
return NULL;
}
is_iso = (strcmp (mime_type, "application/x-iso-image") == 0)
|| (strcmp (mime_type, "application/x-cd-image") == 0)
|| (strcmp (mime_type, "application/x-cue") == 0)
|| (strcmp (mime_type, "application/x-toc") == 0)
|| (strcmp (mime_type, "application/x-cdrdao-toc") == 0);
if (is_iso) {
/* Whether or not this file is local is not a problem */
item = nautilus_menu_item_new ("NautilusDiscBurn::write_iso",
_("_Write to Disc…"),
_("Write disc image to a CD or DVD"),
"media-optical-data-new");
g_object_set_data (G_OBJECT (item), "file_info", file_info);
g_object_set_data (G_OBJECT (item), "window", window);
g_signal_connect (item, "activate",
G_CALLBACK (write_iso_activate_cb), window);
items = g_list_append (items, item);
}
/*
* We handle two cases here. The selection is:
* A) a volume
* B) a drive
*
* This is because there is very little distinction between
* the two for CD/DVD media
*/
drive = NULL;
volume = NULL;
mount = nautilus_file_info_get_mount (file_info);
if (mount != NULL) {
drive = g_mount_get_drive (mount);
volume = g_mount_get_volume (mount);
} else {
char *uri = g_file_get_uri (file);
DEBUG_PRINT ("Mount not found: %s\n", uri);
g_free (uri);
}
if (drive == NULL && volume != NULL) {
/* case A */
drive = g_volume_get_drive (volume);
} else if (volume == NULL && drive != NULL) {
/* case B */
volume = drive_get_first_volume (drive);
if (volume == NULL) {
DEBUG_PRINT ("Volume not found\n");
}
}
if (drive != NULL
&& volume != NULL
&& drive_is_cd_device (drive)
&& ! volume_is_blank (volume)) {
char *device_path;
BraseroMediumMonitor *monitor;
BraseroDrive *bdrive;
BraseroMedium *medium;
BraseroMedia media;
BraseroTrackType *type;
/* Reminder: the following is not needed since it is already
* called in drive_is_cd_device ().
* ensure_initialized();
*/
device_path = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);
monitor = brasero_medium_monitor_get_default ();
bdrive = brasero_medium_monitor_get_drive (monitor, device_path);
g_object_unref (monitor);
medium = brasero_drive_get_medium (bdrive);
media = brasero_medium_get_status (medium);
g_object_unref (bdrive);
type = brasero_track_type_new ();
brasero_track_type_set_has_medium (type);
brasero_track_type_set_medium_type (type, media);
if (brasero_burn_library_input_supported (type) == BRASERO_BURN_OK) {
/* user may want to copy it ... */
item = nautilus_menu_item_new ("NautilusDiscBurn::copy_disc",
_("_Copy Disc…"),
_("Create a copy of this CD or DVD"),
"media-optical-copy");
g_object_set_data (G_OBJECT (item), "file_info", file_info);
g_object_set_data (G_OBJECT (item), "window", window);
g_object_set_data_full (G_OBJECT (item), "drive_device_path", g_strdup (device_path), g_free);
g_signal_connect (item, "activate", G_CALLBACK (copy_disc_activate_cb), window);
items = g_list_append (items, item);
}
brasero_track_type_free (type);
if (brasero_burn_library_get_media_capabilities (media) & BRASERO_MEDIUM_REWRITABLE) {
/* ... or if it's a rewritable medium to blank it ... */
item = nautilus_menu_item_new ("NautilusDiscBurn::blank_disc",
_("_Blank Disc…"),
_("Blank this CD or DVD"),
"media-optical-blank");
g_object_set_data (G_OBJECT (item), "file_info", file_info);
g_object_set_data (G_OBJECT (item), "window", window);
g_object_set_data_full (G_OBJECT (item), "drive_device_path", g_strdup (device_path), g_free);
g_signal_connect (item, "activate",
G_CALLBACK (blank_disc_activate_cb), window);
items = g_list_append (items, item);
}
/* - library should be able to checksum
* - disc must have a data session */
if (brasero_burn_library_can_checksum ()
&& (media & BRASERO_MEDIUM_HAS_DATA)) {
/* ... or verify medium. */
item = nautilus_menu_item_new ("NautilusDiscBurn::check_disc",
_("_Check Disc…"),
_("Check the data integrity on this CD or DVD"),
NULL);
g_object_set_data (G_OBJECT (item), "file_info", file_info);
g_object_set_data (G_OBJECT (item), "window", window);
g_object_set_data_full (G_OBJECT (item), "drive_device_path", g_strdup (device_path), g_free);
g_signal_connect (item, "activate",
G_CALLBACK (check_disc_activate_cb),
window);
items = g_list_append (items, item);
}
g_free (device_path);
}
g_object_unref (file);
if (drive != NULL) {
g_object_unref (drive);
}
if (volume != NULL) {
g_object_unref (volume);
}
g_free (mime_type);
DEBUG_PRINT ("Items returned\n");
return items;
}
