← Back to branch summary

~mfisch/brasero/update-to-3.8.0

« back to all changes in this revision

Viewing changes to libbrasero-burn/brasero-session-cfg.c

  • Committer: Bazaar Package Importer
  • Author(s): Robert Ancell
  • Date: 2010-08-31 15:25:44 UTC
  • mfrom: (1.1.43 upstream)
  • Revision ID: james.westby@ubuntu.com-20100831152544-9lfh5n4atqc91i26
Tags: 2.31.91-0ubuntu1
* New upstream release
* debian/control:
  - Bump build-depends on libglib2.0-dev, libgconf2-dev
  - Drop build-depend on libunique
* debian/rules:
* debian/libbrasero-media0.install:
* debian/libbrasero-media1.install:
  - Update shlibs for libbrasero-media1
* debian/brasero-common.install:
  - Install gsettings files
* debian/libbrasero-media0.install:
* debian/rules:
* debian/patches/01_pkglibdir.patch:
  - Remove versioned plugin directory - the upstream build system has changed
* debian/patches/013_gsettings_backend.patch:
  - Remove hardcoded gconf gsettings backend
* debian/patches/014_plugin_directory.patch:
  - Fix plugin directory

Show diffs side-by-side

added added

removed removed

Lines of Context:
libbrasero-burn/brasero-session-cfg.c
38
38
#include <glib-object.h>
39
39
#include <glib/gi18n-lib.h>
40
40
 
41
 
#include <gconf/gconf-client.h>
42
 
 
43
41
#include "burn-basics.h"
44
42
#include "burn-debug.h"
45
43
#include "burn-plugin-manager.h"
55
53
#include "brasero-burn-lib.h"
56
54
#include "brasero-session-helper.h"
57
55
 
 
56
 
58
57
/**
59
58
 * SECTION:brasero-session-cfg
60
59
 * @short_description: Configure automatically a #BraseroBurnSession object
78
77
        guint CD_TEXT_modified:1;
79
78
        guint configuring:1;
80
79
        guint disabled:1;
81
 
 
82
 
        guint inhibit_flag_sig:1;
83
80
};
84
81
 
85
82
#define BRASERO_SESSION_CFG_PRIVATE(o)  (G_TYPE_INSTANCE_GET_PRIVATE ((o), BRASERO_TYPE_SESSION_CFG, BraseroSessionCfgPrivate))
96
93
 
97
94
G_DEFINE_TYPE (BraseroSessionCfg, brasero_session_cfg, BRASERO_TYPE_SESSION_SPAN);
98
95
 
99
 
#define BRASERO_DEST_SAVED_FLAGS                (BRASERO_DRIVE_PROPERTIES_FLAGS|BRASERO_BURN_FLAG_MULTI)
100
 
#define BRASERO_DRIVE_PROPERTIES_KEY            "/apps/brasero/drives"
101
 
 
102
96
/**
103
97
 * This is to handle tags (and more particularly video ones)
104
98
 */
368
362
}
369
363
 
370
364
/**
371
 
 * Get a key to save parameters through GConf
372
 
 */
373
 
 
374
 
static gchar *
375
 
brasero_session_cfg_get_gconf_key (BraseroSessionCfg *self,
376
 
                                   BraseroMedium *medium,
377
 
                                   const gchar *property)
378
 
{
379
 
        BraseroTrackType *type;
380
 
        BraseroDrive *drive;
381
 
        gchar *display_name;
382
 
        gchar *key = NULL;
383
 
        gchar *disc_type;
384
 
 
385
 
        if (brasero_medium_get_status (medium) == BRASERO_MEDIUM_NONE)
386
 
                return NULL;
387
 
 
388
 
        drive = brasero_medium_get_drive (medium);
389
 
 
390
 
        /* make sure display_name doesn't contain any forbidden characters */
391
 
        if (!brasero_drive_is_fake (drive)) {
392
 
                gchar *tmp;
393
 
 
394
 
                tmp = brasero_drive_get_display_name (drive);
395
 
                display_name = gconf_escape_key (tmp, -1);
396
 
                g_free (tmp);
397
 
        }
398
 
        else
399
 
                display_name = g_strdup ("File");
400
 
 
401
 
        display_name = display_name ? display_name : g_strdup ("");
402
 
 
403
 
        disc_type = gconf_escape_key (brasero_medium_get_type_string (medium), -1);
404
 
        if (!disc_type) {
405
 
                g_free (display_name);
406
 
                return NULL;
407
 
        }
408
 
 
409
 
        type = brasero_track_type_new ();
410
 
        brasero_burn_session_get_input_type (BRASERO_BURN_SESSION (self), type);
411
 
        if (brasero_track_type_get_has_medium (type))
412
 
                key = g_strdup_printf ("%s/%s/disc_%s/%s",
413
 
                                       BRASERO_DRIVE_PROPERTIES_KEY,
414
 
                                       display_name,
415
 
                                       disc_type,
416
 
                                       property);
417
 
        else if (brasero_track_type_get_has_data (type))
418
 
                key = g_strdup_printf ("%s/%s/data_%s/%s",
419
 
                                       BRASERO_DRIVE_PROPERTIES_KEY,
420
 
                                       display_name,
421
 
                                       disc_type,
422
 
                                       property);
423
 
        else if (brasero_track_type_get_has_image (type))
424
 
                key = g_strdup_printf ("%s/%s/image_%s/%s",
425
 
                                       BRASERO_DRIVE_PROPERTIES_KEY,
426
 
                                       display_name,
427
 
                                       disc_type,
428
 
                                       property);
429
 
        else if (brasero_track_type_get_has_stream (type))
430
 
                key = g_strdup_printf ("%s/%s/audio_%s/%s",
431
 
                                       BRASERO_DRIVE_PROPERTIES_KEY,
432
 
                                       display_name,
433
 
                                       disc_type,
434
 
                                       property);
435
 
        else
436
 
                key = g_strdup_printf ("%s/%s/none_%s/%s",
437
 
                                       BRASERO_DRIVE_PROPERTIES_KEY,
438
 
                                       display_name,
439
 
                                       disc_type,
440
 
                                       property);
441
 
 
442
 
        brasero_track_type_free (type);
443
 
        g_free (display_name);
444
 
        g_free (disc_type);
445
 
        return key;
446
 
}
447
 
 
448
 
/**
449
365
 * brasero_session_cfg_get_error:
450
366
 * @cfg: a #BraseroSessionCfg
451
367
 *
504
420
}
505
421
 
506
422
static void
507
 
brasero_session_cfg_save_drive_flags (BraseroSessionCfg *self,
508
 
                                      BraseroMedium *medium)
509
 
{
510
 
        BraseroSessionCfgPrivate *priv;
511
 
        BraseroBurnFlag flags;
512
 
        GConfClient *client;
513
 
        gchar *key;
514
 
 
515
 
        priv = BRASERO_SESSION_CFG_PRIVATE (self);
516
 
 
517
 
        client = gconf_client_get_default ();
518
 
        key = brasero_session_cfg_get_gconf_key (self, medium, "flags");
519
 
        if (!key) {
520
 
                g_object_unref (client);
521
 
                return;
522
 
        }
523
 
 
524
 
        flags = gconf_client_get_int (client, key, NULL);
525
 
        flags &= ~BRASERO_DEST_SAVED_FLAGS;
526
 
        flags |= (brasero_burn_session_get_flags (BRASERO_BURN_SESSION (self)) & BRASERO_DEST_SAVED_FLAGS);
527
 
        gconf_client_set_int (client, key, flags, NULL);
528
 
        g_free (key);
529
 
}
530
 
 
531
 
static void
532
 
brasero_session_cfg_save_drive_properties (BraseroSessionCfg *self,
533
 
                                           BraseroMedium *medium)
534
 
{
535
 
        BraseroSessionCfgPrivate *priv;
536
 
        GConfClient *client;
537
 
        guint64 rate;
538
 
        gchar *key;
539
 
 
540
 
        priv = BRASERO_SESSION_CFG_PRIVATE (self);
541
 
 
542
 
        brasero_session_cfg_save_drive_flags (self, medium);
543
 
 
544
 
        client = gconf_client_get_default ();
545
 
 
546
 
        rate = brasero_burn_session_get_rate (BRASERO_BURN_SESSION (self));
547
 
        key = brasero_session_cfg_get_gconf_key (self, medium, "speed");
548
 
        if (!key) {
549
 
                g_object_unref (client);
550
 
                return;
551
 
        }
552
 
 
553
 
        gconf_client_set_int (client, key, rate / 1000, NULL);
554
 
        g_free (key);
555
 
 
556
 
        g_object_unref (client);
557
 
}
558
 
 
559
 
static void
560
423
brasero_session_cfg_set_drive_properties_default_flags (BraseroSessionCfg *self)
561
424
{
562
425
        BraseroMedia media;
687
550
        media = brasero_medium_get_status (medium);
688
551
 
689
552
        /* This prevents signals to be emitted while (re-) adding them one by one */
690
 
        priv->inhibit_flag_sig = TRUE;
 
553
        g_object_freeze_notify (G_OBJECT (self));
691
554
 
692
555
        brasero_burn_session_set_flags (BRASERO_BURN_SESSION (self), BRASERO_BURN_FLAG_NONE);
693
556
 
699
562
 
700
563
        if (result != BRASERO_BURN_OK) {
701
564
                brasero_burn_session_set_flags (BRASERO_BURN_SESSION (self), original_flags | flags);
702
 
                priv->inhibit_flag_sig = FALSE;
 
565
                g_object_thaw_notify (G_OBJECT (self));
703
566
                return;
704
567
        }
705
568
 
752
615
 
753
616
        brasero_session_cfg_set_drive_properties_default_flags (self);
754
617
 
755
 
        /* allow flag changed signal again */
756
 
        priv->inhibit_flag_sig = FALSE;
757
 
 
758
 
        /* These are always supported and better be set.
759
 
         * Set them now to trigger the "flags-changed" signal */
 
618
        /* These are always supported and better be set. */
760
619
        brasero_burn_session_add_flag (BRASERO_BURN_SESSION (self),
761
620
                                       BRASERO_BURN_FLAG_CHECK_SIZE|
762
621
                                       BRASERO_BURN_FLAG_NOGRACE);
768
627
                brasero_burn_session_add_flag (BRASERO_BURN_SESSION (self),
769
628
                                               BRASERO_BURN_FLAG_EJECT);
770
629
 
771
 
        /* Always save flags */
772
 
        brasero_session_cfg_save_drive_flags (self, medium);
 
630
        /* allow notify::flags signal again */
 
631
        g_object_thaw_notify (G_OBJECT (self));
773
632
}
774
633
 
775
634
static void
791
650
}
792
651
 
793
652
static void
794
 
brasero_session_cfg_set_drive_properties (BraseroSessionCfg *self)
795
 
{
796
 
        BraseroSessionCfgPrivate *priv;
797
 
        BraseroTrackType *source;
798
 
        BraseroBurnFlag flags;
799
 
        BraseroMedium *medium;
800
 
        BraseroDrive *drive;
801
 
        GConfClient *client;
802
 
        GConfValue *value;
803
 
        guint64 rate;
804
 
        gchar *path;
805
 
        gchar *key;
806
 
 
807
 
        priv = BRASERO_SESSION_CFG_PRIVATE (self);
808
 
 
809
 
        BRASERO_BURN_LOG ("Restoring session properties");
810
 
 
811
 
        /* The next two must work as they were checked earlier */
812
 
        drive = brasero_burn_session_get_burner (BRASERO_BURN_SESSION (self));
813
 
        medium = brasero_drive_get_medium (drive);
814
 
        if (!medium || brasero_medium_get_status (medium) == BRASERO_MEDIUM_NONE) {
815
 
                BRASERO_BURN_LOG ("No media");
816
 
                return;
817
 
        }
818
 
 
819
 
        /* Update/set the rate */
820
 
        client = gconf_client_get_default ();
821
 
 
822
 
        key = brasero_session_cfg_get_gconf_key (self, medium, "speed");
823
 
        value = gconf_client_get_without_default (client, key, NULL);
824
 
        g_free (key);
825
 
 
826
 
        if (value) {
827
 
                rate = gconf_value_get_int (value) * 1000;
828
 
                gconf_value_free (value);
829
 
        }
830
 
        else
831
 
                rate = brasero_medium_get_max_write_speed (medium);
832
 
 
833
 
        brasero_burn_session_set_rate (BRASERO_BURN_SESSION (self), rate);
834
 
 
835
 
        /* Set temporary directory
836
 
         * NOTE: BraseroBurnSession can cope with NULL path */
837
 
        key = g_strdup_printf ("%s/tmpdir", BRASERO_DRIVE_PROPERTIES_KEY);
838
 
        path = gconf_client_get_string (client, key, NULL);
839
 
        g_free (key);
840
 
 
841
 
        brasero_burn_session_set_tmpdir (BRASERO_BURN_SESSION (self), path);
842
 
        g_free (path);
843
 
 
844
 
        /* Do the same with the flags.
845
 
         * NOTE: we only save/load PROPERTIES_FLAGS */
846
 
        key = brasero_session_cfg_get_gconf_key (self, medium, "flags");
847
 
        if (!key) {
848
 
                g_object_unref (client);
849
 
                return;
850
 
        }
851
 
 
852
 
        value = gconf_client_get_without_default (client, key, NULL);
853
 
        g_free (key);
854
 
 
855
 
        g_object_unref (client);
856
 
 
857
 
        source = brasero_track_type_new ();
858
 
        brasero_burn_session_get_input_type (BRASERO_BURN_SESSION (self), source);
859
 
        if (brasero_burn_session_same_src_dest_drive (BRASERO_BURN_SESSION (self))) {
860
 
                /* Special case */
861
 
                if (value) {
862
 
                        flags = gconf_value_get_int (value) & BRASERO_DEST_SAVED_FLAGS;
863
 
                        gconf_value_free (value);
864
 
                }
865
 
                else
866
 
                        flags = BRASERO_BURN_FLAG_EJECT|
867
 
                                BRASERO_BURN_FLAG_BURNPROOF;
868
 
 
869
 
                flags |= BRASERO_BURN_FLAG_BLANK_BEFORE_WRITE|
870
 
                         BRASERO_BURN_FLAG_FAST_BLANK;
871
 
        }
872
 
        else if (!value) {
873
 
                /* Set sound defaults. */
874
 
                flags = BRASERO_BURN_FLAG_EJECT|
875
 
                        BRASERO_BURN_FLAG_BURNPROOF;
876
 
 
877
 
                if (brasero_track_type_get_has_data (source)
878
 
                ||  brasero_track_type_get_has_medium (source)
879
 
                ||  brasero_track_type_get_has_image (source))
880
 
                        flags |= BRASERO_BURN_FLAG_NO_TMP_FILES;
881
 
        }
882
 
        else {
883
 
                /* set the saved flags */
884
 
                flags = gconf_value_get_int (value) & BRASERO_DEST_SAVED_FLAGS;
885
 
                gconf_value_free (value);
886
 
        }
887
 
        brasero_track_type_free (source);
888
 
 
889
 
        brasero_session_cfg_add_drive_properties_flags (self, flags);
890
 
}
891
 
 
892
 
static void
893
653
brasero_session_cfg_check_drive_settings (BraseroSessionCfg *self)
894
654
{
895
655
        BraseroSessionCfgPrivate *priv;
1275
1035
 
1276
1036
        /* Special case for video projects */
1277
1037
        if (brasero_track_type_get_has_stream (source)
1278
 
        && BRASERO_STREAM_FORMAT_HAS_VIDEO (brasero_track_type_get_stream_format (source))) {
 
1038
        &&  BRASERO_STREAM_FORMAT_HAS_VIDEO (brasero_track_type_get_stream_format (source))) {
1279
1039
                /* Only set if it was not already set */
1280
1040
                if (brasero_burn_session_tag_lookup (BRASERO_BURN_SESSION (self), BRASERO_VCD_TYPE, NULL) != BRASERO_BURN_OK)
1281
1041
                        brasero_burn_session_tag_add_int (BRASERO_BURN_SESSION (self),
1353
1113
                                  G_CALLBACK (brasero_session_cfg_session_loaded),
1354
1114
                                  session);
1355
1115
 
1356
 
        /* when that happens it's mostly because a medium source changed, or
1357
 
         * a new image was set. 
1358
 
         * - reload saved flags
1359
 
         * - check if all flags are thereafter supported
 
1116
        /* A track was added: 
 
1117
         * - check if all flags are supported
1360
1118
         * - check available formats for path
1361
1119
         * - set one path */
 
1120
        brasero_session_cfg_check_drive_settings (BRASERO_SESSION_CFG (session));
1362
1121
        brasero_session_cfg_update (BRASERO_SESSION_CFG (session));
1363
 
        brasero_session_cfg_set_drive_properties (BRASERO_SESSION_CFG (session));
1364
1122
}
1365
1123
 
1366
1124
static void
1379
1137
                                              brasero_session_cfg_session_loaded,
1380
1138
                                              session);
1381
1139
 
1382
 
        /* when that happens it's mostly because a medium source changed, or
1383
 
         * a new image was set. 
1384
 
         * - reload saved flags
1385
 
         * - check if all flags are thereafter supported
1386
 
         * - check available formats for path
1387
 
         * - set one path
1388
 
         */
 
1140
        /* If there were several tracks and at least one remained there is no
 
1141
         * use checking flags since the source type has not changed anyway.
 
1142
         * If there is no more track, there is no use checking flags anyway. */
1389
1143
        brasero_session_cfg_update (BRASERO_SESSION_CFG (session));
1390
 
        brasero_session_cfg_set_drive_properties (BRASERO_SESSION_CFG (session));
1391
1144
}
1392
1145
 
1393
1146
static void
1402
1155
 
1403
1156
        /* when that happens it's mostly because a medium source changed, or
1404
1157
         * a new image was set. 
1405
 
         * - reload saved flags
1406
 
         * - check if all flags are thereafter supported
 
1158
         * - check if all flags are supported
1407
1159
         * - check available formats for path
1408
 
         * - set one path
1409
 
         */
 
1160
         * - set one path if need be */
 
1161
        brasero_session_cfg_check_drive_settings (BRASERO_SESSION_CFG (session));
1410
1162
        brasero_session_cfg_update (BRASERO_SESSION_CFG (session));
1411
 
        brasero_session_cfg_set_drive_properties (BRASERO_SESSION_CFG (session));
1412
1163
}
1413
1164
 
1414
1165
static void
1453
1204
                                                                  BRASERO_AUDIO_FORMAT_AC3);
1454
1205
                }
1455
1206
        }
1456
 
 
1457
1207
        brasero_track_type_free (type);
1458
1208
 
1459
 
        brasero_session_cfg_save_drive_properties (BRASERO_SESSION_CFG (session),
1460
 
                                                   former);
1461
 
 
1462
1209
        /* In this case need to :
1463
 
         * - load flags 
1464
 
         * - check if all flags are thereafter supported
 
1210
         * - check if all flags are supported
1465
1211
         * - for images, set a path if it wasn't already set */
 
1212
        brasero_session_cfg_check_drive_settings (BRASERO_SESSION_CFG (session));
1466
1213
        brasero_session_cfg_update (BRASERO_SESSION_CFG (session));
1467
 
        brasero_session_cfg_set_drive_properties (BRASERO_SESSION_CFG (session));
1468
1214
}
1469
1215
 
1470
1216
static void
1478
1224
                return;
1479
1225
 
1480
1226
        /* In this case we need to check if:
1481
 
         * - new flags are supported or not supported anymore
1482
 
         * - new image types as input/output are supported
1483
 
         * - if the current set of flags/input/output still works */
1484
 
        brasero_session_cfg_update (self);
 
1227
         * - flags are supported or not supported anymore
 
1228
         * - image types as input/output are supported
 
1229
         * - if the current set of input/output still works */
1485
1230
        brasero_session_cfg_check_drive_settings (self);
1486
 
}
1487
 
 
1488
 
static void
1489
 
brasero_session_cfg_flags_changed (BraseroBurnSession *session) 
1490
 
{
1491
 
        BraseroSessionCfgPrivate *priv;
1492
 
 
1493
 
        priv = BRASERO_SESSION_CFG_PRIVATE (session);
1494
 
        if (priv->disabled)
1495
 
                return;
1496
 
 
1497
 
        /* when we update the flags we don't want a
1498
 
         * whole series of "flags-changed" emitted.
1499
 
         * so make sure there is just one at the end */
1500
 
        if (priv->inhibit_flag_sig)
1501
 
                g_signal_stop_emission_by_name (session, "flags-changed");
 
1231
        brasero_session_cfg_update (self);
1502
1232
}
1503
1233
 
1504
1234
/**
1542
1272
                                  BraseroBurnFlag flags)
1543
1273
{
1544
1274
        BraseroSessionCfgPrivate *priv;
1545
 
        BraseroDrive *drive;
1546
1275
 
1547
1276
        priv = BRASERO_SESSION_CFG_PRIVATE (self);
1548
1277
 
1553
1282
         * Example: After the removal of MULTI, FAST_BLANK
1554
1283
         * becomes available again for DVDRW sequential */
1555
1284
        brasero_session_cfg_set_drive_properties_default_flags (self);
1556
 
 
1557
 
        /* Always save flags */
1558
 
        drive = brasero_burn_session_get_burner (BRASERO_BURN_SESSION (self));
1559
 
        if (drive && brasero_drive_get_medium (drive))
1560
 
                brasero_session_cfg_save_drive_flags (self, brasero_drive_get_medium (drive));
1561
 
 
1562
1285
        brasero_session_cfg_update (self);
1563
1286
}
1564
1287
 
1624
1347
{
1625
1348
        BraseroPluginManager *manager;
1626
1349
        BraseroSessionCfgPrivate *priv;
1627
 
        BraseroDrive *drive;
1628
1350
        GSList *tracks;
1629
1351
 
1630
1352
        priv = BRASERO_SESSION_CFG_PRIVATE (object);
1631
1353
 
1632
 
        drive = brasero_burn_session_get_burner (BRASERO_BURN_SESSION (object));
1633
 
        if (drive && brasero_drive_get_medium (drive))
1634
 
                brasero_session_cfg_save_drive_properties (BRASERO_SESSION_CFG (object),
1635
 
                                                           brasero_drive_get_medium (drive));
1636
 
 
1637
1354
        tracks = brasero_burn_session_get_tracks (BRASERO_BURN_SESSION (object));
1638
1355
        for (; tracks; tracks = tracks->next) {
1639
1356
                BraseroTrack *track;
1670
1387
        session_class->track_removed = brasero_session_cfg_track_removed;
1671
1388
        session_class->track_changed = brasero_session_cfg_track_changed;
1672
1389
        session_class->output_changed = brasero_session_cfg_output_changed;
1673
 
        session_class->flags_changed = brasero_session_cfg_flags_changed;
1674
1390
        session_class->tag_changed = brasero_session_cfg_tag_changed;
1675
1391
 
1676
1392
        session_cfg_signals [WRONG_EXTENSION_SIGNAL] =