« back to all changes in this revision
Viewing changes to src/brasero-project.c
- browse files at revision 45
- compare with another revision
- download diff
- download tarball
- view history from revision 45
- Committer: Bazaar Package Importer
- Author(s): Robert Ancell
- Date: 2009-07-14 14:13:00 UTC
- mfrom: (1.1.25 upstream)
- Revision ID: james.westby@ubuntu.com-20090714141300-e08q13sp48b2xzwd
Tags: 2.27.4-0ubuntu1
* New upstream release: (LP: #399112)
- Hal support removed, now relies on GIO only for drives/media probing
- New layout for size reporting in data/audio/video project
- Lot's of bug fixes
- Fixed some memleaks
- Bump libbrasero-media version to reflect changes (important to packagers)
- Fix #582261 – brasero shows 0% done, while continues burning disc
- Fix #582513 – Bogus VIDEO_TS directory error if AUDIO_TS directory present
- Fix #573805 – "Increase compatibility with Windows systems"?
- Fix #585190 – remove 0 from 03 % status
- Fix #586744 – Use AS_HELP_STRING for configure switches
- Fix #584793 – Poor language in warning dialog when attempting to burn an audio CD onto a CDRW
- Fix #580617 – Brasero floods .xsession-errors log with "Unknown (or already deleted) monitored directory" warnings
- Fix #563501 – Brasero burning window shouldn't try to show drive speed while is converting audio files
- Fix #485719 – Burn dialog CD icon
- Fix #585481 – Deep hierarchy warning
- Fix #554070 – The need of a "replace all" and "replace non" button
- Fix #582461 – Brasero hangs at normalizing tracks
- Fix #587284 – nautilus hangs every time
- Fix #574093 – Caret visible in instructions for project creation
- Fix #581742 – port from HAL to DeviceKit-disks
- Fix #573801 – Bad error message when burning empty burn:///
- Fix #573486 – Various i18n and string issues for good
- Fix #587399 – License clarification
- Fix #587554 – Unclear meaning of text
- Fix #582979 – brasero should not include Categories in mime handler .desktop files
- Fix #586040 – duplicated command listed in open-with dialog
- Fixes for #573486 – Various i18n and string issues
* debian/control.in:
- Add in missing comma in brasero suggests
- Hal support removed, now relies on GIO only for drives/media probing
- New layout for size reporting in data/audio/video project
- Lot's of bug fixes
- Fixed some memleaks
- Bump libbrasero-media version to reflect changes (important to packagers)
- Fix #582261 – brasero shows 0% done, while continues burning disc
- Fix #582513 – Bogus VIDEO_TS directory error if AUDIO_TS directory present
- Fix #573805 – "Increase compatibility with Windows systems"?
- Fix #585190 – remove 0 from 03 % status
- Fix #586744 – Use AS_HELP_STRING for configure switches
- Fix #584793 – Poor language in warning dialog when attempting to burn an audio CD onto a CDRW
- Fix #580617 – Brasero floods .xsession-errors log with "Unknown (or already deleted) monitored directory" warnings
- Fix #563501 – Brasero burning window shouldn't try to show drive speed while is converting audio files
- Fix #485719 – Burn dialog CD icon
- Fix #585481 – Deep hierarchy warning
- Fix #554070 – The need of a "replace all" and "replace non" button
- Fix #582461 – Brasero hangs at normalizing tracks
- Fix #587284 – nautilus hangs every time
- Fix #574093 – Caret visible in instructions for project creation
- Fix #581742 – port from HAL to DeviceKit-disks
- Fix #573801 – Bad error message when burning empty burn:///
- Fix #573486 – Various i18n and string issues for good
- Fix #587399 – License clarification
- Fix #587554 – Unclear meaning of text
- Fix #582979 – brasero should not include Categories in mime handler .desktop files
- Fix #586040 – duplicated command listed in open-with dialog
- Fixes for #573486 – Various i18n and string issues
* debian/control.in:
- Add in missing comma in brasero suggests
- files added:
- libbrasero-burn.pc
- files removed:
- data/brasero-open-image.desktop.in
- files modified:
- ChangeLog
added
removed
src/brasero-project.c
67
67
#include "brasero-burn-options.h"
68
68
#include "brasero-cover.h"
69
69
70
#include "brasero-medium-selection-priv.h"
71
#include "brasero-session-helper.h"
72
#include "brasero-session-cfg.h"
73
#include "brasero-dest-selection.h"
74
70
75
#include "brasero-project-type-chooser.h"
71
76
#include "brasero-app.h"
72
77
#include "brasero-project.h"
83
88
#include "brasero-burn-options.h"
84
89
#include "brasero-project-name.h"
85
90
91
#include "brasero-image-properties.h"
92
86
93
static void brasero_project_class_init (BraseroProjectClass *klass);
87
94
static void brasero_project_init (BraseroProject *sp);
88
95
static void brasero_project_iface_uri_container_init (BraseroURIContainerIFace *iface);
105
112
brasero_project_burn_cb (GtkAction *action, BraseroProject *project);
106
113
107
114
static void
108
brasero_project_size_changed_cb (BraseroDisc *disc,
109
gint64 size,
110
BraseroProject *project);
111
static void
112
brasero_project_flags_changed_cb (BraseroDisc *disc,
113
BraseroBurnFlag flags,
114
BraseroProject *project);
115
116
static void
117
115
brasero_project_burn_clicked_cb (GtkButton *button, BraseroProject *project);
118
116
119
117
static void
120
brasero_project_contents_changed_cb (BraseroDisc *disc,
121
gint nb_files,
122
BraseroProject *project);
123
static void
124
118
brasero_project_selection_changed_cb (BraseroDisc *disc,
125
119
BraseroProject *project);
126
120
143
137
gint *center,
144
138
gint *footer);
145
139
146
typedef enum {
147
BRASERO_PROJECT_SAVE_XML = 0,
148
BRASERO_PROJECT_SAVE_PLAIN = 1,
149
BRASERO_PROJECT_SAVE_PLAYLIST_PLS = 2,
150
BRASERO_PROJECT_SAVE_PLAYLIST_M3U = 3,
151
BRASERO_PROJECT_SAVE_PLAYLIST_XSPF = 4,
152
BRASERO_PROJECT_SAVE_PLAYLIST_IRIVER_PLA = 5
153
} BraseroProjectSave;
154
155
140
struct BraseroProjectPrivate {
141
BraseroSessionCfg *session;
142
143
GtkWidget *help;
144
GtkWidget *selection;
156
145
GtkWidget *name_display;
157
GtkWidget *button_img;
158
GtkWidget *icon_img;
159
146
GtkWidget *discs;
160
147
GtkWidget *audio;
161
148
GtkWidget *data;
197
184
guint has_focus:1;
198
185
guint oversized:1;
199
186
guint selected_uris:1;
200
201
guint merging:1;
202
187
};
203
188
204
189
static GtkActionEntry entries [] = {
265
250
266
251
#define BRASERO_RESPONSE_ADD 1976
267
252
253
enum {
254
TREE_MODEL_ROW = 150,
255
FILE_NODES_ROW,
256
TARGET_URIS_LIST,
257
};
258
259
static GtkTargetEntry ntables_cd[] = {
260
{"GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_WIDGET, TREE_MODEL_ROW},
261
{"GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_WIDGET, FILE_NODES_ROW},
262
{"text/uri-list", 0, TARGET_URIS_LIST}
263
};
264
static guint nb_targets_cd = sizeof (ntables_cd) / sizeof (ntables_cd [0]);
265
268
266
GType
269
267
brasero_project_get_type ()
270
268
{
383
381
}
384
382
385
383
widget = gtk_ui_manager_get_widget (project->priv->manager, "/Toolbar/Add");
384
if (!widget)
385
return;
386
386
387
widget = gtk_bin_get_child (GTK_BIN (widget));
387
388
GTK_WIDGET_SET_FLAGS (widget, GTK_CAN_DEFAULT);
388
389
gtk_window_set_default (GTK_WINDOW (toplevel), widget);
418
419
gtk_action_set_sensitive (action, FALSE);
419
420
}
420
421
421
static void
422
brasero_project_data_icon_error (BraseroProject *project,
423
GError *error)
424
{
425
if (error) {
426
brasero_app_alert (brasero_app_get_default (),
427
/* Translators: this is a picture not
428
* a disc image */
429
C_("picture", "Please select another image."),
430
error->message,
431
GTK_MESSAGE_ERROR);
422
/********************************** help ***************************************/
423
static GtkWidget *
424
brasero_utils_disc_find_tree_view_in_container (GtkContainer *container)
425
{
426
GList *children;
427
GList *iter;
428
429
children = gtk_container_get_children (container);
430
for (iter = children; iter; iter = iter->next) {
431
GtkWidget *widget;
432
433
widget = iter->data;
434
if (GTK_IS_TREE_VIEW (widget)) {
435
g_list_free (children);
436
return widget;
437
}
438
439
if (GTK_IS_CONTAINER (widget)) {
440
widget = brasero_utils_disc_find_tree_view_in_container (GTK_CONTAINER (widget));
441
if (widget) {
442
g_list_free (children);
443
return widget;
444
}
445
}
446
}
447
g_list_free (children);
448
449
return NULL;
450
}
451
452
static GtkWidget *
453
brasero_utils_disc_find_tree_view (BraseroDisc *widget)
454
{
455
return brasero_utils_disc_find_tree_view_in_container (GTK_CONTAINER (widget));
456
}
457
458
static void
459
brasero_utils_disc_hide_use_info_leave_cb (GtkWidget *widget,
460
GdkDragContext *drag_context,
461
guint time,
462
BraseroProject *project)
463
{
464
GtkWidget *other_widget;
465
466
other_widget = brasero_utils_disc_find_tree_view (project->priv->current);
467
if (!other_widget)
468
return;
469
470
g_signal_emit_by_name (other_widget,
471
"drag-leave",
472
drag_context,
473
time);
474
}
475
476
static gboolean
477
brasero_utils_disc_hide_use_info_drop_cb (GtkWidget *widget,
478
GdkDragContext *drag_context,
479
gint x,
480
gint y,
481
guint time,
482
BraseroProject *project)
483
{
484
GdkAtom target = GDK_NONE;
485
GtkWidget *other_widget;
486
487
/* here the treeview is not realized so we'll have a warning message
488
* if we ever try to forward the event */
489
other_widget = brasero_utils_disc_find_tree_view (project->priv->current);
490
if (!other_widget)
491
return FALSE;
492
493
target = gtk_drag_dest_find_target (other_widget,
494
drag_context,
495
gtk_drag_dest_get_target_list (GTK_WIDGET (other_widget)));
496
497
if (target != GDK_NONE) {
498
gboolean return_value = FALSE;
499
500
/* It's necessary to make sure the treeview
501
* is realized already before sending the
502
* signal */
503
gtk_widget_realize (other_widget);
504
505
/* The widget must be realized to receive such events. */
506
g_signal_emit_by_name (other_widget,
507
"drag-drop",
508
drag_context,
509
x,
510
y,
511
time,
512
&return_value);
513
return return_value;
514
}
515
516
return FALSE;
517
}
518
519
static void
520
brasero_utils_disc_hide_use_info_data_received_cb (GtkWidget *widget,
521
GdkDragContext *drag_context,
522
gint x,
523
gint y,
524
GtkSelectionData *data,
525
guint info,
526
guint time,
527
BraseroProject *project)
528
{
529
GtkWidget *other_widget;
530
531
other_widget = brasero_utils_disc_find_tree_view (project->priv->current);
532
if (!other_widget)
533
return;
534
535
g_signal_emit_by_name (other_widget,
536
"drag-data-received",
537
drag_context,
538
x,
539
y,
540
data,
541
info,
542
time);
543
}
544
545
static gboolean
546
brasero_utils_disc_hide_use_info_motion_cb (GtkWidget *widget,
547
GdkDragContext *drag_context,
548
gint x,
549
gint y,
550
guint time,
551
GtkNotebook *notebook)
552
{
553
return TRUE;
554
}
555
556
static gboolean
557
brasero_utils_disc_hide_use_info_button_cb (GtkWidget *widget,
558
GdkEventButton *event,
559
BraseroProject *project)
560
{
561
GtkWidget *other_widget;
562
gboolean result;
563
564
if (event->button != 3)
565
return TRUE;
566
567
other_widget = brasero_utils_disc_find_tree_view (project->priv->current);
568
if (!other_widget)
569
return TRUE;
570
571
g_signal_emit_by_name (other_widget,
572
"button-press-event",
573
event,
574
&result);
575
576
return result;
577
}
578
579
static void
580
brasero_utils_disc_style_changed_cb (GtkWidget *widget,
581
GtkStyle *previous,
582
GtkWidget *event_box)
583
{
584
/* The widget (a treeview here) needs to be realized to get proper style */
585
gtk_widget_realize (widget);
586
gtk_widget_modify_bg (event_box, GTK_STATE_NORMAL, &widget->style->base[GTK_STATE_NORMAL]);
587
}
588
589
static void
590
brasero_utils_disc_realized_cb (GtkWidget *event_box,
591
GtkWidget *textview)
592
{
593
/* The widget (a treeview here) needs to be realized to get proper style */
594
gtk_widget_realize (textview);
595
gtk_widget_modify_bg (event_box, GTK_STATE_NORMAL, &textview->style->base[GTK_STATE_NORMAL]);
596
597
g_signal_handlers_disconnect_by_func (textview,
598
brasero_utils_disc_style_changed_cb,
599
event_box);
600
g_signal_connect (textview,
601
"style-set",
602
G_CALLBACK (brasero_utils_disc_style_changed_cb),
603
event_box);
604
}
605
606
static GtkWidget *
607
brasero_disc_get_use_info_notebook (BraseroProject *project)
608
{
609
GList *chain;
610
GtkTextIter iter;
611
GtkWidget *frame;
612
GtkWidget *textview;
613
GtkWidget *notebook;
614
GtkWidget *alignment;
615
GtkTextBuffer *buffer;
616
GtkWidget *event_box;
617
618
notebook = gtk_notebook_new ();
619
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (notebook), FALSE);
620
gtk_notebook_set_show_border (GTK_NOTEBOOK (notebook), FALSE);
621
622
frame = gtk_frame_new (NULL);
623
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
624
gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
625
frame,
626
NULL);
627
628
/* Now this event box must be 'transparent' to have the same background
629
* color as a treeview */
630
event_box = gtk_event_box_new ();
631
gtk_event_box_set_visible_window (GTK_EVENT_BOX (event_box), TRUE);
632
gtk_event_box_set_above_child (GTK_EVENT_BOX (event_box), TRUE);
633
gtk_drag_dest_set (event_box,
634
GTK_DEST_DEFAULT_MOTION,
635
ntables_cd,
636
nb_targets_cd,
637
GDK_ACTION_COPY|
638
GDK_ACTION_MOVE);
639
640
/* the following signals need to be forwarded to the widget underneath */
641
g_signal_connect (event_box,
642
"drag-motion",
643
G_CALLBACK (brasero_utils_disc_hide_use_info_motion_cb),
644
project);
645
g_signal_connect (event_box,
646
"drag-leave",
647
G_CALLBACK (brasero_utils_disc_hide_use_info_leave_cb),
648
project);
649
g_signal_connect (event_box,
650
"drag-drop",
651
G_CALLBACK (brasero_utils_disc_hide_use_info_drop_cb),
652
project);
653
g_signal_connect (event_box,
654
"button-press-event",
655
G_CALLBACK (brasero_utils_disc_hide_use_info_button_cb),
656
project);
657
g_signal_connect (event_box,
658
"drag-data-received",
659
G_CALLBACK (brasero_utils_disc_hide_use_info_data_received_cb),
660
project);
661
662
gtk_container_add (GTK_CONTAINER (frame), event_box);
663
664
/* The alignment to set properly the position of the GtkTextView */
665
alignment = gtk_alignment_new (0.5, 0.3, 0.0, 0.0);
666
gtk_widget_show (alignment);
667
gtk_container_add (GTK_CONTAINER (event_box), alignment);
668
669
/* The TreeView for the message */
670
buffer = gtk_text_buffer_new (NULL);
671
gtk_text_buffer_create_tag (buffer, "Title",
672
"scale", 1.2,
673
"justification", GTK_JUSTIFY_LEFT,
674
"foreground", "grey50",
675
NULL);
676
677
gtk_text_buffer_create_tag (buffer, "TextBody",
678
"justification", GTK_JUSTIFY_LEFT,
679
"foreground", "grey50",
680
NULL);
681
682
gtk_text_buffer_get_start_iter (buffer, &iter);
683
684
/* Translators: this messages will appear as a list of possible
685
* actions, like:
686
* To add/remove files you can:
687
* * perform action one
688
* * perform action two
689
* The full message will be showed in the main area of an empty
690
* project, suggesting users how to add and remove items to project.
691
* You simply have to translate messages in the best form
692
* for a list of actions. */
693
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter, _("To add files to this project you can:"), -1, "Title", NULL);
694
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter, "\n\t* ", -1, "TextBody", NULL);
695
696
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter, _("click the \"Add\" button to show a selection dialog"), -1, "TextBody", NULL);
697
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter, "\n\t* ", -1, "TextBody", NULL);
698
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter, _("select files in the selection pane and click the \"Add\" button"), -1, "TextBody", NULL);
699
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter, "\n\t* ", -1, "TextBody", NULL);
700
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter, _("drag files in this area from the selection pane or from the file manager"), -1, "TextBody", NULL);
701
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter, "\n\t* ", -1, "TextBody", NULL);
702
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter, _("double click on files in the selection pane"), -1, "TextBody", NULL);
703
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter, "\n\t* ", -1, "TextBody", NULL);
704
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter, _("copy files (from file manager for example) and paste in this area"), -1, "TextBody", NULL);
705
gtk_text_buffer_insert (buffer, &iter, "\n\n\n", -1);
706
707
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter, _("To remove files from this project you can:"), -1, "Title", NULL);
708
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter, "\n\t* ", -1, "TextBody", NULL);
709
710
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter, _("click on the \"Remove\" button to remove selected items in this area"), -1, "TextBody", NULL);
711
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter, "\n\t* ", -1, "TextBody", NULL);
712
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter, _("select items in this area, and choose \"Remove\" from context menu"), -1, "TextBody", NULL);
713
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter, "\n\t* ", -1, "TextBody", NULL);
714
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter, _("select items in this area, and press \"Delete\" key"), -1, "TextBody", NULL);
715
716
textview = gtk_text_view_new_with_buffer (buffer);
717
gtk_text_view_set_editable (GTK_TEXT_VIEW (textview), FALSE);
718
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (textview), FALSE);
719
720
gtk_drag_dest_set (textview,
721
GTK_DEST_DEFAULT_MOTION,
722
ntables_cd,
723
nb_targets_cd,
724
GDK_ACTION_COPY|
725
GDK_ACTION_MOVE);
726
727
/* the following signals need to be forwarded to the widget underneath */
728
g_signal_connect (textview,
729
"drag-motion",
730
G_CALLBACK (brasero_utils_disc_hide_use_info_motion_cb),
731
project);
732
g_signal_connect (textview,
733
"drag-leave",
734
G_CALLBACK (brasero_utils_disc_hide_use_info_leave_cb),
735
project);
736
g_signal_connect (textview,
737
"drag-drop",
738
G_CALLBACK (brasero_utils_disc_hide_use_info_drop_cb),
739
project);
740
g_signal_connect (textview,
741
"button-press-event",
742
G_CALLBACK (brasero_utils_disc_hide_use_info_button_cb),
743
project);
744
g_signal_connect (textview,
745
"drag-data-received",
746
G_CALLBACK (brasero_utils_disc_hide_use_info_data_received_cb),
747
project);
748
749
gtk_container_add (GTK_CONTAINER (alignment), textview);
750
751
g_signal_connect (event_box,
752
"realize",
753
G_CALLBACK (brasero_utils_disc_realized_cb),
754
project);
755
756
chain = g_list_prepend (NULL, event_box);
757
gtk_container_set_focus_chain (GTK_CONTAINER (frame), chain);
758
g_list_free (chain);
759
760
chain = g_list_prepend (NULL, alignment);
761
gtk_container_set_focus_chain (GTK_CONTAINER (event_box), chain);
762
g_list_free (chain);
763
764
chain = g_list_prepend (NULL, textview);
765
gtk_container_set_focus_chain (GTK_CONTAINER (alignment), chain);
766
g_list_free (chain);
767
768
gtk_widget_show_all (notebook);
769
return notebook;
770
}
771
772
/********************************** size ***************************************/
773
774
gchar *
775
brasero_project_get_sectors_string (gint64 sectors,
776
gboolean time_format)
777
{
778
gint64 size_bytes;
779
780
if (time_format) {
781
size_bytes = sectors * GST_SECOND / 75;
782
return brasero_units_get_time_string (size_bytes, TRUE, FALSE);
432
783
}
433
784
else {
434
brasero_app_alert (brasero_app_get_default (),
435
/* Translators: this is a picture not
436
* a disc image */
437
C_("picture", "Please select another image."),
438
_("Unknown error"),
439
GTK_MESSAGE_ERROR);
440
}
441
}
442
443
static void
444
brasero_project_icon_changed_cb (BraseroDisc *disc,
445
BraseroProject *project)
446
{
447
GError *error = NULL;
448
GdkPixbuf *pixbuf;
449
gchar *icon;
450
451
icon = brasero_data_disc_get_scaled_icon_path (BRASERO_DATA_DISC (project->priv->current));
452
if (!icon) {
453
gtk_image_set_from_icon_name (GTK_IMAGE (project->priv->icon_img),
454
"media-optical",
455
GTK_ICON_SIZE_LARGE_TOOLBAR);
456
return;
457
}
458
459
/* Load and convert (48x48) the image into a pixbuf */
460
pixbuf = gdk_pixbuf_new_from_file_at_scale (icon,
461
48,
462
48,
463
FALSE,
464
&error);
465
g_free (icon);
466
467
if (!pixbuf) {
468
gtk_image_set_from_icon_name (GTK_IMAGE (project->priv->icon_img),
469
"media-optical",
470
GTK_ICON_SIZE_LARGE_TOOLBAR);
471
brasero_project_data_icon_error (project, error);
472
g_error_free (error);
473
return;
474
}
475
476
gtk_image_set_from_pixbuf (GTK_IMAGE (project->priv->icon_img), pixbuf);
477
g_object_unref (pixbuf);
478
}
479
480
static void
481
brasero_project_icon_button_clicked (GtkWidget *button,
482
BraseroProject *project)
483
{
484
GtkFileFilter *filter;
485
GError *error = NULL;
486
GtkWidget *chooser;
487
gchar *path;
488
gint res;
489
490
if (!BRASERO_IS_DATA_DISC (project->priv->current))
491
return;
492
493
chooser = gtk_file_chooser_dialog_new (_("Medium Icon"),
494
GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (project))),
495
GTK_FILE_CHOOSER_ACTION_OPEN,
496
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
497
GTK_STOCK_OK, GTK_RESPONSE_OK,
498
NULL);
499
500
filter = gtk_file_filter_new ();
501
gtk_file_filter_set_name (filter, _("All files"));
502
gtk_file_filter_add_pattern (filter, "*");
503
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);
504
505
filter = gtk_file_filter_new ();
506
/* Translators: this is an image, a picture, not a "Disc Image" */
507
gtk_file_filter_set_name (filter, C_("picture", "Image files"));
508
gtk_file_filter_add_mime_type (filter, "image/*");
509
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);
510
511
gtk_widget_show (chooser);
512
res = gtk_dialog_run (GTK_DIALOG (chooser));
513
if (res != GTK_RESPONSE_OK) {
514
gtk_widget_destroy (chooser);
515
return;
516
}
517
518
path = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (chooser));
519
gtk_widget_destroy (chooser);
520
521
if (!brasero_data_disc_set_icon_path (BRASERO_DATA_DISC (project->priv->current), path, &error)) {
522
if (error) {
523
brasero_project_data_icon_error (project, error);
524
g_error_free (error);
525
}
526
}
527
g_free (path);
785
size_bytes = sectors * 2048;
786
return g_format_size_for_display (size_bytes);
787
}
788
}
789
790
static void
791
brasero_project_update_project_size (BraseroProject *project)
792
{
793
goffset sectors = 0;
794
GtkWidget *status;
795
gchar *size_str;
796
gchar *string;
797
798
status = brasero_app_get_statusbar2 (brasero_app_get_default ());
799
800
if (!project->priv->status_ctx)
801
project->priv->status_ctx = gtk_statusbar_get_context_id (GTK_STATUSBAR (status),
802
"size_project");
803
804
gtk_statusbar_pop (GTK_STATUSBAR (status), project->priv->status_ctx);
805
806
brasero_burn_session_get_size (BRASERO_BURN_SESSION (project->priv->session),
807
§ors,
808
NULL);
809
810
string = brasero_project_get_sectors_string (sectors, !BRASERO_IS_DATA_DISC (project->priv->current));
811
size_str = g_strdup_printf (_("Project estimated size: %s"), string);
812
813
g_free (string);
814
815
gtk_statusbar_push (GTK_STATUSBAR (status), project->priv->status_ctx, size_str);
816
g_free (size_str);
817
}
818
819
static void
820
brasero_project_update_controls (BraseroProject *project)
821
{
822
GtkAction *action;
823
824
brasero_project_set_remove_button_state (project);
825
brasero_project_set_add_button_state (project);
826
827
action = gtk_action_group_get_action (project->priv->project_group, "DeleteAll");
828
gtk_action_set_sensitive (action, (project->priv->empty == FALSE));
829
}
830
831
static void
832
brasero_project_modified (BraseroProject *project)
833
{
834
GtkAction *action;
835
836
brasero_project_update_controls (project);
837
brasero_project_update_project_size (project);
838
839
/* the state of the following depends on the existence of an opened project */
840
action = gtk_action_group_get_action (project->priv->project_group, "Save");
841
gtk_action_set_sensitive (action, TRUE);
842
project->priv->modified = TRUE;
843
}
844
845
static void
846
brasero_project_track_removed (BraseroBurnSession *session,
847
BraseroTrack *track,
848
guint former_position,
849
BraseroProject *project)
850
{
851
brasero_project_modified (project);
852
}
853
854
static void
855
brasero_project_track_changed (BraseroBurnSession *session,
856
BraseroTrack *track,
857
BraseroProject *project)
858
{
859
brasero_project_modified (project);
860
}
861
862
static void
863
brasero_project_track_added (BraseroBurnSession *session,
864
BraseroTrack *track,
865
BraseroProject *project)
866
{
867
brasero_project_modified (project);
868
}
869
870
static void
871
brasero_project_message_response_span_cb (BraseroDiscMessage *message,
872
GtkResponseType response,
873
BraseroProject *project)
874
{
875
if (response == GTK_RESPONSE_OK)
876
brasero_session_span_start (BRASERO_SESSION_SPAN (project->priv->session));
877
}
878
879
static void
880
brasero_project_message_response_overburn_cb (BraseroDiscMessage *message,
881
GtkResponseType response,
882
BraseroProject *project)
883
{
884
if (response == GTK_RESPONSE_OK)
885
brasero_session_cfg_add_flags (project->priv->session, BRASERO_BURN_FLAG_OVERBURN);
886
}
887
888
static void
889
brasero_project_is_valid (BraseroSessionCfg *session,
890
BraseroProject *project)
891
{
892
BraseroSessionError valid;
893
BraseroStatus *status;
894
GdkWindow *window;
895
GdkCursor *cursor;
896
GtkAction *action;
897
898
/* Update the cursor */
899
status = brasero_status_new ();
900
brasero_burn_session_get_status (BRASERO_BURN_SESSION (session), status);
901
902
window = gtk_widget_get_window (GTK_WIDGET (project));
903
if (window) {
904
if (brasero_status_get_result (status) == BRASERO_BURN_NOT_READY) {
905
cursor = gdk_cursor_new (GDK_WATCH);
906
gdk_window_set_cursor (window, cursor);
907
gdk_cursor_unref (cursor);
908
}
909
else
910
gdk_window_set_cursor (window, NULL);
911
}
912
913
brasero_status_free (status);
914
915
valid = brasero_session_cfg_get_error (project->priv->session);
916
917
/* Update burn button state */
918
action = gtk_action_group_get_action (project->priv->project_group, "Burn");
919
gtk_action_set_sensitive (action, BRASERO_SESSION_IS_VALID (valid));
920
gtk_widget_set_sensitive (project->priv->burn, BRASERO_SESSION_IS_VALID (valid));
921
922
/* FIXME: update option button state as well */
923
924
/* Clean any message */
925
brasero_notify_message_remove (BRASERO_NOTIFY (project->priv->message),
926
BRASERO_NOTIFY_CONTEXT_SIZE);
927
928
if (valid == BRASERO_SESSION_INSUFFICIENT_SPACE) {
929
project->priv->oversized = TRUE;
930
931
/* Here there is an alternative: we may be able to span the data
932
* across multiple media. So try that. */
933
if (brasero_session_span_possible (BRASERO_SESSION_SPAN (project->priv->session)) == BRASERO_BURN_RETRY) {
934
GtkWidget *message;
935
936
message = brasero_notify_message_add (BRASERO_NOTIFY (project->priv->message),
937
_("Would you like to burn the selection of files across several media?"),
938
_("The size of the project is too large for the disc even with the overburn option."),
939
-1,
940
BRASERO_NOTIFY_CONTEXT_SIZE);
941
brasero_notify_button_add (BRASERO_NOTIFY (project->priv->message),
942
BRASERO_DISC_MESSAGE (message),
943
_("_Burn Several Discs"),
944
_("Burn the selection of files across several media"),
945
GTK_RESPONSE_OK);
946
947
g_signal_connect (message,
948
"response",
949
G_CALLBACK (brasero_project_message_response_span_cb),
950
project);
951
}
952
else
953
brasero_notify_message_add (BRASERO_NOTIFY (project->priv->message),
954
_("Please choose another CD or DVD or insert a new one."),
955
_("The size of the project is too large for the disc even with the overburn option."),
956
-1,
957
BRASERO_NOTIFY_CONTEXT_SIZE);
958
}
959
else if (valid == BRASERO_SESSION_OVERBURN_NECESSARY) {
960
GtkWidget *message;
961
962
project->priv->oversized = TRUE;
963
message = brasero_notify_message_add (BRASERO_NOTIFY (project->priv->message),
964
_("Would you like to burn beyond the disc reported capacity?"),
965
_("The size of the project is too large for the disc and you must remove files from the project otherwise."
966
"\nYou may want to use this option if you're using 90 or 100 min CD-R(W) which cannot be properly recognised and therefore need overburn option."
967
"\nNOTE: This option might cause failure."),
968
-1,
969
BRASERO_NOTIFY_CONTEXT_SIZE);
970
brasero_notify_button_add (BRASERO_NOTIFY (project->priv->message),
971
BRASERO_DISC_MESSAGE (message),
972
_("_Overburn"),
973
_("Burn beyond the disc reported capacity"),
974
GTK_RESPONSE_OK);
975
976
g_signal_connect (message,
977
"response",
978
G_CALLBACK (brasero_project_message_response_overburn_cb),
979
project);
980
}
981
else if (valid == BRASERO_SESSION_EMPTY) {
982
project->priv->empty = TRUE;
983
gtk_notebook_set_current_page (GTK_NOTEBOOK (project->priv->help), 1);
984
}
985
else if (valid == BRASERO_SESSION_NO_OUTPUT) {
986
brasero_notify_message_add (BRASERO_NOTIFY (project->priv->message),
987
_("Please insert a recordable CD or DVD."),
988
_("There is no recordable disc inserted."),
989
-1,
990
BRASERO_NOTIFY_CONTEXT_SIZE);
991
}
992
else if (valid == BRASERO_SESSION_NO_CD_TEXT) {
993
brasero_notify_message_add (BRASERO_NOTIFY (project->priv->message),
994
_("No track information (artist, title, ...) will be written to the disc."),
995
_("This is not supported by the current active burning backend."),
996
-1,
997
BRASERO_NOTIFY_CONTEXT_SIZE);
998
}
999
else if (valid == BRASERO_SESSION_NOT_SUPPORTED) {
1000
brasero_notify_message_add (BRASERO_NOTIFY (project->priv->message),
1001
_("Please replace the disc with a supported CD or DVD."),
1002
_("It is not possible to write with the current set of plugins."),
1003
-1,
1004
BRASERO_NOTIFY_CONTEXT_SIZE);
1005
}
1006
else if (brasero_burn_session_is_dest_file (BRASERO_BURN_SESSION (project->priv->session))
1007
&& brasero_medium_selection_get_media_num (BRASERO_MEDIUM_SELECTION (project->priv->selection)) == 1) {
1008
/* The user may have forgotten to insert a disc so remind him of that if
1009
* there aren't any other possibility in the selection */
1010
brasero_notify_message_add (BRASERO_NOTIFY (project->priv->message),
1011
_("Please insert a recordable CD or DVD if you don't want to write to an image file."),
1012
NULL,
1013
10000,
1014
BRASERO_NOTIFY_CONTEXT_SIZE);
1015
}
1016
1017
if (BRASERO_SESSION_IS_VALID (valid) || valid == BRASERO_SESSION_NOT_READY)
1018
gtk_notebook_set_current_page (GTK_NOTEBOOK (project->priv->help), 0);
1019
1020
if (BRASERO_SESSION_IS_VALID (valid)) {
1021
project->priv->empty = FALSE;
1022
project->priv->oversized = FALSE;
1023
}
528
1024
}
529
1025
530
1026
static void
531
1027
brasero_project_init (BraseroProject *obj)
532
1028
{
1029
GtkSizeGroup *name_size_group;
533
1030
GtkSizeGroup *size_group;
534
1031
GtkWidget *alignment;
535
GtkWidget *button;
536
GtkWidget *image;
537
GtkWidget *label;
538
GtkWidget *box;
1032
GtkWidget *selector;
1033
GtkWidget *table;
539
1034
540
1035
obj->priv = g_new0 (BraseroProjectPrivate, 1);
541
1036
549
1044
gtk_widget_show (obj->priv->message);
550
1045
551
1046
/* bottom */
552
box = gtk_hbox_new (FALSE, 6);
553
gtk_container_set_border_width (GTK_CONTAINER (box), 4);
554
gtk_widget_show (box);
555
gtk_box_pack_end (GTK_BOX (obj), box, FALSE, TRUE, 0);
556
557
/* Icon button */
558
image = gtk_image_new_from_icon_name ("media-optical", GTK_ICON_SIZE_LARGE_TOOLBAR);
559
gtk_widget_show (image);
560
obj->priv->icon_img = image;
561
562
button = gtk_button_new ();
563
gtk_widget_show (button);
564
gtk_button_set_image (GTK_BUTTON (button), image);
565
obj->priv->button_img = button;
566
567
gtk_widget_set_tooltip_text (button, _("Select an icon for the disc that will appear in file managers"));
568
569
g_signal_connect (button,
570
"clicked",
571
G_CALLBACK (brasero_project_icon_button_clicked),
572
obj);
573
574
gtk_box_pack_start (GTK_BOX (box), button, FALSE, TRUE, 0);
575
576
/* Name widget */
577
label = gtk_label_new_with_mnemonic (_("_Name:"));
578
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
579
gtk_misc_set_padding (GTK_MISC (label), 6, 0);
580
gtk_widget_show (label);
581
gtk_box_pack_start (GTK_BOX (box), label, FALSE, TRUE, 0);
582
583
obj->priv->name_display = brasero_project_name_new ();
584
gtk_widget_show (obj->priv->name_display);
585
gtk_box_pack_start (GTK_BOX (box), obj->priv->name_display, TRUE, TRUE, 0);
586
obj->priv->empty = 1;
587
588
g_signal_connect (obj->priv->name_display,
589
"name-changed",
590
G_CALLBACK (brasero_project_name_changed_cb),
591
obj);
592
593
gtk_label_set_mnemonic_widget (GTK_LABEL (label), obj->priv->name_display);
1047
table = gtk_table_new (3, 2, FALSE);
1048
gtk_container_set_border_width (GTK_CONTAINER (table), 6);
1049
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
1050
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
1051
gtk_widget_show (table);
1052
gtk_box_pack_end (GTK_BOX (obj), table, FALSE, TRUE, 0);
1053
1054
/* Media selection widget */
1055
name_size_group = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);
1056
selector = brasero_dest_selection_new (NULL);
1057
gtk_size_group_add_widget (GTK_SIZE_GROUP (name_size_group), selector);
1058
g_object_unref (name_size_group);
1059
1060
gtk_widget_show (selector);
1061
obj->priv->selection = selector;
1062
1063
gtk_table_attach (GTK_TABLE (table), selector,
1064
0, 2,
1065
1, 2,
1066
GTK_FILL|GTK_EXPAND,
1067
GTK_FILL|GTK_EXPAND,
1068
0, 0);
1069
1070
size_group = gtk_size_group_new (GTK_SIZE_GROUP_BOTH);
594
1071
595
1072
/* burn button set insensitive since there are no files in the selection */
596
size_group = gtk_size_group_new (GTK_SIZE_GROUP_BOTH);
597
1073
obj->priv->burn = brasero_utils_make_button (_("_Burn..."),
598
1074
NULL,
599
1075
"media-optical-burn",
612
1088
alignment = gtk_alignment_new (1.0, 0.5, 0.0, 0.0);
613
1089
gtk_widget_show (alignment);
614
1090
gtk_container_add (GTK_CONTAINER (alignment), obj->priv->burn);
615
gtk_box_pack_end (GTK_BOX (box), alignment, FALSE, TRUE, 0);
1091
gtk_table_attach (GTK_TABLE (table), alignment,
1092
2, 3,
1093
1, 2,
1094
GTK_FILL,
1095
GTK_EXPAND,
1096
0, 0);
1097
1098
/* Name widget */
1099
obj->priv->name_display = brasero_project_name_new (BRASERO_BURN_SESSION (obj->priv->session));
1100
gtk_size_group_add_widget (GTK_SIZE_GROUP (name_size_group), obj->priv->name_display);
1101
gtk_widget_show (obj->priv->name_display);
1102
gtk_table_attach (GTK_TABLE (table), obj->priv->name_display,
1103
0, 2,
1104
0, 1,
1105
GTK_EXPAND|GTK_FILL,
1106
GTK_EXPAND|GTK_FILL,
1107
0, 0);
1108
obj->priv->empty = 1;
1109
1110
g_signal_connect (obj->priv->name_display,
1111
"name-changed",
1112
G_CALLBACK (brasero_project_name_changed_cb),
1113
obj);
616
1114
617
1115
/* The three panes to put into the notebook */
618
1116
obj->priv->audio = brasero_audio_disc_new ();
619
1117
gtk_widget_show (obj->priv->audio);
620
1118
g_signal_connect (G_OBJECT (obj->priv->audio),
621
"contents-changed",
622
G_CALLBACK (brasero_project_contents_changed_cb),
623
obj);
624
g_signal_connect (G_OBJECT (obj->priv->audio),
625
"size-changed",
626
G_CALLBACK (brasero_project_size_changed_cb),
627
obj);
628
g_signal_connect (G_OBJECT (obj->priv->audio),
629
1119
"selection-changed",
630
1120
G_CALLBACK (brasero_project_selection_changed_cb),
631
1121
obj);
634
1124
gtk_widget_show (obj->priv->data);
635
1125
brasero_data_disc_set_right_button_group (BRASERO_DATA_DISC (obj->priv->data), size_group);
636
1126
g_signal_connect (G_OBJECT (obj->priv->data),
637
"contents-changed",
638
G_CALLBACK (brasero_project_contents_changed_cb),
639
obj);
640
g_signal_connect (G_OBJECT (obj->priv->data),
641
"size-changed",
642
G_CALLBACK (brasero_project_size_changed_cb),
643
obj);
644
g_signal_connect (G_OBJECT (obj->priv->data),
645
"flags-changed",
646
G_CALLBACK (brasero_project_flags_changed_cb),
647
obj);
648
g_signal_connect (G_OBJECT (obj->priv->data),
649
1127
"selection-changed",
650
1128
G_CALLBACK (brasero_project_selection_changed_cb),
651
1129
obj);
652
g_signal_connect (obj->priv->data,
653
"icon-changed",
654
G_CALLBACK (brasero_project_icon_changed_cb),
655
obj);
656
1130
657
1131
obj->priv->video = brasero_video_disc_new ();
658
1132
gtk_widget_show (obj->priv->video);
659
1133
g_signal_connect (G_OBJECT (obj->priv->video),
660
"contents-changed",
661
G_CALLBACK (brasero_project_contents_changed_cb),
662
obj);
663
g_signal_connect (G_OBJECT (obj->priv->video),
664
"size-changed",
665
G_CALLBACK (brasero_project_size_changed_cb),
666
obj);
667
g_signal_connect (G_OBJECT (obj->priv->video),
668
1134
"selection-changed",
669
1135
G_CALLBACK (brasero_project_selection_changed_cb),
670
1136
obj);
671
1137
1138
obj->priv->help = brasero_disc_get_use_info_notebook (obj);
1139
gtk_widget_show (obj->priv->help);
1140
672
1141
obj->priv->discs = gtk_notebook_new ();
673
1142
gtk_widget_show (obj->priv->discs);
674
1143
gtk_notebook_set_show_border (GTK_NOTEBOOK (obj->priv->discs), FALSE);
681
1150
gtk_notebook_prepend_page (GTK_NOTEBOOK (obj->priv->discs),
682
1151
obj->priv->audio, NULL);
683
1152
1153
gtk_notebook_prepend_page (GTK_NOTEBOOK (obj->priv->help),
1154
obj->priv->discs, NULL);
1155
684
1156
gtk_box_pack_start (GTK_BOX (obj),
685
obj->priv->discs,
1157
obj->priv->help,
686
1158
TRUE,
687
1159
TRUE,
688
1160
0);
689
1161
690
1162
g_object_unref (size_group);
1163
691
1164
}
692
1165
693
1166
static void
711
1184
{
712
1185
BraseroProject *obj;
713
1186
714
obj = BRASERO_PROJECT(g_object_new(BRASERO_TYPE_PROJECT, NULL));
1187
obj = BRASERO_PROJECT (g_object_new (BRASERO_TYPE_PROJECT, NULL));
715
1188
gtk_notebook_set_current_page (GTK_NOTEBOOK (obj->priv->discs), 0);
716
1189
717
1190
return GTK_WIDGET (obj);
718
1191
}
719
1192
720
/********************************** size ***************************************/
721
gchar *
722
brasero_project_get_sectors_string (gint64 sectors,
723
gboolean time_format)
724
{
725
gint64 size_bytes;
726
727
if (time_format) {
728
size_bytes = sectors * GST_SECOND / 75;
729
return brasero_units_get_time_string (size_bytes, TRUE, FALSE);
730
}
731
else {
732
size_bytes = sectors * 2048;
733
return g_format_size_for_display (size_bytes);
734
}
735
}
736
737
static void
738
brasero_project_update_project_size (BraseroProject *project,
739
guint64 sectors)
740
{
741
GtkWidget *status;
742
gchar *string;
743
gchar *size;
744
745
status = brasero_app_get_statusbar2 (brasero_app_get_default ());
746
747
if (!project->priv->status_ctx)
748
project->priv->status_ctx = gtk_statusbar_get_context_id (GTK_STATUSBAR (status),
749
"size_project");
750
751
gtk_statusbar_pop (GTK_STATUSBAR (status), project->priv->status_ctx);
752
753
string = brasero_project_get_sectors_string (sectors,
754
!BRASERO_IS_DATA_DISC (project->priv->current));
755
if (project->priv->merging) {
756
gchar *medium_string;
757
BraseroMedium *medium;
758
gint64 free_space = 0;
759
760
medium = brasero_data_disc_get_loaded_medium (BRASERO_DATA_DISC (project->priv->current));
761
brasero_medium_get_free_space (medium,
762
&free_space,
763
NULL);
764
765
medium_string = g_format_size_for_display (free_space);
766
/* Translators: first %s is the size of the project and the
767
* second %s is the remaining free space on the disc that is
768
* used for multisession */
769
size = g_strdup_printf (_("Project estimated size: %s/%s"),
770
string,
771
medium_string);
772
g_free (medium_string);
773
}
774
else
775
size = g_strdup_printf (_("Project estimated size: %s"), string);
776
777
g_free (string);
778
779
gtk_statusbar_push (GTK_STATUSBAR (status), project->priv->status_ctx, size);
780
g_free (size);
781
}
782
783
static void
784
brasero_project_size_changed_cb (BraseroDisc *disc,
785
gint64 sectors,
786
BraseroProject *project)
787
{
788
project->priv->sectors = sectors;
789
brasero_project_update_project_size (project, sectors);
790
}
791
792
static void
793
brasero_project_flags_changed_cb (BraseroDisc *disc,
794
BraseroBurnFlag flags,
795
BraseroProject *project)
796
{
797
gboolean merging;
798
799
merging = (flags & BRASERO_BURN_FLAG_MERGE) != 0;
800
801
/* see if the project name should be updated */
802
brasero_project_name_set_multisession_medium (BRASERO_PROJECT_NAME (project->priv->name_display),
803
brasero_data_disc_get_loaded_medium (BRASERO_DATA_DISC (disc)));
804
805
/* we just need to know if MERGE flag is on */
806
project->priv->merging = merging;
807
brasero_project_update_project_size (project, project->priv->sectors);
808
}
809
810
1193
/***************************** URIContainer ************************************/
811
1194
static void
812
1195
brasero_project_selection_changed_cb (BraseroDisc *disc,
855
1238
end);
856
1239
}
857
1240
858
/******************** useful function to wait when burning/saving **************/
859
static gboolean
860
_wait_for_ready_state (GtkWidget *dialog)
861
{
862
gchar *current_task = NULL;
863
GtkProgressBar *progress;
864
BraseroDiscResult status;
865
BraseroProject *project;
866
gint remaining = 0;
867
gint initial;
868
869
project = g_object_get_data (G_OBJECT (dialog), "Project");
870
if (project->priv->oversized
871
|| !project->priv->current
872
|| !project->priv->project_status) {
873
gtk_dialog_response (GTK_DIALOG (dialog), GTK_RESPONSE_CANCEL);
874
return FALSE;
875
}
876
877
progress = g_object_get_data (G_OBJECT (dialog), "ProgressBar");
878
initial = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (dialog), "Remaining"));
879
status = brasero_disc_get_status (project->priv->current, &remaining, ¤t_task);
880
if (status == BRASERO_DISC_NOT_READY || status == BRASERO_DISC_LOADING) {
881
gchar *string;
882
gchar *size_str;
883
884
if (initial <= 0 || remaining <= 0)
885
gtk_progress_bar_pulse (progress);
886
else
887
gtk_progress_bar_set_fraction (progress, (gdouble) ((gdouble) (initial - remaining) / (gdouble) initial));
888
889
if (current_task) {
890
GtkWidget *current_action;
891
892
current_action = g_object_get_data (G_OBJECT (dialog), "CurrentAction");
893
string = g_strdup_printf ("<i>%s</i>", current_task);
894
g_free (current_task);
895
896
gtk_label_set_markup (GTK_LABEL (current_action), string);
897
g_free (string);
898
}
899
900
string = brasero_project_get_sectors_string (project->priv->sectors,
901
!BRASERO_IS_DATA_DISC (project->priv->current));
902
903
size_str = g_strdup_printf (_("Project estimated size: %s"), string);
904
g_free (string);
905
906
gtk_progress_bar_set_text (progress, size_str);
907
g_free (size_str);
908
909
return TRUE;
910
}
911
912
gtk_dialog_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
913
return FALSE;
914
}
915
916
static BraseroDiscResult
917
brasero_project_check_status (BraseroProject *project,
918
BraseroDisc *disc)
919
{
920
int id;
921
int answer;
922
GtkWidget *box;
923
GtkWidget *dialog;
924
gchar *current_task;
925
GtkWidget *progress;
926
gint remaining = -1;
927
BraseroDiscResult result;
928
GtkWidget *current_action;
929
930
current_task = NULL;
931
result = brasero_disc_get_status (disc, &remaining, ¤t_task);
932
if (result != BRASERO_DISC_NOT_READY && result != BRASERO_DISC_LOADING)
933
return result;
934
935
/* we are not ready to create tracks presumably because
936
* data or audio has not finished to explore a directory
937
* or get the metadata of a song or a film */
938
939
/* This dialog can run as a standalone window when run from nautilus
940
* to burn burn:// URI contents. */
941
dialog = brasero_app_dialog (brasero_app_get_default (),
942
_("Please wait until the estimation of the project size is completed."),
943
GTK_BUTTONS_CANCEL,
944
GTK_MESSAGE_OTHER);
945
946
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
947
_("All files from the project need to be analysed to complete this operation."));
948
949
gtk_window_set_title (GTK_WINDOW (dialog), _("Project Size Estimation"));
950
951
box = gtk_vbox_new (FALSE, 4);
952
gtk_box_pack_end (GTK_BOX (GTK_DIALOG (dialog)->vbox),
953
box,
954
TRUE,
955
TRUE,
956
0);
957
958
progress = gtk_progress_bar_new ();
959
gtk_progress_bar_set_text (GTK_PROGRESS_BAR (progress), " ");
960
gtk_box_pack_start (GTK_BOX (box),
961
progress,
962
TRUE,
963
TRUE,
964
0);
965
966
if (current_task) {
967
gchar *string;
968
969
string = g_strdup_printf ("<i>%s</i>", current_task);
970
g_free (current_task);
971
972
current_action = gtk_label_new (string);
973
g_free (string);
974
}
975
else
976
current_action = gtk_label_new ("");
977
978
gtk_label_set_use_markup (GTK_LABEL (current_action), TRUE);
979
gtk_misc_set_alignment (GTK_MISC (current_action), 0.0, 0.5);
980
gtk_box_pack_start (GTK_BOX (box),
981
current_action,
982
FALSE,
983
TRUE,
984
0);
985
986
gtk_widget_show_all (dialog);
987
gtk_progress_bar_pulse (GTK_PROGRESS_BAR (progress));
988
989
g_object_set_data (G_OBJECT (dialog), "CurrentAction", current_action);
990
g_object_set_data (G_OBJECT (dialog), "ProgressBar", progress);
991
g_object_set_data (G_OBJECT (dialog), "Remaining", GINT_TO_POINTER (remaining));
992
g_object_set_data (G_OBJECT (dialog), "Project", project);
993
994
id = g_timeout_add (100,
995
(GSourceFunc) _wait_for_ready_state,
996
dialog);
997
998
project->priv->project_status = dialog;
999
answer = gtk_dialog_run (GTK_DIALOG (dialog));
1000
g_source_remove (id);
1001
1002
gtk_widget_destroy (dialog);
1003
1004
if (!project->priv->project_status)
1005
return BRASERO_DISC_CANCELLED;
1006
1007
project->priv->project_status = NULL;
1008
1009
if (answer != GTK_RESPONSE_OK)
1010
return BRASERO_DISC_CANCELLED;
1011
else if (project->priv->oversized)
1012
return BRASERO_DISC_ERROR_SIZE;
1013
1014
return brasero_disc_get_status (disc, NULL, NULL);
1015
}
1016
1017
/******************************** burning **************************************/
1018
1241
static void
1019
1242
brasero_project_no_song_dialog (BraseroProject *project)
1020
1243
{
1021
1244
brasero_app_alert (brasero_app_get_default (),
1022
1245
_("Please add songs to the project."),
1023
_("The project is empty"),
1246
_("There are no songs to write to disc"),
1024
1247
GTK_MESSAGE_WARNING);
1025
1248
}
1026
1249
1029
1252
{
1030
1253
brasero_app_alert (brasero_app_get_default (),
1031
1254
_("Please add files to the project."),
1032
_("The project is empty"),
1255
_("There are no files to write to disc"),
1033
1256
GTK_MESSAGE_WARNING);
1034
1257
}
1035
1258
1259
static BraseroBurnResult
1260
brasero_project_check_status (BraseroProject *project)
1261
{
1262
GtkWidget *dialog;
1263
BraseroStatus *status;
1264
GtkResponseType response;
1265
BraseroBurnResult result;
1266
1267
status = brasero_status_new ();
1268
brasero_burn_session_get_status (BRASERO_BURN_SESSION (project->priv->session), status);
1269
result = brasero_status_get_result (status);
1270
brasero_status_free (status);
1271
1272
if (result == BRASERO_BURN_ERR) {
1273
/* At the moment the only error possible is an empty project */
1274
if (BRASERO_IS_AUDIO_DISC (project->priv->current))
1275
brasero_project_no_song_dialog (project);
1276
else
1277
brasero_project_no_file_dialog (project);
1278
1279
return BRASERO_BURN_ERR;
1280
}
1281
1282
if (result == BRASERO_BURN_OK)
1283
return BRASERO_BURN_OK;
1284
1285
dialog = brasero_status_dialog_new (BRASERO_BURN_SESSION (project->priv->session),
1286
gtk_widget_get_toplevel (GTK_WIDGET (project)));
1287
1288
gtk_widget_show (dialog);
1289
response = gtk_dialog_run (GTK_DIALOG (dialog));
1290
gtk_widget_destroy (dialog);
1291
1292
return (response == GTK_RESPONSE_OK)? BRASERO_BURN_OK:BRASERO_BURN_CANCEL;
1293
}
1294
1295
/******************************** burning **************************************/
1036
1296
static void
1037
1297
brasero_project_setup_session (BraseroProject *project,
1038
1298
BraseroBurnSession *session)
1054
1314
}
1055
1315
}
1056
1316
1317
static gboolean
1318
brasero_project_drive_properties (BraseroProject *project)
1319
{
1320
BraseroTrackType *track_type;
1321
GtkWidget *medium_prop;
1322
GtkResponseType answer;
1323
BraseroDrive *drive;
1324
gchar *display_name;
1325
GtkWidget *options;
1326
GtkWidget *button;
1327
GtkWidget *dialog;
1328
GtkWidget *box;
1329
gchar *header;
1330
gchar *string;
1331
1332
/* Build dialog */
1333
drive = brasero_burn_session_get_burner (BRASERO_BURN_SESSION (project->priv->session));
1334
display_name = brasero_drive_get_display_name (drive);
1335
header = g_strdup_printf (_("Properties of %s"), display_name);
1336
g_free (display_name);
1337
1338
dialog = gtk_dialog_new_with_buttons (header,
1339
NULL,
1340
GTK_DIALOG_MODAL|
1341
GTK_DIALOG_NO_SEPARATOR|
1342
GTK_DIALOG_DESTROY_WITH_PARENT,
1343
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1344
NULL);
1345
g_free (header);
1346
1347
brasero_app_set_toplevel (brasero_app_get_default (), GTK_WINDOW (dialog));
1348
1349
button = brasero_utils_make_button (_("_Burn"),
1350
NULL,
1351
"media-optical-burn",
1352
GTK_ICON_SIZE_BUTTON);
1353
gtk_widget_show (button);
1354
gtk_dialog_add_action_widget (GTK_DIALOG (dialog),
1355
button,
1356
GTK_RESPONSE_OK);
1357
1358
box = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
1359
1360
track_type = brasero_track_type_new ();
1361
1362
brasero_burn_session_get_input_type (BRASERO_BURN_SESSION (project->priv->session), track_type);
1363
if (brasero_track_type_get_has_stream (track_type)
1364
&& BRASERO_STREAM_FORMAT_HAS_VIDEO (brasero_track_type_get_stream_format (track_type))) {
1365
/* Special case for video project */
1366
options = brasero_video_options_new (BRASERO_BURN_SESSION (project->priv->session));
1367
gtk_widget_show (options);
1368
1369
string = g_strdup_printf ("<b>%s</b>", _("Video Options"));
1370
options = brasero_utils_pack_properties (string,
1371
options,
1372
NULL);
1373
g_free (string);
1374
gtk_box_pack_start (GTK_BOX (box), options, FALSE, TRUE, 0);
1375
}
1376
1377
brasero_track_type_free (track_type);
1378
1379
medium_prop = brasero_drive_properties_new (project->priv->session);
1380
gtk_widget_show (medium_prop);
1381
gtk_box_pack_start (GTK_BOX (box), medium_prop, TRUE, TRUE, 0);
1382
1383
/* launch the dialog */
1384
answer = gtk_dialog_run (GTK_DIALOG (dialog));
1385
gtk_widget_destroy (dialog);
1386
1387
return (answer == GTK_RESPONSE_OK);
1388
}
1389
1390
static gboolean
1391
brasero_project_image_properties (BraseroProject *project)
1392
{
1393
GtkResponseType answer;
1394
GtkWidget *button;
1395
GtkWidget *dialog;
1396
1397
/* Build dialog */
1398
dialog = brasero_image_properties_new ();
1399
1400
brasero_app_set_toplevel (brasero_app_get_default (), GTK_WINDOW (dialog));
1401
gtk_window_set_destroy_with_parent (GTK_WINDOW (dialog), TRUE);
1402
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER_ON_PARENT);
1403
1404
gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
1405
1406
button = brasero_utils_make_button (_("_Burn"),
1407
NULL,
1408
"media-optical-burn",
1409
GTK_ICON_SIZE_BUTTON);
1410
gtk_widget_show (button);
1411
gtk_dialog_add_action_widget (GTK_DIALOG (dialog),
1412
button,
1413
GTK_RESPONSE_OK);
1414
1415
GTK_WIDGET_SET_FLAGS (button,
1416
GTK_WIDGET_FLAGS (button)|
1417
GTK_CAN_DEFAULT);
1418
1419
brasero_image_properties_set_session (BRASERO_IMAGE_PROPERTIES (dialog), project->priv->session);
1420
1421
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
1422
gtk_widget_show_all (dialog);
1423
1424
/* launch the dialog */
1425
answer = gtk_dialog_run (GTK_DIALOG (dialog));
1426
gtk_widget_destroy (dialog);
1427
1428
return (answer == GTK_RESPONSE_OK);
1429
}
1430
1057
1431
void
1058
1432
brasero_project_burn (BraseroProject *project)
1059
1433
{
1060
BraseroSessionCfg *session;
1061
BraseroDiscResult result;
1062
GtkWidget *dialog;
1063
gboolean success;
1064
1065
result = brasero_project_check_status (project, project->priv->current);
1066
if (result == BRASERO_DISC_CANCELLED)
1067
return;
1068
1069
if (result == BRASERO_DISC_ERROR_SIZE)
1070
return;
1071
1072
if (result == BRASERO_DISC_ERROR_EMPTY_SELECTION) {
1073
if (BRASERO_IS_AUDIO_DISC (project->priv->current))
1074
brasero_project_no_song_dialog (project);
1075
else
1076
brasero_project_no_file_dialog (project);
1077
1078
return;
1079
}
1080
1081
if (result != BRASERO_DISC_OK)
1434
gboolean res = FALSE;
1435
BraseroDisc *current_disc;
1436
1437
if (!brasero_burn_session_is_dest_file (BRASERO_BURN_SESSION (project->priv->session)))
1438
res = brasero_project_drive_properties (project);
1439
else
1440
res = brasero_project_image_properties (project);
1441
1442
if (!res)
1082
1443
return;
1083
1444
1084
1445
project->priv->is_burning = 1;
1085
1446
1447
/* This is to avoid having the settings being wrongly reflected or changed */
1448
current_disc = project->priv->current;
1449
brasero_disc_set_session_contents (current_disc, NULL);
1450
project->priv->current = NULL;
1451
1452
brasero_dest_selection_set_session (BRASERO_DEST_SELECTION (project->priv->selection), NULL);
1453
1454
brasero_project_setup_session (project, BRASERO_BURN_SESSION (project->priv->session));
1455
1086
1456
/* This is to stop the preview widget from playing */
1087
1457
brasero_uri_container_uri_selected (BRASERO_URI_CONTAINER (project));
1088
1458
1089
/* setup, show, and run options dialog */
1090
session = brasero_session_cfg_new ();
1091
brasero_disc_set_session_contents (project->priv->current, BRASERO_BURN_SESSION (session));
1092
dialog = brasero_burn_options_new (session);
1093
1094
brasero_app_set_toplevel (brasero_app_get_default (), GTK_WINDOW (dialog));
1095
1096
result = gtk_dialog_run (GTK_DIALOG (dialog));
1097
if (result != GTK_RESPONSE_OK) {
1098
g_object_unref (session);
1099
gtk_widget_destroy (dialog);
1100
goto end;
1101
}
1102
1103
gtk_widget_destroy (dialog);
1104
1105
brasero_project_setup_session (project, BRASERO_BURN_SESSION (session));
1106
1107
1459
/* now setup the burn dialog */
1108
success = brasero_app_burn (brasero_app_get_default (), BRASERO_BURN_SESSION (session));
1109
1110
project->priv->burnt = success;
1111
g_object_unref (session);
1112
1113
end:
1460
if (brasero_app_burn (brasero_app_get_default (), BRASERO_BURN_SESSION (project->priv->session)))
1461
project->priv->burnt = TRUE;
1462
1463
/* empty the stack of temporary tracks */
1464
while (brasero_burn_session_pop_tracks (BRASERO_BURN_SESSION (project->priv->session)) == BRASERO_BURN_RETRY);
1465
1466
project->priv->current = current_disc;
1467
brasero_disc_set_session_contents (current_disc, BRASERO_BURN_SESSION (project->priv->session));
1468
1469
brasero_dest_selection_set_session (BRASERO_DEST_SELECTION (project->priv->selection),
1470
BRASERO_BURN_SESSION (project->priv->session));
1114
1471
1115
1472
project->priv->is_burning = 0;
1116
1473
}
1120
1477
brasero_project_create_audio_cover (BraseroProject *project,
1121
1478
BraseroJacketEdit *cover)
1122
1479
{
1123
BraseroBurnSession *session;
1124
1480
GtkWidget *window;
1125
1481
1126
1482
if (!BRASERO_IS_AUDIO_DISC (project->priv->current))
1127
1483
return;
1128
1484
1129
session = BRASERO_BURN_SESSION (brasero_session_cfg_new ());
1130
brasero_disc_set_session_contents (BRASERO_DISC (project->priv->current), session);
1131
brasero_project_setup_session (project, session);
1132
1133
window = brasero_session_edit_cover (session, gtk_widget_get_toplevel (GTK_WIDGET (project)));
1134
g_object_unref (session);
1135
1485
brasero_project_setup_session (project, BRASERO_BURN_SESSION (project->priv->session));
1486
window = brasero_session_edit_cover (BRASERO_BURN_SESSION (project->priv->session),
1487
gtk_widget_get_toplevel (GTK_WIDGET (project)));
1136
1488
gtk_dialog_run (GTK_DIALOG (window));
1137
1489
gtk_widget_destroy (window);
1138
1490
}
1139
1491
1140
1492
/******************************** ******************************************/
1141
1493
static void
1142
brasero_project_switch (BraseroProject *project, BraseroProjectType type)
1494
brasero_project_reset (BraseroProject *project)
1143
1495
{
1144
GtkAction *action;
1145
GConfClient *client;
1146
1496
gtk_notebook_set_current_page (GTK_NOTEBOOK (project->priv->help), 1);
1497
1147
1498
if (project->priv->project_status) {
1148
1499
gtk_widget_hide (project->priv->project_status);
1149
1500
gtk_dialog_response (GTK_DIALOG (project->priv->project_status),
1151
1502
project->priv->project_status = NULL;
1152
1503
}
1153
1504
1154
gtk_image_set_from_icon_name (GTK_IMAGE (project->priv->icon_img),
1155
"media-optical",
1156
GTK_ICON_SIZE_LARGE_TOOLBAR);
1157
1158
if (project->priv->current)
1159
brasero_disc_reset (project->priv->current);
1505
if (project->priv->current) {
1506
brasero_disc_set_session_contents (project->priv->current, NULL);
1507
project->priv->current = NULL;
1508
}
1160
1509
1161
1510
if (project->priv->chooser) {
1162
1511
gtk_widget_destroy (project->priv->chooser);
1163
1512
project->priv->chooser = NULL;
1164
1513
}
1165
1514
1515
if (project->priv->project) {
1516
g_free (project->priv->project);
1517
project->priv->project = NULL;
1518
}
1519
1520
if (project->priv->cover) {
1521
g_free (project->priv->cover);
1522
project->priv->cover = NULL;
1523
}
1524
1525
/* remove the buttons from the "toolbar" */
1526
if (project->priv->merge_id > 0)
1527
gtk_ui_manager_remove_ui (project->priv->manager,
1528
project->priv->merge_id);
1529
1166
1530
project->priv->empty = 1;
1167
1531
project->priv->burnt = 0;
1168
project->priv->merging = 0;
1169
1532
project->priv->modified = 0;
1170
1533
1171
if (project->priv->project) {
1172
g_free (project->priv->project);
1173
project->priv->project = NULL;
1174
}
1175
1176
if (project->priv->cover) {
1177
g_free (project->priv->cover);
1178
project->priv->cover = NULL;
1179
}
1180
1181
client = gconf_client_get_default ();
1182
1183
/* remove the buttons from the "toolbar" */
1184
if (project->priv->merge_id)
1185
gtk_ui_manager_remove_ui (project->priv->manager,
1186
project->priv->merge_id);
1534
if (project->priv->session) {
1535
g_signal_handlers_disconnect_by_func (project->priv->session,
1536
brasero_project_is_valid,
1537
project);
1538
g_signal_handlers_disconnect_by_func (project->priv->session,
1539
brasero_project_track_added,
1540
project);
1541
g_signal_handlers_disconnect_by_func (project->priv->session,
1542
brasero_project_track_changed,
1543
project);
1544
g_signal_handlers_disconnect_by_func (project->priv->session,
1545
brasero_project_track_removed,
1546
project);
1547
1548
/* unref session to force it to remove all temporary files */
1549
g_object_unref (project->priv->session);
1550
project->priv->session = NULL;
1551
}
1552
1553
brasero_notify_message_remove (BRASERO_NOTIFY (project->priv->message), BRASERO_NOTIFY_CONTEXT_SIZE);
1554
brasero_notify_message_remove (BRASERO_NOTIFY (project->priv->message), BRASERO_NOTIFY_CONTEXT_LOADING);
1555
brasero_notify_message_remove (BRASERO_NOTIFY (project->priv->message), BRASERO_NOTIFY_CONTEXT_MULTISESSION);
1556
}
1557
1558
static void
1559
brasero_project_new_session (BraseroProject *project)
1560
{
1561
if (project->priv->session)
1562
brasero_project_reset (project);
1563
1564
project->priv->session = brasero_session_cfg_new ();
1565
1566
/* NOTE: "is-valid" is emitted whenever there is a change in the
1567
* contents of the session. So no need to connect to track-added, ... */
1568
g_signal_connect (project->priv->session,
1569
"is-valid",
1570
G_CALLBACK (brasero_project_is_valid),
1571
project);
1572
g_signal_connect (project->priv->session,
1573
"track-added",
1574
G_CALLBACK (brasero_project_track_added),
1575
project);
1576
g_signal_connect (project->priv->session,
1577
"track-changed",
1578
G_CALLBACK (brasero_project_track_changed),
1579
project);
1580
g_signal_connect (project->priv->session,
1581
"track-removed",
1582
G_CALLBACK (brasero_project_track_removed),
1583
project);
1584
1585
brasero_dest_selection_set_session (BRASERO_DEST_SELECTION (project->priv->selection),
1586
BRASERO_BURN_SESSION (project->priv->session));
1587
brasero_project_name_set_session (BRASERO_PROJECT_NAME (project->priv->name_display),
1588
BRASERO_BURN_SESSION (project->priv->session));
1589
}
1590
1591
static void
1592
brasero_project_switch (BraseroProject *project, BraseroProjectType type)
1593
{
1594
GtkAction *action;
1187
1595
1188
1596
if (type == BRASERO_PROJECT_TYPE_AUDIO) {
1189
gtk_widget_hide (project->priv->button_img);
1190
1597
project->priv->current = BRASERO_DISC (project->priv->audio);
1191
project->priv->merge_id = brasero_disc_add_ui (project->priv->current,
1192
project->priv->manager,
1193
project->priv->message);
1194
1195
1598
gtk_notebook_set_current_page (GTK_NOTEBOOK (project->priv->discs), 0);
1196
brasero_project_update_project_size (project, 0);
1599
brasero_medium_selection_show_media_type (BRASERO_MEDIUM_SELECTION (project->priv->selection),
1600
BRASERO_MEDIA_TYPE_WRITABLE);
1197
1601
}
1198
1602
else if (type == BRASERO_PROJECT_TYPE_DATA) {
1199
gtk_widget_show (project->priv->button_img);
1200
1603
project->priv->current = BRASERO_DISC (project->priv->data);
1201
project->priv->merge_id = brasero_disc_add_ui (project->priv->current,
1202
project->priv->manager,
1203
project->priv->message);
1204
1205
1604
gtk_notebook_set_current_page (GTK_NOTEBOOK (project->priv->discs), 1);
1206
brasero_project_update_project_size (project, 0);
1605
brasero_medium_selection_show_media_type (BRASERO_MEDIUM_SELECTION (project->priv->selection),
1606
BRASERO_MEDIA_TYPE_WRITABLE|
1607
BRASERO_MEDIA_TYPE_FILE);
1207
1608
}
1208
1609
else if (type == BRASERO_PROJECT_TYPE_VIDEO) {
1209
gtk_widget_hide (project->priv->button_img);
1210
1610
project->priv->current = BRASERO_DISC (project->priv->video);
1211
project->priv->merge_id = brasero_disc_add_ui (project->priv->current,
1212
project->priv->manager,
1213
project->priv->message);
1214
1215
1611
gtk_notebook_set_current_page (GTK_NOTEBOOK (project->priv->discs), 2);
1216
brasero_project_update_project_size (project, 0);
1612
brasero_medium_selection_show_media_type (BRASERO_MEDIUM_SELECTION (project->priv->selection),
1613
BRASERO_MEDIA_TYPE_WRITABLE|
1614
BRASERO_MEDIA_TYPE_FILE);
1615
}
1616
1617
brasero_dest_selection_choose_best (BRASERO_DEST_SELECTION (project->priv->selection));
1618
1619
if (project->priv->current) {
1620
project->priv->merge_id = brasero_disc_add_ui (project->priv->current,
1621
project->priv->manager,
1622
project->priv->message);
1623
brasero_disc_set_session_contents (project->priv->current,
1624
BRASERO_BURN_SESSION (project->priv->session));
1217
1625
}
1218
1626
1219
1627
brasero_notify_message_remove (BRASERO_NOTIFY (project->priv->message), BRASERO_NOTIFY_CONTEXT_SIZE);
1232
1640
gtk_action_set_sensitive (action, TRUE);
1233
1641
action = gtk_action_group_get_action (project->priv->project_group, "Save");
1234
1642
gtk_action_set_sensitive (action, FALSE);
1235
1236
brasero_project_name_set_type (BRASERO_PROJECT_NAME (project->priv->name_display), type);
1237
1643
}
1238
1644
1239
1645
void
1240
1646
brasero_project_set_audio (BraseroProject *project, GSList *uris)
1241
1647
{
1648
brasero_project_new_session (project);
1242
1649
brasero_project_switch (project, BRASERO_PROJECT_TYPE_AUDIO);
1243
1650
1244
1651
for (; uris; uris = uris->next) {
1253
1660
brasero_project_set_data (BraseroProject *project,
1254
1661
GSList *uris)
1255
1662
{
1663
brasero_project_new_session (project);
1256
1664
brasero_project_switch (project, BRASERO_PROJECT_TYPE_DATA);
1257
1665
1258
1666
for (; uris; uris = uris->next) {
1266
1674
void
1267
1675
brasero_project_set_video (BraseroProject *project, GSList *uris)
1268
1676
{
1677
brasero_project_new_session (project);
1269
1678
brasero_project_switch (project, BRASERO_PROJECT_TYPE_VIDEO);
1270
1679
1271
1680
for (; uris; uris = uris->next) {
1330
1739
GtkAction *action;
1331
1740
GtkWidget *status;
1332
1741
1333
if (project->priv->project_status) {
1334
gtk_widget_hide (project->priv->project_status);
1335
gtk_dialog_response (GTK_DIALOG (project->priv->project_status),
1336
GTK_RESPONSE_CANCEL);
1337
project->priv->project_status = NULL;
1338
}
1339
1340
if (project->priv->chooser) {
1341
gtk_widget_destroy (project->priv->chooser);
1342
project->priv->chooser = NULL;
1343
}
1344
1345
if (project->priv->project) {
1346
g_free (project->priv->project);
1347
project->priv->project = NULL;
1348
}
1349
1350
if (project->priv->cover) {
1351
g_free (project->priv->cover);
1352
project->priv->cover = NULL;
1353
}
1354
1355
if (project->priv->chooser) {
1356
gtk_widget_destroy (project->priv->chooser);
1357
project->priv->chooser = NULL;
1358
}
1359
1360
if (project->priv->current)
1361
brasero_disc_reset (project->priv->current);
1362
1363
project->priv->current = NULL;
1742
brasero_project_reset (project);
1364
1743
1365
1744
/* update buttons/menus */
1366
1745
action = gtk_action_group_get_action (project->priv->project_group, "Add");
1384
1763
gtk_statusbar_pop (GTK_STATUSBAR (status), project->priv->status_ctx);
1385
1764
}
1386
1765
1387
/********************* update the appearance of menus and buttons **************/
1388
static void
1389
brasero_project_contents_changed_cb (BraseroDisc *disc,
1390
gint nb_files,
1391
BraseroProject *project)
1392
{
1393
GtkAction *action;
1394
gboolean sensitive;
1395
1396
project->priv->empty = (nb_files == 0);
1397
1398
if (brasero_disc_get_status (disc, NULL, NULL) != BRASERO_DISC_LOADING)
1399
project->priv->modified = 1;
1400
1401
brasero_project_set_remove_button_state (project);
1402
brasero_project_set_add_button_state (project);
1403
1404
action = gtk_action_group_get_action (project->priv->project_group, "DeleteAll");
1405
gtk_action_set_sensitive (action, (project->priv->empty == FALSE));
1406
1407
/* the following button/action states depend on the project size too */
1408
sensitive = (project->priv->oversized == 0 &&
1409
project->priv->empty == 0);
1410
1411
action = gtk_action_group_get_action (project->priv->project_group, "Burn");
1412
gtk_action_set_sensitive (action, sensitive);
1413
gtk_widget_set_sensitive (project->priv->burn, sensitive);
1414
1415
/* the state of the following depends on the existence of an opened project */
1416
action = gtk_action_group_get_action (project->priv->project_group, "Save");
1417
if (project->priv->modified)
1418
gtk_action_set_sensitive (action, TRUE);
1419
else
1420
gtk_action_set_sensitive (action, FALSE);
1421
}
1422
1423
1766
/**************************** manage the relations with the sources ************/
1424
1767
static void
1425
1768
brasero_project_transfer_uris_from_src (BraseroProject *project)
1716
2059
return;
1717
2060
}
1718
2061
1719
brasero_disc_clear (BRASERO_DISC (project->priv->current));
2062
if (!brasero_disc_clear (BRASERO_DISC (project->priv->current)))
2063
brasero_burn_session_add_track (BRASERO_BURN_SESSION (project->priv->session), NULL, NULL);
1720
2064
}
1721
2065
1722
2066
static void
1778
2122
gtk_action_set_sensitive (action, FALSE);
1779
2123
1780
2124
project->priv->manager = manager;
2125
2126
gtk_widget_grab_focus (project->priv->name_display);
1781
2127
}
1782
2128
1783
2129
/******************************* common to save/open ***************************/
1855
2201
gtk_action_set_sensitive (action, FALSE);
1856
2202
}
1857
2203
2204
static BraseroProjectType
2205
brasero_project_get_session_type (BraseroProject *project)
2206
{
2207
BraseroTrackType *session_type;
2208
BraseroProjectType type;
2209
2210
session_type = brasero_track_type_new ();
2211
brasero_burn_session_get_input_type (BRASERO_BURN_SESSION (project->priv->session), session_type);
2212
2213
if (brasero_track_type_get_has_stream (session_type)) {
2214
if (BRASERO_STREAM_FORMAT_HAS_VIDEO (brasero_track_type_get_stream_format (session_type)))
2215
type = BRASERO_PROJECT_TYPE_VIDEO;
2216
else
2217
type = BRASERO_PROJECT_TYPE_AUDIO;
2218
}
2219
else if (brasero_track_type_get_has_data (session_type))
2220
type = BRASERO_PROJECT_TYPE_DATA;
2221
else
2222
type = BRASERO_PROJECT_TYPE_INVALID;
2223
2224
brasero_track_type_free (session_type);
2225
2226
return type;
2227
}
2228
1858
2229
/******************************* Projects **************************************/
1859
2230
BraseroProjectType
1860
brasero_project_open_project (BraseroProject *project,
1861
BraseroDiscTrack *track,
1862
const gchar *uri) /* escaped */
2231
brasero_project_open_project_real (BraseroProject *project,
2232
const gchar *uri, /* escaped */
2233
gboolean playlist,
2234
gboolean warn_user)
1863
2235
{
2236
GValue *value;
1864
2237
BraseroProjectType type;
1865
2238
1866
if (!track)
1867
return BRASERO_PROJECT_TYPE_INVALID;
1868
1869
brasero_project_update_project_size (project, 0);
1870
1871
if (track->type == BRASERO_PROJECT_TYPE_AUDIO)
1872
type = BRASERO_PROJECT_TYPE_AUDIO;
1873
else if (track->type == BRASERO_PROJECT_TYPE_DATA)
1874
type = BRASERO_PROJECT_TYPE_DATA;
1875
else if (track->type == BRASERO_PROJECT_TYPE_VIDEO)
1876
type = BRASERO_PROJECT_TYPE_VIDEO;
2239
brasero_project_new_session (project);
2240
2241
#ifdef BUILD_PLAYLIST
2242
2243
if (playlist) {
2244
if (!brasero_project_open_audio_playlist_project (uri, BRASERO_BURN_SESSION (project->priv->session), warn_user))
2245
return BRASERO_PROJECT_TYPE_INVALID;
2246
}
1877
2247
else
2248
2249
#endif
2250
2251
if (!brasero_project_open_project_xml (uri, BRASERO_BURN_SESSION (project->priv->session), warn_user))
1878
2252
return BRASERO_PROJECT_TYPE_INVALID;
1879
2253
2254
type = brasero_project_get_session_type (project);
2255
if (type == BRASERO_PROJECT_TYPE_INVALID)
2256
return type;
2257
1880
2258
brasero_project_switch (project, type);
1881
2259
1882
if (track->label) {
2260
if (brasero_burn_session_get_label (BRASERO_BURN_SESSION (project->priv->session))) {
1883
2261
g_signal_handlers_block_by_func (project->priv->name_display,
1884
2262
brasero_project_name_changed_cb,
1885
2263
project);
1886
gtk_entry_set_text (GTK_ENTRY (project->priv->name_display), track->label);
2264
gtk_entry_set_text (GTK_ENTRY (project->priv->name_display),
2265
brasero_burn_session_get_label (BRASERO_BURN_SESSION (project->priv->session)));
1887
2266
g_signal_handlers_unblock_by_func (project->priv->name_display,
1888
2267
brasero_project_name_changed_cb,
1889
2268
project);
1890
2269
}
1891
2270
1892
if (track->cover) {
2271
value = NULL;
2272
brasero_burn_session_tag_lookup (BRASERO_BURN_SESSION (project->priv->session),
2273
BRASERO_COVER_URI,
2274
&value);
2275
if (value) {
1893
2276
if (project->priv->cover)
1894
2277
g_free (project->priv->cover);
1895
2278
1896
project->priv->cover = g_strdup (track->cover);
2279
project->priv->cover = g_strdup (g_value_get_string (value));
1897
2280
}
1898
2281
1899
brasero_disc_load_track (project->priv->current, track);
1900
2282
project->priv->modified = 0;
1901
2283
1902
if (uri)
2284
return type;
2285
}
2286
2287
BraseroProjectType
2288
brasero_project_open_project (BraseroProject *project,
2289
const gchar *uri,
2290
gboolean playlist) /* escaped */
2291
{
2292
BraseroProjectType type;
2293
2294
type = brasero_project_open_project_real (project, uri, playlist, TRUE);
2295
if (type != BRASERO_PROJECT_TYPE_INVALID && uri)
1903
2296
brasero_project_set_uri (project, uri, type);
1904
2297
1905
2298
return type;
1906
2299
}
1907
2300
1908
2301
BraseroProjectType
1909
brasero_project_load_session (BraseroProject *project, const gchar *uri)
2302
brasero_project_load_session (BraseroProject *project,
2303
const gchar *uri)
1910
2304
{
1911
BraseroDiscTrack *track = NULL;
1912
BraseroProjectType type;
1913
1914
if (!brasero_project_open_project_xml (uri, &track, FALSE))
1915
return BRASERO_PROJECT_TYPE_INVALID;
1916
1917
if (track->type == BRASERO_PROJECT_TYPE_AUDIO)
1918
type = BRASERO_PROJECT_TYPE_AUDIO;
1919
else if (track->type == BRASERO_PROJECT_TYPE_DATA)
1920
type = BRASERO_PROJECT_TYPE_DATA;
1921
else if (track->type == BRASERO_PROJECT_TYPE_VIDEO)
1922
type = BRASERO_PROJECT_TYPE_VIDEO;
1923
else {
1924
brasero_track_free (track);
1925
return BRASERO_PROJECT_TYPE_INVALID;
1926
}
1927
1928
brasero_project_switch (project, type);
1929
1930
g_signal_handlers_block_by_func (project->priv->name_display,
1931
brasero_project_name_changed_cb,
1932
project);
1933
gtk_entry_set_text (GTK_ENTRY (project->priv->name_display), (gchar *) track->label);
1934
g_signal_handlers_unblock_by_func (project->priv->name_display,
1935
brasero_project_name_changed_cb,
1936
project);
1937
1938
brasero_disc_load_track (project->priv->current, track);
1939
brasero_track_free (track);
1940
1941
project->priv->modified = 0;
1942
1943
return type;
2305
return brasero_project_open_project_real (project, uri, FALSE, FALSE);
1944
2306
}
1945
2307
1946
2308
/******************************** save project *********************************/
2000
2362
}
2001
2363
2002
2364
static gboolean
2003
_save_audio_track_xml (xmlTextWriter *project,
2004
BraseroDiscTrack *track)
2005
{
2006
GSList *iter;
2007
gint success;
2008
2009
for (iter = track->contents.tracks; iter; iter = iter->next) {
2010
BraseroDiscSong *song;
2011
BraseroStreamInfo *info;
2012
xmlChar *escaped;
2013
gchar *start;
2014
gchar *isrc;
2015
gchar *end;
2016
2017
song = iter->data;
2018
info = song->info;
2019
2020
escaped = (unsigned char *) g_uri_escape_string (song->uri, NULL, FALSE);
2021
success = xmlTextWriterWriteElement (project,
2022
(xmlChar *) "uri",
2023
escaped);
2024
g_free (escaped);
2025
2026
if (success == -1)
2027
return FALSE;
2028
2029
if (song->gap) {
2030
gchar *silence;
2031
2032
silence = g_strdup_printf ("%"G_GINT64_FORMAT, song->gap);
2033
success = xmlTextWriterWriteElement (project,
2034
(xmlChar *) "silence",
2035
(xmlChar *) silence);
2036
2037
g_free (silence);
2038
if (success == -1)
2039
return FALSE;
2040
}
2041
2042
if (song->end > 0) {
2043
/* start of the song */
2044
start = g_strdup_printf ("%"G_GINT64_FORMAT, song->start);
2045
success = xmlTextWriterWriteElement (project,
2046
(xmlChar *) "start",
2047
(xmlChar *) start);
2048
2049
g_free (start);
2050
if (success == -1)
2051
return FALSE;
2052
2053
/* end of the song */
2054
end = g_strdup_printf ("%"G_GINT64_FORMAT, song->end);
2055
success = xmlTextWriterWriteElement (project,
2056
(xmlChar *) "end",
2057
(xmlChar *) end);
2058
2059
g_free (end);
2060
if (success == -1)
2061
return FALSE;
2062
}
2063
2064
if (!info)
2065
continue;
2066
2067
if (info->title) {
2068
escaped = (unsigned char *) g_uri_escape_string (info->title, NULL, FALSE);
2069
success = xmlTextWriterWriteElement (project,
2070
(xmlChar *) "title",
2071
escaped);
2072
g_free (escaped);
2073
2074
if (success == -1)
2075
return FALSE;
2076
}
2077
2078
if (info->artist) {
2079
escaped = (unsigned char *) g_uri_escape_string (info->artist, NULL, FALSE);
2080
success = xmlTextWriterWriteElement (project,
2081
(xmlChar *) "artist",
2082
escaped);
2083
g_free (escaped);
2084
2085
if (success == -1)
2086
return FALSE;
2087
}
2088
2089
if (info->composer) {
2090
escaped = (unsigned char *) g_uri_escape_string (info->composer, NULL, FALSE);
2091
success = xmlTextWriterWriteElement (project,
2092
(xmlChar *) "composer",
2093
escaped);
2094
g_free (escaped);
2095
2096
if (success == -1)
2097
return FALSE;
2098
}
2099
2100
if (info->isrc) {
2101
isrc = g_strdup_printf ("%d", info->isrc);
2102
success = xmlTextWriterWriteElement (project,
2103
(xmlChar *) "isrc",
2104
(xmlChar *) isrc);
2105
2106
g_free (isrc);
2107
if (success == -1)
2108
return FALSE;
2109
}
2110
}
2111
2112
return TRUE;
2113
}
2114
2115
static gboolean
2116
_save_data_track_xml (xmlTextWriter *project,
2117
BraseroDiscTrack *track)
2118
{
2119
gchar *uri;
2120
gint success;
2121
GSList *iter;
2122
GSList *grafts;
2123
BraseroGraftPt *graft;
2124
2125
if (track->contents.data.icon) {
2126
/* Write the icon if any */
2127
success = xmlTextWriterWriteElement (project, (xmlChar *) "icon", (xmlChar *) track->contents.data.icon);
2128
if (success < 0)
2129
return FALSE;
2130
}
2131
2132
for (grafts = track->contents.data.grafts; grafts; grafts = grafts->next) {
2133
graft = grafts->data;
2134
2135
success = xmlTextWriterStartElement (project, (xmlChar *) "graft");
2136
if (success < 0)
2137
return FALSE;
2138
2139
success = xmlTextWriterWriteElement (project, (xmlChar *) "path", (xmlChar *) graft->path);
2140
if (success < 0)
2141
return FALSE;
2142
2143
if (graft->uri) {
2144
xmlChar *escaped;
2145
2146
escaped = (unsigned char *) g_uri_escape_string (graft->uri, NULL, FALSE);
2147
success = xmlTextWriterWriteElement (project, (xmlChar *) "uri", escaped);
2148
g_free (escaped);
2149
if (success < 0)
2150
return FALSE;
2151
}
2152
2153
success = xmlTextWriterEndElement (project); /* graft */
2154
if (success < 0)
2155
return FALSE;
2156
}
2157
2158
/* save excluded uris */
2159
for (iter = track->contents.data.excluded; iter; iter = iter->next) {
2160
xmlChar *escaped;
2161
2162
escaped = xmlURIEscapeStr ((xmlChar *) iter->data, NULL);
2163
success = xmlTextWriterWriteElement (project, (xmlChar *) "excluded", (xmlChar *) escaped);
2164
g_free (escaped);
2165
if (success < 0)
2166
return FALSE;
2167
}
2168
2169
/* save restored uris */
2170
for (iter = track->contents.data.restored; iter; iter = iter->next) {
2171
uri = iter->data;
2172
success = xmlTextWriterWriteElement (project, (xmlChar *) "restored", (xmlChar *) uri);
2173
if (success < 0)
2174
return FALSE;
2175
}
2176
2177
/* NOTE: we don't write symlinks and unreadable they are useless */
2178
return TRUE;
2179
}
2180
2181
static gboolean
2182
brasero_project_save_project_xml (BraseroProject *proj,
2183
const gchar *uri,
2184
BraseroDiscTrack *track,
2185
gboolean use_dialog)
2186
{
2187
xmlTextWriter *project;
2188
gboolean retval;
2189
gint success;
2190
gchar *path;
2191
2192
path = g_filename_from_uri (uri, NULL, NULL);
2193
if (!path)
2194
return FALSE;
2195
2196
project = xmlNewTextWriterFilename (path, 0);
2197
if (!project) {
2198
g_free (path);
2199
2200
if (use_dialog)
2201
brasero_project_not_saved_dialog (proj);
2202
2203
return FALSE;
2204
}
2205
2206
xmlTextWriterSetIndent (project, 1);
2207
xmlTextWriterSetIndentString (project, (xmlChar *) "\t");
2208
2209
success = xmlTextWriterStartDocument (project,
2210
NULL,
2211
"UTF8",
2212
NULL);
2213
if (success < 0)
2214
goto error;
2215
2216
success = xmlTextWriterStartElement (project, (xmlChar *) "braseroproject");
2217
if (success < 0)
2218
goto error;
2219
2220
/* write the name of the version */
2221
success = xmlTextWriterWriteElement (project,
2222
(xmlChar *) "version",
2223
(xmlChar *) BRASERO_PROJECT_VERSION);
2224
if (success < 0)
2225
goto error;
2226
2227
success = xmlTextWriterWriteElement (project,
2228
(xmlChar *) "label",
2229
(xmlChar *) gtk_entry_get_text (GTK_ENTRY (proj->priv->name_display)));
2230
if (success < 0)
2231
goto error;
2232
2233
if (proj->priv->cover) {
2234
gchar *escaped;
2235
2236
escaped = g_uri_escape_string (proj->priv->cover, NULL, FALSE);
2237
success = xmlTextWriterWriteElement (project,
2238
(xmlChar *) "cover",
2239
(xmlChar *) escaped);
2240
g_free (escaped);
2241
2242
if (success < 0)
2243
goto error;
2244
}
2245
2246
success = xmlTextWriterStartElement (project, (xmlChar *) "track");
2247
if (success < 0)
2248
goto error;
2249
2250
if (track->type == BRASERO_PROJECT_TYPE_AUDIO) {
2251
success = xmlTextWriterStartElement (project, (xmlChar *) "audio");
2252
if (success < 0)
2253
goto error;
2254
2255
retval = _save_audio_track_xml (project, track);
2256
if (!retval)
2257
goto error;
2258
2259
success = xmlTextWriterEndElement (project); /* audio */
2260
if (success < 0)
2261
goto error;
2262
}
2263
else if (track->type == BRASERO_PROJECT_TYPE_DATA) {
2264
success = xmlTextWriterStartElement (project, (xmlChar *) "data");
2265
if (success < 0)
2266
goto error;
2267
2268
retval = _save_data_track_xml (project, track);
2269
if (!retval)
2270
goto error;
2271
2272
success = xmlTextWriterEndElement (project); /* data */
2273
if (success < 0)
2274
goto error;
2275
}
2276
else if (track->type == BRASERO_PROJECT_TYPE_VIDEO) {
2277
success = xmlTextWriterStartElement (project, (xmlChar *) "video");
2278
if (success < 0)
2279
goto error;
2280
2281
retval = _save_audio_track_xml (project, track);
2282
if (!retval)
2283
goto error;
2284
2285
success = xmlTextWriterEndElement (project); /* audio */
2286
if (success < 0)
2287
goto error;
2288
}
2289
else
2290
retval = FALSE;
2291
2292
success = xmlTextWriterEndElement (project); /* track */
2293
if (success < 0)
2294
goto error;
2295
2296
success = xmlTextWriterEndElement (project); /* braseroproject */
2297
if (success < 0)
2298
goto error;
2299
2300
xmlTextWriterEndDocument (project);
2301
xmlFreeTextWriter (project);
2302
g_free (path);
2303
return TRUE;
2304
2305
error:
2306
2307
xmlTextWriterEndDocument (project);
2308
xmlFreeTextWriter (project);
2309
2310
g_remove (path);
2311
g_free (path);
2312
2313
if (use_dialog)
2314
brasero_project_not_saved_dialog (proj);
2315
2316
return FALSE;
2317
}
2318
2319
static gboolean
2320
brasero_project_save_audio_project_plain_text (BraseroProject *proj,
2321
const gchar *uri,
2322
BraseroDiscTrack *track,
2323
gboolean use_dialog)
2324
{
2325
const gchar *title;
2326
guint written;
2327
GSList *iter;
2328
gchar *path;
2329
FILE *file;
2330
2331
path = g_filename_from_uri (uri, NULL, NULL);
2332
if (!path)
2333
return FALSE;
2334
2335
file = fopen (path, "w+");
2336
g_free (path);
2337
if (!file) {
2338
if (use_dialog)
2339
brasero_project_not_saved_dialog (proj);
2340
2341
return FALSE;
2342
}
2343
2344
/* write title */
2345
title = gtk_entry_get_text (GTK_ENTRY (proj->priv->name_display));
2346
written = fwrite (title, strlen (title), 1, file);
2347
if (written != 1)
2348
goto error;
2349
2350
written = fwrite ("\n", 1, 1, file);
2351
if (written != 1)
2352
goto error;
2353
2354
for (iter = track->contents.tracks; iter; iter = iter->next) {
2355
BraseroDiscSong *song;
2356
BraseroStreamInfo *info;
2357
gchar *time;
2358
2359
song = iter->data;
2360
info = song->info;
2361
2362
written = fwrite (info->title, 1, strlen (info->title), file);
2363
if (written != strlen (info->title))
2364
goto error;
2365
2366
time = brasero_units_get_time_string (song->end - song->start, TRUE, FALSE);
2367
if (time) {
2368
written = fwrite ("\t", 1, 1, file);
2369
if (written != 1)
2370
goto error;
2371
2372
written = fwrite (time, 1, strlen (time), file);
2373
if (written != strlen (time)) {
2374
g_free (time);
2375
goto error;
2376
}
2377
g_free (time);
2378
}
2379
2380
if (info->artist) {
2381
gchar *string;
2382
2383
written = fwrite ("\t", 1, 1, file);
2384
if (written != 1)
2385
goto error;
2386
2387
/* Translators: %s is an artist */
2388
string = g_strdup_printf (" by %s", info->artist);
2389
written = fwrite (string, 1, strlen (string), file);
2390
if (written != strlen (string)) {
2391
g_free (string);
2392
goto error;
2393
}
2394
g_free (string);
2395
}
2396
2397
written = fwrite ("\n(", 1, 2, file);
2398
if (written != 2)
2399
goto error;
2400
2401
written = fwrite (song->uri, 1, strlen (song->uri), file);
2402
if (written != strlen (song->uri))
2403
goto error;
2404
2405
written = fwrite (")", 1, 1, file);
2406
if (written != 1)
2407
goto error;
2408
2409
written = fwrite ("\n\n", 1, 2, file);
2410
if (written != 2)
2411
goto error;
2412
}
2413
2414
fclose (file);
2415
return TRUE;
2416
2417
error:
2418
fclose (file);
2419
2420
if (use_dialog)
2421
brasero_project_not_saved_dialog (proj);
2422
2423
return FALSE;
2424
}
2425
2426
#ifdef BUILD_PLAYLIST
2427
2428
static void
2429
brasero_project_save_audio_playlist_entry (GtkTreeModel *model,
2430
GtkTreeIter *iter,
2431
gchar **uri,
2432
gchar **title,
2433
gboolean *custom_title,
2434
gpointer user_data)
2435
{
2436
gtk_tree_model_get (model, iter,
2437
0, uri,
2438
1, title,
2439
2, custom_title,
2440
-1);
2441
}
2442
2443
static gboolean
2444
brasero_project_save_audio_project_playlist (BraseroProject *proj,
2445
const gchar *uri,
2446
BraseroProjectSave type,
2447
BraseroDiscTrack *track,
2448
gboolean use_dialog)
2449
{
2450
TotemPlParserType pl_type;
2451
TotemPlParser *parser;
2452
GtkListStore *model;
2453
GtkTreeIter t_iter;
2454
gboolean result;
2455
GSList *iter;
2456
gchar *path;
2457
2458
path = g_filename_from_uri (uri, NULL, NULL);
2459
if (!path)
2460
return FALSE;
2461
2462
parser = totem_pl_parser_new ();
2463
2464
/* create and populate treemodel */
2465
model = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN);
2466
for (iter = track->contents.tracks; iter; iter = iter->next) {
2467
BraseroDiscSong *song;
2468
BraseroStreamInfo *info;
2469
2470
song = iter->data;
2471
info = song->info;
2472
2473
gtk_list_store_append (model, &t_iter);
2474
gtk_list_store_set (model, &t_iter,
2475
0, song->uri,
2476
1, info->title,
2477
2, TRUE,
2478
-1);
2479
}
2480
2481
switch (type) {
2482
case BRASERO_PROJECT_SAVE_PLAYLIST_M3U:
2483
pl_type = TOTEM_PL_PARSER_M3U;
2484
break;
2485
case BRASERO_PROJECT_SAVE_PLAYLIST_XSPF:
2486
pl_type = TOTEM_PL_PARSER_XSPF;
2487
break;
2488
case BRASERO_PROJECT_SAVE_PLAYLIST_IRIVER_PLA:
2489
pl_type = TOTEM_PL_PARSER_IRIVER_PLA;
2490
break;
2491
2492
case BRASERO_PROJECT_SAVE_PLAYLIST_PLS:
2493
default:
2494
pl_type = TOTEM_PL_PARSER_PLS;
2495
break;
2496
}
2497
2498
result = totem_pl_parser_write_with_title (parser,
2499
GTK_TREE_MODEL (model),
2500
brasero_project_save_audio_playlist_entry,
2501
path,
2502
gtk_entry_get_text (GTK_ENTRY (proj->priv->name_display)),
2503
pl_type,
2504
NULL,
2505
NULL);
2506
if (!result && use_dialog)
2507
brasero_project_not_saved_dialog (proj);
2508
2509
if (result)
2510
brasero_project_add_to_recents (proj, uri, FALSE);
2511
2512
g_object_unref (model);
2513
g_object_unref (parser);
2514
g_free (path);
2515
2516
return result;
2517
}
2518
2519
#endif
2520
2521
static gboolean
2522
2365
brasero_project_save_project_real (BraseroProject *project,
2523
2366
const gchar *uri,
2524
2367
BraseroProjectSave save_type)
2525
2368
{
2526
2369
BraseroDiscResult result;
2527
2370
BraseroProjectType type;
2528
BraseroDiscTrack track;
2529
2371
2530
2372
g_return_val_if_fail (uri != NULL || project->priv->project != NULL, FALSE);
2531
2373
2532
result = brasero_project_check_status (project, project->priv->current);
2533
if (result != BRASERO_DISC_OK)
2374
result = brasero_project_check_status (project);
2375
if (result != BRASERO_BURN_OK)
2534
2376
return FALSE;
2535
2377
2536
bzero (&track, sizeof (track));
2537
2538
result = brasero_disc_get_track (project->priv->current, &track);
2539
2378
if (result == BRASERO_DISC_ERROR_EMPTY_SELECTION) {
2540
2379
if (BRASERO_IS_AUDIO_DISC (project->priv->current))
2541
2380
brasero_project_no_song_dialog (project);
2549
2388
return FALSE;
2550
2389
}
2551
2390
2552
if (track.type == BRASERO_PROJECT_TYPE_AUDIO)
2553
type = BRASERO_PROJECT_TYPE_AUDIO;
2554
else if (track.type == BRASERO_PROJECT_TYPE_DATA)
2555
type = BRASERO_PROJECT_TYPE_DATA;
2556
else if (track.type == BRASERO_PROJECT_TYPE_VIDEO)
2557
type = BRASERO_PROJECT_TYPE_VIDEO;
2558
else {
2559
brasero_track_clear (&track);
2560
return BRASERO_PROJECT_TYPE_INVALID;
2561
}
2391
type = brasero_project_get_session_type (project);
2562
2392
2563
2393
if (save_type == BRASERO_PROJECT_SAVE_XML
2564
|| track.type == BRASERO_PROJECT_TYPE_DATA) {
2394
|| type == BRASERO_PROJECT_TYPE_DATA) {
2565
2395
brasero_project_set_uri (project, uri, type);
2566
if (!brasero_project_save_project_xml (project,
2567
uri ? uri : project->priv->project,
2568
&track,
2569
TRUE))
2396
if (!brasero_project_save_project_xml (BRASERO_BURN_SESSION (project->priv->session),
2397
uri ? uri : project->priv->project)) {
2398
brasero_project_not_saved_dialog (project);
2570
2399
return FALSE;
2400
}
2571
2401
2572
2402
project->priv->modified = 0;
2573
2403
}
2574
2404
else if (save_type == BRASERO_PROJECT_SAVE_PLAIN) {
2575
if (!brasero_project_save_audio_project_plain_text (project,
2576
uri,
2577
&track,
2578
TRUE))
2405
if (!brasero_project_save_audio_project_plain_text (BRASERO_BURN_SESSION (project->priv->session),
2406
uri)) {
2407
brasero_project_not_saved_dialog (project);
2579
2408
return FALSE;
2409
}
2580
2410
}
2581
2411
2582
2412
#ifdef BUILD_PLAYLIST
2583
2413
2584
2414
else {
2585
if (!brasero_project_save_audio_project_playlist (project,
2415
if (!brasero_project_save_audio_project_playlist (BRASERO_BURN_SESSION (project->priv->session),
2586
2416
uri,
2587
save_type,
2588
&track,
2589
TRUE))
2417
save_type)) {
2418
brasero_project_not_saved_dialog (project);
2590
2419
return FALSE;
2420
}
2591
2421
}
2592
2422
2593
2423
#endif
2594
2424
2595
brasero_track_clear (&track);
2596
2425
return TRUE;
2597
2426
}
2598
2427
2664
2493
gchar *uri = NULL;
2665
2494
gboolean result;
2666
2495
2496
if (!project->priv->session)
2497
return FALSE;
2498
2667
2499
if (!project->priv->project && !(uri = brasero_project_save_project_ask_for_path (project, NULL)))
2668
2500
return FALSE;
2669
2501
2680
2512
gboolean result;
2681
2513
gchar *uri;
2682
2514
2515
if (!project->priv->session)
2516
return FALSE;
2517
2683
2518
uri = brasero_project_save_project_ask_for_path (project, &type);
2684
2519
if (!uri)
2685
2520
return FALSE;
2702
2537
gchar **saved_uri,
2703
2538
gboolean show_cancel)
2704
2539
{
2705
BraseroDiscTrack track;
2540
if (!project->priv->session)
2541
return FALSE;
2706
2542
2707
2543
if (!project->priv->current) {
2708
2544
if (saved_uri)
2785
2621
return FALSE;
2786
2622
}
2787
2623
2788
bzero (&track, sizeof (track));
2789
if (brasero_disc_get_track (project->priv->current, &track) == BRASERO_DISC_OK) {
2790
/* NOTE: is this right? because brasero could not shut itself
2791
* down if an error occurs. */
2792
if (!brasero_project_save_project_xml (project,
2793
uri,
2794
&track,
2795
FALSE))
2796
return TRUE;
2797
}
2798
2799
brasero_track_clear (&track);
2624
/* NOTE: is this right? because brasero could not shut itself
2625
* down if an error occurs. */
2626
if (!brasero_project_save_project_xml (BRASERO_BURN_SESSION (project->priv->session), uri))
2627
return TRUE;
2800
2628
2801
2629
if (saved_uri)
2802
2630
*saved_uri = g_strdup (uri);
Loggerhead is a web-based interface for Breezy
Version: 2.0.1