static void
refresh_devices_list (XfburnPreferencesDialog * dialog)
{
XfburnPreferencesDialogPrivate *priv = XFBURN_PREFERENCES_DIALOG_GET_PRIVATE (dialog);
GtkTreeModel *model;
GList *device;
XfburnDeviceList *devlist;
model = gtk_tree_view_get_model (GTK_TREE_VIEW (priv->treeview_devices));
gtk_list_store_clear (GTK_LIST_STORE (model));
devlist = xfburn_device_list_new ();
g_object_get (G_OBJECT (devlist), "devices", &device, NULL);
g_object_unref (devlist);
while (device) {
GtkTreeIter iter;
XfburnDevice *device_data;
gchar *name, *addr;
gboolean cdr, cdrw, dvdr, dvdram, bd;
device_data = (XfburnDevice *) device->data;
g_object_get (G_OBJECT (device_data), "name", &name, "address", &addr,
"cdr", &cdr, "cdrw", &cdrw, "dvdr", &dvdr, "dvdram", &dvdram,
"bd", &bd, NULL);
gtk_list_store_append (GTK_LIST_STORE (model), &iter);
gtk_list_store_set (GTK_LIST_STORE (model), &iter,
DEVICE_LIST_COLUMN_NAME, name,
DEVICE_LIST_COLUMN_NODE, addr,
DEVICE_LIST_COLUMN_CDR, cdr,
DEVICE_LIST_COLUMN_CDRW, cdrw,
DEVICE_LIST_COLUMN_DVDR, dvdr,
DEVICE_LIST_COLUMN_DVDRAM, dvdram,
DEVICE_LIST_COLUMN_BD, bd,
-1);
g_free (name);
g_free (addr);
device = g_list_next (device);
}
}
/* entry point */
int
main (int argc, char **argv)
{
GtkWidget *mainwin;
gint n_burners;
GError *error = NULL;
#ifdef HAVE_GUDEV
gchar *error_msg;
#endif
XfburnTranscoder *transcoder;
XfburnDeviceList *devlist;
#if DEBUG > 0
/* I have to disable this until GtkTreeView gets fixed,
* and doesn't complain anymore when a DnD doesn't add any
* rows
g_log_set_always_fatal (G_LOG_LEVEL_CRITICAL);
*/
#endif
g_set_application_name (_("Xfburn"));
gdk_threads_init ();
gdk_threads_enter ();
xfce_textdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR, "UTF-8");
if (!gtk_init_with_args (&argc, &argv, "", optionentries, GETTEXT_PACKAGE, &error)) {
if (error != NULL) {
g_print (_("%s: %s\nTry %s --help to see a full list of available command line options.\n"), PACKAGE, error->message, PACKAGE_NAME);
g_error_free (error);
return EXIT_FAILURE;
}
}
if (!burn_initialize ()) {
g_critical ("Unable to initialize libburn");
xfce_dialog_show_error (NULL, NULL, _("Unable to initialize the burning backend."));
gdk_threads_leave ();
return EXIT_FAILURE;
}
#ifdef HAVE_GST
if (!gst_init_check (&argc, &argv, &error)) {
g_critical ("Failed to initialize gstreamer!");
/* I'm assuming this pretty much never happens. If it does, we should make this a soft failure and fall back to basic */
gdk_threads_leave ();
burn_finish ();
return EXIT_FAILURE;
}
#endif
if (show_version) {
#ifdef HAVE_GST
const char *nano_str;
guint gst_major, gst_minor, gst_micro, gst_nano;
#endif
g_print ("%s version %s for Xfce %s\n", PACKAGE, VERSION, xfce_version_string ());
g_print ("\tbuilt with GTK+-%d.%d.%d, ", GTK_MAJOR_VERSION, GTK_MINOR_VERSION, GTK_MICRO_VERSION);
g_print ("linked with GTK+-%d.%d.%d.\n", gtk_major_version, gtk_minor_version, gtk_micro_version);
#ifdef HAVE_GST
gst_version (&gst_major, &gst_minor, &gst_micro, &gst_nano);
if (gst_nano == 1)
nano_str = " (CVS)";
else if (gst_nano == 2)
nano_str = " (Prerelease)";
else
nano_str = "";
g_print ("\tGStreamer support (built with %d.%d.%d, linked against %d.%d.%d%s)\n",
GST_VERSION_MAJOR, GST_VERSION_MINOR, GST_VERSION_MICRO,
gst_major, gst_minor, gst_micro, nano_str);
#endif
exit (EXIT_SUCCESS);
}
if (transcoder_selection && strcmp (transcoder_selection, "list") == 0) {
print_available_transcoders();
gdk_threads_leave ();
burn_finish ();
return EXIT_SUCCESS;
}
DBG ("%s version %s for Xfce %s\n", PACKAGE, VERSION, xfce_version_string ());
xfburn_settings_init ();
#ifdef HAVE_GUDEV
error_msg = xfburn_udev_manager_create_global ();
if (error_msg) {
xfce_dialog_show_error (NULL, NULL, "%s", error_msg);
gdk_threads_leave ();
burn_finish ();
return EXIT_FAILURE;
} else {
g_message ("Using UDEV");
}
#endif
xfburn_stock_init ();
devlist = xfburn_device_list_new ();
g_object_get (devlist, "num-burners", &n_burners, NULL);
if (n_burners < 1) {
GtkMessageDialog *dialog = (GtkMessageDialog *) gtk_message_dialog_new (NULL,
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_WARNING,
GTK_BUTTONS_CLOSE,
((const gchar *) _("No burners are currently available")));
gtk_message_dialog_format_secondary_text (dialog,
_("Possibly the disc(s) are in use, and cannot get accessed.\n\n"
"Please unmount and restart the application.\n\n"
"If no disc is in the drive, check that you have read and write access to the drive with the current user."));
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (GTK_WIDGET (dialog));
}
/*----------Transcoder--------------------------------------------------*/
if (!transcoder_selection) {
/* select the best available */
#ifdef HAVE_GST
transcoder = XFBURN_TRANSCODER (xfburn_transcoder_gst_new ());
#else
transcoder = XFBURN_TRANSCODER (xfburn_transcoder_basic_new ());
#endif
#ifdef HAVE_GST
} else if (strcmp (transcoder_selection, "gst") == 0) {
transcoder = XFBURN_TRANSCODER (xfburn_transcoder_gst_new ());
#endif
} else if (strcmp (transcoder_selection, "basic") == 0) {
transcoder = XFBURN_TRANSCODER (xfburn_transcoder_basic_new ());
} else {
g_print ("'%s' is an invalid transcoder selection.\n",
transcoder_selection);
g_print ("\n");
print_available_transcoders();
gdk_threads_leave ();
burn_finish ();
return EXIT_FAILURE;
}
if (!xfburn_transcoder_is_initialized (transcoder, &error)) {
xfce_dialog_show_warning(NULL, NULL, _("Failed to initialize %s transcoder: %s\n\t(falling back to basic implementation)"), xfburn_transcoder_get_name (transcoder), error->message);
g_error_free (error);
g_object_unref (transcoder);
transcoder = XFBURN_TRANSCODER (xfburn_transcoder_basic_new ());
} else {
g_message ("Using %s transcoder.", xfburn_transcoder_get_name (transcoder));
}
xfburn_transcoder_set_global (transcoder);
/*----------evaluate parsed command line action options-------------------------*/
/* heuristic for file names on the commandline */
if (argc == 2 && !add_data_composition && !add_audio_composition) {
/* exactly one filename, assume it is an image */
image_filename = argv[1];
} else if (argc > 2) {
/* several file names, for now just open up a data composition */
/* TODO: auto-detect music files for audio compositions */
add_data_composition = TRUE;
}
if (show_main) {
xfburn_main_enter_main_window ();
}
if (image_filename != NULL) {
GtkWidget *dialog = xfburn_burn_image_dialog_new ();
other_action = TRUE;
DBG ("image_filename = '%s'\n", image_filename);
if (*image_filename != '\0') {
gchar *image_fullname;
if (!g_path_is_absolute (image_filename))
image_fullname = g_build_filename (g_get_current_dir (), image_filename, NULL);
else
image_fullname = image_filename;
if (g_file_test (image_fullname, G_FILE_TEST_EXISTS))
xfburn_burn_image_dialog_set_filechooser_name (dialog, image_fullname);
else
xfce_dialog_show_error (NULL, NULL, _("Image file '%s' does not exist."), image_fullname);
}
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
} else if (blank) {
GtkWidget *dialog = xfburn_blank_dialog_new ();
other_action = TRUE;
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
}
/*----------main window--------------------------------------------------*/
if (!other_action || show_main) {
xfburn_main_enter_main_window ();
mainwin = xfburn_main_window_new ();
gtk_widget_show (mainwin);
if (add_data_composition)
xfburn_main_window_add_data_composition_with_files (XFBURN_MAIN_WINDOW (mainwin), argc-1, argv+1);
if (add_audio_composition)
xfburn_main_window_add_audio_composition_with_files (XFBURN_MAIN_WINDOW (mainwin), argc-1, argv+1);
}
gtk_main ();
/*----------shutdown--------------------------------------------------*/
g_object_unref (devlist);
g_object_unref (transcoder);
#ifdef HAVE_GUDEV
xfburn_udev_manager_shutdown ();
#endif
xfburn_settings_flush ();
xfburn_settings_free ();
burn_finish ();
gdk_threads_leave ();
return EXIT_SUCCESS;
}
static void
xfburn_burn_image_dialog_init (XfburnBurnImageDialog * obj)
{
GtkBox *box = GTK_BOX (GTK_DIALOG (obj)->vbox);
XfburnBurnImageDialogPrivate *priv = XFBURN_BURN_IMAGE_DIALOG_GET_PRIVATE (obj);
GdkPixbuf *icon = NULL;
GtkFileFilter *filter;
GtkWidget *frame;
GtkWidget *vbox;
GtkWidget *button;
XfburnDevice *device;
gtk_window_set_title (GTK_WINDOW (obj), _("Burn image"));
gtk_window_set_destroy_with_parent (GTK_WINDOW (obj), TRUE);
icon = gtk_widget_render_icon (GTK_WIDGET (obj), XFBURN_STOCK_BURN_CD, GTK_ICON_SIZE_DIALOG, NULL);
gtk_window_set_icon (GTK_WINDOW (obj), icon);
g_object_unref (icon);
/* file */
priv->chooser_image = gtk_file_chooser_button_new (_("Image to burn"), GTK_FILE_CHOOSER_ACTION_OPEN);
gtk_widget_show (priv->chooser_image);
filter = gtk_file_filter_new ();
gtk_file_filter_set_name (filter, _("All files"));
gtk_file_filter_add_pattern (filter, "*");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(priv->chooser_image), filter);
filter = gtk_file_filter_new ();
gtk_file_filter_set_name (filter, _("ISO images"));
gtk_file_filter_add_pattern (filter, "*.[iI][sS][oO]");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (priv->chooser_image), filter);
gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (priv->chooser_image), filter);
if(xfburn_main_has_initial_dir ()) {
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (priv->chooser_image), xfburn_main_get_initial_dir ());
}
if (last_file) {
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (priv->chooser_image), last_file);
}
frame = xfce_gtk_frame_box_new_with_content (_("Image to burn"), priv->chooser_image);
gtk_widget_show (frame);
gtk_box_pack_start (box, frame, FALSE, FALSE, BORDER);
/* red label for image */
priv->image_label = gtk_label_new ("");
gtk_widget_show (priv->image_label);
gtk_box_pack_start (GTK_BOX (box), priv->image_label, FALSE, FALSE, 0);
update_image_label (GTK_FILE_CHOOSER (priv->chooser_image), obj);
g_signal_connect (G_OBJECT (priv->chooser_image), "selection-changed", G_CALLBACK (update_image_label), obj);
/* devices list */
priv->device_box = xfburn_device_box_new (SHOW_CD_WRITERS | SHOW_CDRW_WRITERS | SHOW_DVD_WRITERS | SHOW_MODE_SELECTION | SHOW_SPEED_SELECTION);
gtk_widget_show (priv->device_box);
frame = xfce_gtk_frame_box_new_with_content (_("Burning device"), priv->device_box);
gtk_widget_show (frame);
gtk_box_pack_start (box, frame, FALSE, FALSE, BORDER);
/* options */
vbox = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox);
frame = xfce_gtk_frame_box_new_with_content (_("Options"), vbox);
gtk_widget_show (frame);
gtk_box_pack_start (box, frame, FALSE, FALSE, BORDER);
priv->check_eject = gtk_check_button_new_with_mnemonic (_("E_ject disk"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->check_eject), TRUE);
gtk_widget_show (priv->check_eject);
gtk_box_pack_start (GTK_BOX (vbox), priv->check_eject, FALSE, FALSE, BORDER);
priv->check_dummy = gtk_check_button_new_with_mnemonic (_("_Dummy write"));
gtk_widget_show (priv->check_dummy);
gtk_box_pack_start (GTK_BOX (vbox), priv->check_dummy, FALSE, FALSE, BORDER);
priv->check_burnfree = gtk_check_button_new_with_mnemonic (_("Burn_Free"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->check_burnfree), TRUE);
gtk_widget_show (priv->check_burnfree);
gtk_box_pack_start (GTK_BOX (vbox), priv->check_burnfree, FALSE, FALSE, BORDER);
priv->check_stream_recording = gtk_check_button_new_with_mnemonic (_("Stream _Recording"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->check_stream_recording), TRUE);
gtk_widget_show (priv->check_stream_recording);
gtk_box_pack_start (GTK_BOX (vbox), priv->check_stream_recording, FALSE, FALSE, BORDER);
priv->check_quit = gtk_check_button_new_with_mnemonic (_("_Quit after success"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->check_quit), xfburn_settings_get_boolean("quit_after_success", FALSE));
gtk_widget_show (priv->check_quit);
gtk_box_pack_start (GTK_BOX (vbox), priv->check_quit, FALSE, FALSE, BORDER);
/* action buttons */
button = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
gtk_widget_show (button);
gtk_dialog_add_action_widget (GTK_DIALOG (obj), button, GTK_RESPONSE_CANCEL);
priv->burn_button = xfburn_gtk_button_new_mixed (XFBURN_STOCK_BURN_CD, _("_Burn image"));
gtk_widget_show (priv->burn_button);
g_signal_connect (G_OBJECT (priv->burn_button), "clicked", G_CALLBACK (cb_clicked_ok), obj);
gtk_container_add (GTK_CONTAINER( GTK_DIALOG(obj)->action_area), priv->burn_button);
//gtk_dialog_add_action_widget (GTK_DIALOG (obj), button, GTK_RESPONSE_OK);
GTK_WIDGET_SET_FLAGS (priv->burn_button, GTK_CAN_DEFAULT);
gtk_widget_grab_focus (priv->burn_button);
gtk_widget_grab_default (priv->burn_button);
priv->devlist = xfburn_device_list_new ();
priv->handler_volchange = g_signal_connect (G_OBJECT (priv->devlist), "volume-change-end", G_CALLBACK (cb_volume_change_end), obj);
g_signal_connect (G_OBJECT (obj), "response", G_CALLBACK (cb_dialog_response), obj);
device = xfburn_device_list_get_current_device (priv->devlist);
if (device)
cb_volume_change_end (priv->devlist, TRUE, device, obj);
}
