1
/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
4
* Copyright (C) Philippe Rouquier 2008 <bonfire-app@wanadoo.fr>
6
* brasero is free software: you can redistribute it and/or modify it
7
* under the terms of the GNU General Public License as published by the
8
* Free Software Foundation, either version 3 of the License, or
9
* (at your option) any later version.
11
* brasero is distributed in the hope that it will be useful, but
12
* WITHOUT ANY WARRANTY; without even the implied warranty of
13
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
14
* See the GNU General Public License for more details.
16
* You should have received a copy of the GNU General Public License along
17
* with this program. If not, see <http://www.gnu.org/licenses/>.
27
#include <glib-object.h>
28
#include <glib/gi18n-lib.h>
30
#include <gconf/gconf-client.h>
32
#include "burn-basics.h"
33
#include "burn-debug.h"
34
#include "burn-plugin-manager.h"
35
#include "burn-session.h"
36
#include "burn-caps.h"
37
#include "burn-plugin-manager.h"
38
#include "burn-image-format.h"
40
#include "brasero-session-cfg.h"
42
typedef struct _BraseroSessionCfgPrivate BraseroSessionCfgPrivate;
43
struct _BraseroSessionCfgPrivate
45
BraseroBurnCaps *caps;
47
BraseroBurnFlag supported;
48
BraseroBurnFlag compulsory;
54
BraseroSessionError is_valid;
56
guint CD_TEXT_modified:1;
61
#define BRASERO_SESSION_CFG_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), BRASERO_TYPE_SESSION_CFG, BraseroSessionCfgPrivate))
70
static guint session_cfg_signals [LAST_SIGNAL] = { 0 };
72
G_DEFINE_TYPE (BraseroSessionCfg, brasero_session_cfg, BRASERO_TYPE_BURN_SESSION);
74
#define BRASERO_DEST_SAVED_FLAGS (BRASERO_DRIVE_PROPERTIES_FLAGS|BRASERO_BURN_FLAG_MULTI)
75
#define BRASERO_DRIVE_PROPERTIES_KEY "/apps/brasero/drives"
78
* Get a key to save parameters through GConf
82
brasero_session_cfg_get_gconf_key (BraseroSessionCfg *self,
83
const gchar *property)
85
BraseroMedium *medium;
91
drive = brasero_burn_session_get_burner (BRASERO_BURN_SESSION (self));
95
medium = brasero_drive_get_medium (drive);
96
if (brasero_medium_get_status (medium) == BRASERO_MEDIUM_NONE)
99
/* make sure display_name doesn't contain any forbidden characters */
100
if (!brasero_drive_is_fake (drive)) {
103
tmp = brasero_drive_get_display_name (drive);
104
display_name = gconf_escape_key (tmp, -1);
108
display_name = g_strdup ("File");
110
display_name = display_name ? display_name : "";
112
disc_type = gconf_escape_key (brasero_medium_get_type_string (medium), -1);
114
g_free (display_name);
118
switch (brasero_burn_session_get_input_type (BRASERO_BURN_SESSION (self), NULL)) {
119
case BRASERO_TRACK_TYPE_NONE:
120
key = g_strdup_printf ("%s/%s/none_%s/%s",
121
BRASERO_DRIVE_PROPERTIES_KEY,
126
case BRASERO_TRACK_TYPE_DISC:
127
key = g_strdup_printf ("%s/%s/disc_%s/%s",
128
BRASERO_DRIVE_PROPERTIES_KEY,
134
case BRASERO_TRACK_TYPE_DATA:
135
key = g_strdup_printf ("%s/%s/data_%s/%s",
136
BRASERO_DRIVE_PROPERTIES_KEY,
142
case BRASERO_TRACK_TYPE_IMAGE:
143
key = g_strdup_printf ("%s/%s/image_%s/%s",
144
BRASERO_DRIVE_PROPERTIES_KEY,
150
case BRASERO_TRACK_TYPE_AUDIO:
151
key = g_strdup_printf ("%s/%s/audio_%s/%s",
152
BRASERO_DRIVE_PROPERTIES_KEY,
161
g_free (display_name);
167
brasero_session_cfg_get_error (BraseroSessionCfg *self)
169
BraseroSessionCfgPrivate *priv;
171
priv = BRASERO_SESSION_CFG_PRIVATE (self);
173
if (priv->is_valid == BRASERO_SESSION_VALID
174
&& priv->CD_TEXT_modified)
175
return BRASERO_SESSION_NO_CD_TEXT;
177
return priv->is_valid;
181
brasero_session_cfg_disable (BraseroSessionCfg *self)
183
BraseroSessionCfgPrivate *priv;
185
priv = BRASERO_SESSION_CFG_PRIVATE (self);
186
priv->disabled = TRUE;
190
brasero_session_cfg_save_drive_properties (BraseroSessionCfg *self)
192
BraseroSessionCfgPrivate *priv;
193
BraseroBurnFlag flags;
199
priv = BRASERO_SESSION_CFG_PRIVATE (self);
201
client = gconf_client_get_default ();
203
rate = brasero_burn_session_get_rate (BRASERO_BURN_SESSION (self));
204
key = brasero_session_cfg_get_gconf_key (self, "speed");
206
g_object_unref (client);
210
gconf_client_set_int (client, key, rate / 1000, NULL);
213
key = brasero_session_cfg_get_gconf_key (self, "flags");
215
g_object_unref (client);
219
flags = gconf_client_get_int (client, key, NULL);
220
flags &= ~BRASERO_DEST_SAVED_FLAGS;
221
flags |= (brasero_burn_session_get_flags (BRASERO_BURN_SESSION (self)) & BRASERO_DEST_SAVED_FLAGS);
222
gconf_client_set_int (client, key, flags, NULL);
225
/* temporary directory */
226
path = brasero_burn_session_get_tmpdir (BRASERO_BURN_SESSION (self));
227
key = g_strdup_printf ("%s/tmpdir", BRASERO_DRIVE_PROPERTIES_KEY);
228
gconf_client_set_string (client, key, path, NULL);
231
g_object_unref (client);
235
brasero_session_cfg_add_drive_properties_flags (BraseroSessionCfg *self,
236
BraseroBurnFlag flags)
239
BraseroBurnFlag flag;
240
BraseroBurnResult result;
241
BraseroSessionCfgPrivate *priv;
243
priv = BRASERO_SESSION_CFG_PRIVATE (self);
245
media = brasero_burn_session_get_dest_media (BRASERO_BURN_SESSION (self));
247
/* add flags then wipe out flags from session to check them one by one */
248
flags |= brasero_burn_session_get_flags (BRASERO_BURN_SESSION (self));
249
brasero_burn_session_remove_flag (BRASERO_BURN_SESSION (self), flags);
251
priv->supported = BRASERO_BURN_FLAG_NONE;
252
priv->compulsory = BRASERO_BURN_FLAG_NONE;
253
result = brasero_burn_caps_get_flags (priv->caps,
254
BRASERO_BURN_SESSION (self),
257
if (result != BRASERO_BURN_OK) {
258
brasero_burn_session_set_flags (BRASERO_BURN_SESSION (self), flags);
262
/* These are always supported and better be set. */
263
brasero_burn_session_set_flags (BRASERO_BURN_SESSION (self),
264
BRASERO_BURN_FLAG_DONT_OVERWRITE|
265
BRASERO_BURN_FLAG_CHECK_SIZE|
266
BRASERO_BURN_FLAG_NOGRACE);
268
for (flag = BRASERO_BURN_FLAG_EJECT; flag < BRASERO_BURN_FLAG_LAST; flag <<= 1) {
269
/* see if this flag was originally set */
273
/* Don't set write modes now in this case */
274
if (brasero_burn_session_same_src_dest_drive (BRASERO_BURN_SESSION (self))
275
&& (flag & (BRASERO_BURN_FLAG_DAO|BRASERO_BURN_FLAG_RAW)))
279
&& (priv->compulsory & brasero_burn_session_get_flags (BRASERO_BURN_SESSION (self))) != priv->compulsory) {
280
brasero_burn_session_add_flag (BRASERO_BURN_SESSION (self), priv->compulsory);
282
priv->supported = BRASERO_BURN_FLAG_NONE;
283
priv->compulsory = BRASERO_BURN_FLAG_NONE;
284
brasero_burn_caps_get_flags (priv->caps,
285
BRASERO_BURN_SESSION (self),
290
if (priv->supported & flag) {
291
brasero_burn_session_add_flag (BRASERO_BURN_SESSION (self), flag);
293
priv->supported = BRASERO_BURN_FLAG_NONE;
294
priv->compulsory = BRASERO_BURN_FLAG_NONE;
295
brasero_burn_caps_get_flags (priv->caps,
296
BRASERO_BURN_SESSION (self),
302
if (BRASERO_MEDIUM_IS (media, BRASERO_MEDIUM_DVDRW_PLUS)
303
|| BRASERO_MEDIUM_IS (media, BRASERO_MEDIUM_DVDRW_RESTRICTED)
304
|| BRASERO_MEDIUM_IS (media, BRASERO_MEDIUM_DVDRW_PLUS_DL)) {
305
/* This is a special case to favour libburn/growisofs
306
* wodim/cdrecord for these types of media. */
307
if (priv->supported & BRASERO_BURN_FLAG_MULTI) {
308
brasero_burn_session_add_flag (BRASERO_BURN_SESSION (self),
309
BRASERO_BURN_FLAG_MULTI);
311
priv->supported = BRASERO_BURN_FLAG_NONE;
312
priv->compulsory = BRASERO_BURN_FLAG_NONE;
313
brasero_burn_caps_get_flags (priv->caps,
314
BRASERO_BURN_SESSION (self),
320
/* Always set this flag whenever possible */
321
if (priv->supported & BRASERO_BURN_FLAG_BLANK_BEFORE_WRITE) {
322
brasero_burn_session_add_flag (BRASERO_BURN_SESSION (self),
323
BRASERO_BURN_FLAG_BLANK_BEFORE_WRITE);
325
if (priv->supported & BRASERO_BURN_FLAG_FAST_BLANK)
326
brasero_burn_session_add_flag (BRASERO_BURN_SESSION (self),
327
BRASERO_BURN_FLAG_FAST_BLANK);
329
priv->supported = BRASERO_BURN_FLAG_NONE;
330
priv->compulsory = BRASERO_BURN_FLAG_NONE;
331
brasero_burn_caps_get_flags (priv->caps,
332
BRASERO_BURN_SESSION (self),
337
/* When copying with same drive don't set write mode, it'll be set later */
338
if (!brasero_burn_session_same_src_dest_drive (BRASERO_BURN_SESSION (self))) {
339
/* use DAO whenever it's possible */
340
if (priv->supported & BRASERO_BURN_FLAG_DAO) {
341
brasero_burn_session_add_flag (BRASERO_BURN_SESSION (self), BRASERO_BURN_FLAG_DAO);
343
priv->supported = BRASERO_BURN_FLAG_NONE;
344
priv->compulsory = BRASERO_BURN_FLAG_NONE;
345
brasero_burn_caps_get_flags (priv->caps,
346
BRASERO_BURN_SESSION (self),
350
/* NOTE: after setting DAO, some flags may become
351
* compulsory like BLANK_BEFORE for CDRW with data */
355
/* Always save flags */
356
brasero_session_cfg_save_drive_properties (self);
360
brasero_session_cfg_set_drive_properties (BraseroSessionCfg *self)
362
BraseroTrackType source = { 0, };
363
BraseroSessionCfgPrivate *priv;
364
BraseroBurnFlag flags;
365
BraseroMedium *medium;
373
priv = BRASERO_SESSION_CFG_PRIVATE (self);
375
/* The next two must work as they were checked earlier */
376
brasero_burn_session_get_input_type (BRASERO_BURN_SESSION (self), &source);
377
drive = brasero_burn_session_get_burner (BRASERO_BURN_SESSION (self));
379
medium = brasero_drive_get_medium (drive);
380
if (!medium || brasero_medium_get_status (medium) == BRASERO_MEDIUM_NONE)
383
/* Update/set the rate */
384
client = gconf_client_get_default ();
386
key = brasero_session_cfg_get_gconf_key (self, "speed");
387
value = gconf_client_get_without_default (client, key, NULL);
391
rate = gconf_value_get_int (value) * 1000;
392
gconf_value_free (value);
395
rate = brasero_medium_get_max_write_speed (medium);
397
brasero_burn_session_set_rate (BRASERO_BURN_SESSION (self), rate);
399
/* Set temporary directory
400
* NOTE: BraseroBurnSession can cope with NULL path */
401
key = g_strdup_printf ("%s/tmpdir", BRASERO_DRIVE_PROPERTIES_KEY);
402
path = gconf_client_get_string (client, key, NULL);
405
brasero_burn_session_set_tmpdir (BRASERO_BURN_SESSION (self), path);
408
/* Do the same with the flags.
409
* NOTE: we only save/load PROPERTIES_FLAGS */
410
key = brasero_session_cfg_get_gconf_key (self, "flags");
412
g_object_unref (client);
416
value = gconf_client_get_without_default (client, key, NULL);
419
g_object_unref (client);
421
if (brasero_burn_session_same_src_dest_drive (BRASERO_BURN_SESSION (self))) {
424
flags = gconf_value_get_int (value) & BRASERO_DEST_SAVED_FLAGS;
425
gconf_value_free (value);
428
flags = BRASERO_BURN_FLAG_EJECT|
429
BRASERO_BURN_FLAG_BURNPROOF;
431
flags |= BRASERO_BURN_FLAG_BLANK_BEFORE_WRITE|
432
BRASERO_BURN_FLAG_FAST_BLANK;
435
/* Set sound defaults. */
436
flags = BRASERO_BURN_FLAG_EJECT|
437
BRASERO_BURN_FLAG_BURNPROOF;
439
if (source.type == BRASERO_TRACK_TYPE_DATA
440
|| source.type == BRASERO_TRACK_TYPE_DISC
441
|| source.type == BRASERO_TRACK_TYPE_IMAGE)
442
flags |= BRASERO_BURN_FLAG_NO_TMP_FILES;
445
/* set the saved flags */
446
flags = gconf_value_get_int (value) & BRASERO_DEST_SAVED_FLAGS;
447
gconf_value_free (value);
450
brasero_session_cfg_add_drive_properties_flags (self, flags);
454
brasero_session_cfg_check_drive_settings (BraseroSessionCfg *self)
456
BraseroSessionCfgPrivate *priv;
457
BraseroBurnFlag flags;
459
priv = BRASERO_SESSION_CFG_PRIVATE (self);
461
/* Try to properly update the flags for the current drive */
462
flags = brasero_burn_session_get_flags (BRASERO_BURN_SESSION (self));
463
if (brasero_burn_session_same_src_dest_drive (BRASERO_BURN_SESSION (self))) {
464
flags |= BRASERO_BURN_FLAG_BLANK_BEFORE_WRITE|
465
BRASERO_BURN_FLAG_FAST_BLANK;
468
/* check each flag before re-adding it */
469
brasero_session_cfg_add_drive_properties_flags (self, flags);
472
static BraseroSessionError
473
brasero_session_cfg_check_size (BraseroSessionCfg *self)
475
BraseroSessionCfgPrivate *priv;
476
BraseroBurnFlag flags;
477
BraseroMedium *medium;
478
BraseroDrive *burner;
479
GValue *value = NULL;
486
priv = BRASERO_SESSION_CFG_PRIVATE (self);
488
burner = brasero_burn_session_get_burner (BRASERO_BURN_SESSION (self));
490
priv->is_valid = BRASERO_SESSION_NO_OUTPUT;
491
return BRASERO_SESSION_NO_OUTPUT;
494
/* FIXME: here we could check the hard drive space */
495
if (brasero_drive_is_fake (burner)) {
496
priv->is_valid = BRASERO_SESSION_VALID;
497
return BRASERO_SESSION_VALID;
500
medium = brasero_drive_get_medium (burner);
502
priv->is_valid = BRASERO_SESSION_NO_OUTPUT;
503
return BRASERO_SESSION_NO_OUTPUT;
506
flags = brasero_burn_session_get_flags (BRASERO_BURN_SESSION (self));
507
if (flags & (BRASERO_BURN_FLAG_MERGE|BRASERO_BURN_FLAG_APPEND))
508
brasero_medium_get_free_space (medium, NULL, &disc_size);
510
brasero_medium_get_capacity (medium, NULL, &disc_size);
515
/* get input track size */
516
iter = brasero_burn_session_get_tracks (BRASERO_BURN_SESSION (self));
519
if (brasero_burn_session_tag_lookup (BRASERO_BURN_SESSION (self),
520
BRASERO_DATA_TRACK_SIZE_TAG,
521
&value) == BRASERO_BURN_OK) {
522
session_size = g_value_get_int64 (value);
524
else if (brasero_burn_session_tag_lookup (BRASERO_BURN_SESSION (self),
525
BRASERO_AUDIO_TRACK_SIZE_TAG,
526
&value) == BRASERO_BURN_OK) {
527
session_size = g_value_get_int64 (value);
529
else for (; iter; iter = iter->next) {
530
BraseroTrackDataType type;
537
type = brasero_track_get_type (track, NULL);
538
if (type == BRASERO_TRACK_TYPE_DISC)
539
brasero_track_get_disc_data_size (track, §ors, NULL);
540
else if (type == BRASERO_TRACK_TYPE_IMAGE)
541
brasero_track_get_image_size (track, NULL, §ors, NULL, NULL);
542
else if (type == BRASERO_TRACK_TYPE_AUDIO) {
545
brasero_track_get_audio_length (track, &len);
546
sectors = BRASERO_DURATION_TO_SECTORS (len);
549
session_size += sectors;
552
BRASERO_BURN_LOG ("Session size %lli/Disc size %lli",
556
if (session_size < disc_size) {
557
priv->is_valid = BRASERO_SESSION_VALID;
558
return BRASERO_SESSION_VALID;
561
/* FIXME: This is not good since with a DVD 3% of 4.3G may be too much
562
* with 3% we are slightly over the limit of the most overburnable discs
563
* but at least users can try to overburn as much as they can. */
565
/* The idea would be to test write the disc with cdrecord from /dev/null
566
* until there is an error and see how much we were able to write. So,
567
* when we propose overburning to the user, we could ask if he wants
568
* us to determine how much data can be written to a particular disc
569
* provided he has chosen a real disc. */
570
max_sectors = disc_size * 103 / 100;
571
if (max_sectors < session_size) {
572
priv->is_valid = BRASERO_SESSION_INSUFFICIENT_SPACE;
573
return BRASERO_SESSION_INSUFFICIENT_SPACE;
576
if (!(flags & BRASERO_BURN_FLAG_OVERBURN)) {
577
BraseroSessionCfgPrivate *priv;
579
priv = BRASERO_SESSION_CFG_PRIVATE (self);
581
if (!(priv->supported & BRASERO_BURN_FLAG_OVERBURN)) {
582
priv->is_valid = BRASERO_SESSION_INSUFFICIENT_SPACE;
583
return BRASERO_SESSION_INSUFFICIENT_SPACE;
586
priv->is_valid = BRASERO_SESSION_OVERBURN_NECESSARY;
587
return BRASERO_SESSION_OVERBURN_NECESSARY;
590
priv->is_valid = BRASERO_SESSION_VALID;
591
return BRASERO_SESSION_VALID;
595
brasero_session_cfg_update (BraseroSessionCfg *self,
599
BraseroSessionCfgPrivate *priv;
600
BraseroTrackType source = { 0, };
601
BraseroBurnResult result;
602
BraseroDrive *burner;
604
priv = BRASERO_SESSION_CFG_PRIVATE (self);
606
if (priv->configuring)
609
/* Make sure there is a source */
610
brasero_burn_session_get_input_type (BRASERO_BURN_SESSION (self), &source);
611
if (source.type == BRASERO_TRACK_TYPE_NONE) {
612
priv->is_valid = BRASERO_SESSION_NOT_SUPPORTED;
614
session_cfg_signals [IS_VALID_SIGNAL],
619
if (source.type == BRASERO_TRACK_TYPE_DISC
620
&& source.subtype.media == BRASERO_MEDIUM_NONE) {
621
priv->is_valid = BRASERO_SESSION_NO_INPUT_MEDIUM;
623
session_cfg_signals [IS_VALID_SIGNAL],
628
if (source.type == BRASERO_TRACK_TYPE_IMAGE
629
&& source.subtype.img_format == BRASERO_IMAGE_FORMAT_NONE) {
633
tracks = brasero_burn_session_get_tracks (BRASERO_BURN_SESSION (self));
635
/* It can be two cases:
637
* - image format cannot be detected */
641
track = tracks->data;
642
uri = brasero_track_get_image_source (track, TRUE);
644
priv->is_valid = BRASERO_SESSION_UNKNOWN_IMAGE;
648
priv->is_valid = BRASERO_SESSION_NO_INPUT_IMAGE;
651
priv->is_valid = BRASERO_SESSION_NO_INPUT_IMAGE;
654
session_cfg_signals [IS_VALID_SIGNAL],
659
/* FIXME: another easy error to catch: AUDIO project with a DVD */
661
/* make sure there is an output set */
662
burner = brasero_burn_session_get_burner (BRASERO_BURN_SESSION (self));
664
priv->is_valid = BRASERO_SESSION_NO_OUTPUT;
666
session_cfg_signals [IS_VALID_SIGNAL],
671
/* Check that current input and output work */
672
if (priv->CD_TEXT_modified) {
673
/* Try to redo what we undid (after all a new plugin could have
674
* been activated in the mean time ...) and see what happens */
675
source.subtype.audio_format |= BRASERO_METADATA_INFO;
676
result = brasero_burn_caps_is_input_supported (priv->caps,
677
BRASERO_BURN_SESSION (self),
680
if (result == BRASERO_BURN_OK) {
681
priv->CD_TEXT_modified = FALSE;
683
priv->configuring = TRUE;
684
brasero_burn_session_set_input_type (BRASERO_BURN_SESSION (self), &source);
685
priv->configuring = FALSE;
688
/* No, nothing's changed */
689
source.subtype.audio_format &= ~BRASERO_METADATA_INFO;
690
result = brasero_burn_caps_is_input_supported (priv->caps,
691
BRASERO_BURN_SESSION (self),
697
/* Don't use flags as they'll be adapted later. */
698
result = brasero_burn_caps_is_session_supported (priv->caps,
699
BRASERO_BURN_SESSION (self),
701
if (result != BRASERO_BURN_OK
702
&& source.type == BRASERO_TRACK_TYPE_AUDIO
703
&& (source.subtype.audio_format & BRASERO_METADATA_INFO)) {
704
/* Another special case in case some burning backends
705
* don't support CD-TEXT for audio (libburn). If no
706
* other backend is available remove CD-TEXT option but
708
source.subtype.audio_format &= ~BRASERO_METADATA_INFO;
709
result = brasero_burn_caps_is_input_supported (priv->caps,
710
BRASERO_BURN_SESSION (self),
713
BRASERO_BURN_LOG ("Tested support without Metadata information (result %d)", result);
714
if (result == BRASERO_BURN_OK) {
715
priv->CD_TEXT_modified = TRUE;
717
priv->configuring = TRUE;
718
brasero_burn_session_set_input_type (BRASERO_BURN_SESSION (self), &source);
719
priv->configuring = FALSE;
724
if (result != BRASERO_BURN_OK) {
725
if (source.type == BRASERO_TRACK_TYPE_DISC
726
&& (source.subtype.media & BRASERO_MEDIUM_PROTECTED)
727
&& brasero_track_type_is_supported (&source) != BRASERO_BURN_OK) {
728
/* This is a special case to display a helpful message */
729
priv->is_valid = BRASERO_SESSION_DISC_PROTECTED;
731
session_cfg_signals [IS_VALID_SIGNAL],
735
priv->is_valid = BRASERO_SESSION_NOT_SUPPORTED;
737
session_cfg_signals [IS_VALID_SIGNAL],
744
/* Configure flags */
745
priv->configuring = TRUE;
747
if (brasero_drive_is_fake (burner))
748
/* Remove some impossible flags */
749
brasero_burn_session_remove_flag (BRASERO_BURN_SESSION (self),
750
BRASERO_BURN_FLAG_DUMMY|
751
BRASERO_BURN_FLAG_NO_TMP_FILES);
754
brasero_session_cfg_set_drive_properties (self);
756
brasero_session_cfg_check_drive_settings (self);
758
priv->configuring = FALSE;
760
/* Finally check size */
761
if (brasero_burn_session_same_src_dest_drive (BRASERO_BURN_SESSION (self))) {
762
priv->is_valid = BRASERO_SESSION_VALID;
764
session_cfg_signals [IS_VALID_SIGNAL],
768
brasero_session_cfg_check_size (self);
770
session_cfg_signals [IS_VALID_SIGNAL],
776
brasero_session_cfg_input_changed (BraseroBurnSession *session)
778
BraseroSessionCfgPrivate *priv;
780
priv = BRASERO_SESSION_CFG_PRIVATE (session);
784
/* when that happens it's mostly because a medium source changed, or
785
* a new image was set.
786
* - reload saved flags
787
* - check if all flags are thereafter supported
788
* - check available formats for path
791
brasero_session_cfg_update (BRASERO_SESSION_CFG (session),
797
brasero_session_cfg_output_changed (BraseroBurnSession *session)
799
BraseroSessionCfgPrivate *priv;
801
priv = BRASERO_SESSION_CFG_PRIVATE (session);
805
/* In this case need to :
807
* - check if all flags are thereafter supported
808
* - for images, set a path if it wasn't already set
810
brasero_session_cfg_update (BRASERO_SESSION_CFG (session),
816
brasero_session_cfg_caps_changed (BraseroPluginManager *manager,
817
BraseroSessionCfg *self)
819
BraseroSessionCfgPrivate *priv;
821
priv = BRASERO_SESSION_CFG_PRIVATE (self);
825
/* In this case we need to check if:
826
* - new flags are supported or not supported anymore
827
* - new image types as input/output are supported
828
* - if the current set of flags/input/output still works */
829
brasero_session_cfg_update (self,
835
brasero_session_cfg_add_flags (BraseroSessionCfg *self,
836
BraseroBurnFlag flags)
838
BraseroSessionCfgPrivate *priv;
840
priv = BRASERO_SESSION_CFG_PRIVATE (self);
842
if ((priv->supported & flags) != flags)
845
if ((brasero_burn_session_get_flags (BRASERO_BURN_SESSION (self)) & flags) == flags)
848
brasero_burn_session_add_flag (BRASERO_BURN_SESSION (self), flags);
849
priv->supported = BRASERO_BURN_FLAG_NONE;
850
priv->compulsory = BRASERO_BURN_FLAG_NONE;
851
brasero_burn_caps_get_flags (priv->caps,
852
BRASERO_BURN_SESSION (self),
856
/* Always save flags */
857
brasero_session_cfg_save_drive_properties (self);
859
brasero_session_cfg_update (self,
865
brasero_session_cfg_remove_flags (BraseroSessionCfg *self,
866
BraseroBurnFlag flags)
868
BraseroSessionCfgPrivate *priv;
870
priv = BRASERO_SESSION_CFG_PRIVATE (self);
872
brasero_burn_session_remove_flag (BRASERO_BURN_SESSION (self), flags);
873
priv->supported = BRASERO_BURN_FLAG_NONE;
874
priv->compulsory = BRASERO_BURN_FLAG_NONE;
875
brasero_burn_caps_get_flags (priv->caps,
876
BRASERO_BURN_SESSION (self),
880
/* Always save flags */
881
brasero_session_cfg_save_drive_properties (self);
883
brasero_session_cfg_update (self,
889
brasero_session_cfg_is_supported (BraseroSessionCfg *self,
890
BraseroBurnFlag flags)
892
BraseroSessionCfgPrivate *priv;
894
priv = BRASERO_SESSION_CFG_PRIVATE (self);
895
return (priv->supported & flags) == flags;
899
brasero_session_cfg_is_compulsory (BraseroSessionCfg *self,
900
BraseroBurnFlag flags)
902
BraseroSessionCfgPrivate *priv;
904
priv = BRASERO_SESSION_CFG_PRIVATE (self);
905
return (priv->compulsory & flags) == flags;
909
brasero_session_cfg_init (BraseroSessionCfg *object)
911
BraseroSessionCfgPrivate *priv;
912
BraseroPluginManager *manager;
914
priv = BRASERO_SESSION_CFG_PRIVATE (object);
916
priv->caps = brasero_burn_caps_get_default ();
918
manager = brasero_plugin_manager_get_default ();
919
priv->caps_sig = g_signal_connect (manager,
921
G_CALLBACK (brasero_session_cfg_caps_changed),
926
brasero_session_cfg_finalize (GObject *object)
928
BraseroSessionCfgPrivate *priv;
930
priv = BRASERO_SESSION_CFG_PRIVATE (object);
932
if (priv->caps_sig) {
933
BraseroPluginManager *manager;
935
manager = brasero_plugin_manager_get_default ();
936
g_signal_handler_disconnect (manager, priv->caps_sig);
941
g_object_unref (priv->caps);
945
G_OBJECT_CLASS (brasero_session_cfg_parent_class)->finalize (object);
949
brasero_session_cfg_class_init (BraseroSessionCfgClass *klass)
951
GObjectClass* object_class = G_OBJECT_CLASS (klass);
952
BraseroBurnSessionClass *session_class = BRASERO_BURN_SESSION_CLASS (klass);
954
g_type_class_add_private (klass, sizeof (BraseroSessionCfgPrivate));
956
object_class->finalize = brasero_session_cfg_finalize;
958
session_class->input_changed = brasero_session_cfg_input_changed;
959
session_class->output_changed = brasero_session_cfg_output_changed;
961
session_cfg_signals[IS_VALID_SIGNAL] =
962
g_signal_new ("is_valid",
963
G_OBJECT_CLASS_TYPE (klass),
964
G_SIGNAL_RUN_LAST | G_SIGNAL_RUN_CLEANUP | G_SIGNAL_ACTION,
967
g_cclosure_marshal_VOID__VOID,
974
brasero_session_cfg_new (void)
976
return g_object_new (BRASERO_TYPE_SESSION_CFG, NULL);
added
removed
src/brasero-session-cfg.c
