GNOME.org
 

[brasero/gnome-2-30] Optimization for session configuration object

commit 7b3ad4adf98ee3cfb247aa38ccf3f7913f1566f2
Author: Philippe Rouquier <bonfire-app wanadoo fr>
Date:   Sat Oct 9 15:17:00 2010 +0200

    Optimization for session configuration object

 libbrasero-burn/brasero-session-cfg.c |  264 +++++++++++++++++++--------------
 1 files changed, 156 insertions(+), 108 deletions(-)
---
diff --git a/libbrasero-burn/brasero-session-cfg.c b/libbrasero-burn/brasero-session-cfg.c
index ebf7cc8..55ed18f 100644
--- a/libbrasero-burn/brasero-session-cfg.c
+++ b/libbrasero-burn/brasero-session-cfg.c
@@ -73,6 +73,11 @@ struct _BraseroSessionCfgPrivate
 
 	gchar *output;
 
+	/* Do some caching to improve performances */
+	BraseroTrackType *source;
+	goffset disc_size;
+	goffset session_size;
+
 	BraseroSessionError is_valid;
 
 	guint CD_TEXT_modified:1;
@@ -376,7 +381,7 @@ brasero_session_cfg_get_gconf_key (BraseroSessionCfg *self,
 				   BraseroMedium *medium,
 				   const gchar *property)
 {
-	BraseroTrackType *type;
+	BraseroSessionCfgPrivate *priv;
 	BraseroDrive *drive;
 	gchar *display_name;
 	gchar *key = NULL;
@@ -406,27 +411,26 @@ brasero_session_cfg_get_gconf_key (BraseroSessionCfg *self,
 		return NULL;
 	}
 
-	type = brasero_track_type_new ();
-	brasero_burn_session_get_input_type (BRASERO_BURN_SESSION (self), type);
-	if (brasero_track_type_get_has_medium (type))
+	priv = BRASERO_SESSION_CFG_PRIVATE (self);
+	if (brasero_track_type_get_has_medium (priv->source))
 		key = g_strdup_printf ("%s/%s/disc_%s/%s",
 				       BRASERO_DRIVE_PROPERTIES_KEY,
 				       display_name,
 				       disc_type,
 				       property);
-	else if (brasero_track_type_get_has_data (type))
+	else if (brasero_track_type_get_has_data (priv->source))
 		key = g_strdup_printf ("%s/%s/data_%s/%s",
 				       BRASERO_DRIVE_PROPERTIES_KEY,
 				       display_name,
 				       disc_type,
 				       property);
-	else if (brasero_track_type_get_has_image (type))
+	else if (brasero_track_type_get_has_image (priv->source))
 		key = g_strdup_printf ("%s/%s/image_%s/%s",
 				       BRASERO_DRIVE_PROPERTIES_KEY,
 				       display_name,
 				       disc_type,
 				       property);
-	else if (brasero_track_type_get_has_stream (type))
+	else if (brasero_track_type_get_has_stream (priv->source))
 		key = g_strdup_printf ("%s/%s/audio_%s/%s",
 				       BRASERO_DRIVE_PROPERTIES_KEY,
 				       display_name,
@@ -439,7 +443,6 @@ brasero_session_cfg_get_gconf_key (BraseroSessionCfg *self,
 				       disc_type,
 				       property);
 
-	brasero_track_type_free (type);
 	g_free (display_name);
 	g_free (disc_type);
 	return key;
@@ -668,6 +671,16 @@ brasero_session_cfg_set_drive_properties_flags (BraseroSessionCfg *self,
 	priv = BRASERO_SESSION_CFG_PRIVATE (self);
 
 	original_flags = brasero_burn_session_get_flags (BRASERO_BURN_SESSION (self));
+
+	/* If the session is invalid no need to check the flags: just add them.
+	 * The correct flags will be re-computed anyway when the session becomes
+	 * valid again. */
+	if (priv->is_valid != BRASERO_SESSION_VALID) {
+		BRASERO_BURN_LOG ("Session not ready for flag computation currently: adding flags (will update later)");
+		brasero_burn_session_set_flags (BRASERO_BURN_SESSION (self), flags);
+		return;
+	}
+
 	BRASERO_BURN_LOG ("Resetting all flags");
 	BRASERO_BURN_LOG_FLAGS (original_flags, "Current are");
 	BRASERO_BURN_LOG_FLAGS (flags, "New should be");
@@ -794,7 +807,6 @@ static void
 brasero_session_cfg_set_drive_properties (BraseroSessionCfg *self)
 {
 	BraseroSessionCfgPrivate *priv;
-	BraseroTrackType *source;
 	BraseroBurnFlag flags;
 	BraseroMedium *medium;
 	BraseroDrive *drive;
@@ -854,8 +866,6 @@ brasero_session_cfg_set_drive_properties (BraseroSessionCfg *self)
 
 	g_object_unref (client);
 
-	source = brasero_track_type_new ();
-	brasero_burn_session_get_input_type (BRASERO_BURN_SESSION (self), source);
 	if (brasero_burn_session_same_src_dest_drive (BRASERO_BURN_SESSION (self))) {
 		/* Special case */
 		if (value) {
@@ -874,9 +884,9 @@ brasero_session_cfg_set_drive_properties (BraseroSessionCfg *self)
 		flags = BRASERO_BURN_FLAG_EJECT|
 			BRASERO_BURN_FLAG_BURNPROOF;
 
-		if (brasero_track_type_get_has_data (source)
-		||  brasero_track_type_get_has_medium (source)
-		||  brasero_track_type_get_has_image (source))
+		if (brasero_track_type_get_has_data (priv->source)
+		||  brasero_track_type_get_has_medium (priv->source)
+		||  brasero_track_type_get_has_image (priv->source))
 			flags |= BRASERO_BURN_FLAG_NO_TMP_FILES;
 	}
 	else {
@@ -884,7 +894,6 @@ brasero_session_cfg_set_drive_properties (BraseroSessionCfg *self)
 		flags = gconf_value_get_int (value) & BRASERO_DEST_SAVED_FLAGS;
 		gconf_value_free (value);
 	}
-	brasero_track_type_free (source);
 
 	brasero_session_cfg_add_drive_properties_flags (self, flags);
 }
@@ -917,9 +926,7 @@ brasero_session_cfg_check_size (BraseroSessionCfg *self)
 	BraseroDrive *burner;
 	GValue *value = NULL;
 	/* in sectors */
-	goffset session_size;
 	goffset max_sectors;
-	goffset disc_size;
 
 	priv = BRASERO_SESSION_CFG_PRIVATE (self);
 
@@ -941,33 +948,35 @@ brasero_session_cfg_check_size (BraseroSessionCfg *self)
 		return BRASERO_SESSION_NO_OUTPUT;
 	}
 
-	disc_size = brasero_burn_session_get_available_medium_space (BRASERO_BURN_SESSION (self));
-	if (disc_size < 0)
-		disc_size = 0;
-
-	/* get input track size */
-	session_size = 0;
-
-	if (brasero_burn_session_tag_lookup (BRASERO_BURN_SESSION (self),
-					     BRASERO_DATA_TRACK_SIZE_TAG,
-					     &value) == BRASERO_BURN_OK) {
-		session_size = g_value_get_int64 (value);
+	/* Get both sizes if need be */
+	if (!priv->disc_size) {
+		priv->disc_size = brasero_burn_session_get_available_medium_space (BRASERO_BURN_SESSION (self));
+		if (priv->disc_size < 0)
+			priv->disc_size = 0;
 	}
-	else if (brasero_burn_session_tag_lookup (BRASERO_BURN_SESSION (self),
-						  BRASERO_STREAM_TRACK_SIZE_TAG,
-						  &value) == BRASERO_BURN_OK) {
-		session_size = g_value_get_int64 (value);
+
+	if (!priv->session_size) {
+		if (brasero_burn_session_tag_lookup (BRASERO_BURN_SESSION (self),
+						     BRASERO_DATA_TRACK_SIZE_TAG,
+						     &value) == BRASERO_BURN_OK) {
+			priv->session_size = g_value_get_int64 (value);
+		}
+		else if (brasero_burn_session_tag_lookup (BRASERO_BURN_SESSION (self),
+							  BRASERO_STREAM_TRACK_SIZE_TAG,
+							  &value) == BRASERO_BURN_OK) {
+			priv->session_size = g_value_get_int64 (value);
+		}
+		else
+			brasero_burn_session_get_size (BRASERO_BURN_SESSION (self),
+						       &priv->session_size,
+						       NULL);
 	}
-	else
-		brasero_burn_session_get_size (BRASERO_BURN_SESSION (self),
-					       &session_size,
-					       NULL);
 
 	BRASERO_BURN_LOG ("Session size %lli/Disc size %lli",
-			  session_size,
-			  disc_size);
+			  priv->session_size,
+			  priv->disc_size);
 
-	if (session_size < disc_size) {
+	if (priv->session_size < priv->disc_size) {
 		priv->is_valid = BRASERO_SESSION_VALID;
 		return BRASERO_SESSION_VALID;
 	}
@@ -983,8 +992,8 @@ brasero_session_cfg_check_size (BraseroSessionCfg *self)
 	 * when we propose overburning to the user, we could ask if he wants
 	 * us to determine how much data can be written to a particular disc
 	 * provided he has chosen a real disc. */
-	max_sectors = disc_size * 103 / 100;
-	if (max_sectors < session_size) {
+	max_sectors = priv->disc_size * 103 / 100;
+	if (max_sectors < priv->session_size) {
 		priv->is_valid = BRASERO_SESSION_INSUFFICIENT_SPACE;
 		return BRASERO_SESSION_INSUFFICIENT_SPACE;
 	}
@@ -1027,19 +1036,20 @@ brasero_session_cfg_set_tracks_audio_format (BraseroBurnSession *session,
 	}
 }
 
-static void
-brasero_session_cfg_update (BraseroSessionCfg *self)
+static gboolean
+brasero_session_cfg_can_update (BraseroSessionCfg *self)
 {
-	BraseroTrackType *source = NULL;
 	BraseroSessionCfgPrivate *priv;
 	BraseroBurnResult result;
 	BraseroStatus *status;
-	BraseroDrive *burner;
 
 	priv = BRASERO_SESSION_CFG_PRIVATE (self);
 
+	if (priv->disabled)
+		return FALSE;
+
 	if (priv->configuring)
-		return;
+		return FALSE;
 
 	/* Make sure the session is ready */
 	status = brasero_status_new ();
@@ -1051,7 +1061,7 @@ brasero_session_cfg_update (BraseroSessionCfg *self)
 		g_signal_emit (self,
 			       session_cfg_signals [IS_VALID_SIGNAL],
 			       0);
-		return;
+		return FALSE;
 	}
 
 	if (result == BRASERO_BURN_ERR) {
@@ -1067,21 +1077,35 @@ brasero_session_cfg_update (BraseroSessionCfg *self)
 				g_signal_emit (self,
 					       session_cfg_signals [IS_VALID_SIGNAL],
 					       0);
-				return;
+				return FALSE;
 			}
 
 			g_error_free (error);
 		}
 	}
 	g_object_unref (status);
+	return TRUE;
+}
+
+static void
+brasero_session_cfg_update (BraseroSessionCfg *self)
+{
+	BraseroSessionCfgPrivate *priv;
+	BraseroBurnResult result;
+	BraseroDrive *burner;
+
+	priv = BRASERO_SESSION_CFG_PRIVATE (self);
 
 	/* Make sure there is a source */
-	source = brasero_track_type_new ();
-	brasero_burn_session_get_input_type (BRASERO_BURN_SESSION (self), source);
+	if (priv->source) {
+		brasero_track_type_free (priv->source);
+		priv->source = NULL;
+	}
 
-	if (brasero_track_type_is_empty (source)) {
-		brasero_track_type_free (source);
+	priv->source = brasero_track_type_new ();
+	brasero_burn_session_get_input_type (BRASERO_BURN_SESSION (self), priv->source);
 
+	if (brasero_track_type_is_empty (priv->source)) {
 		priv->is_valid = BRASERO_SESSION_EMPTY;
 		g_signal_emit (self,
 			       session_cfg_signals [IS_VALID_SIGNAL],
@@ -1090,10 +1114,8 @@ brasero_session_cfg_update (BraseroSessionCfg *self)
 	}
 
 	/* it can be empty with just an empty track */
-	if (brasero_track_type_get_has_medium (source)
-	&&  brasero_track_type_get_medium_type (source) == BRASERO_MEDIUM_NONE) {
-		brasero_track_type_free (source);
-
+	if (brasero_track_type_get_has_medium (priv->source)
+	&&  brasero_track_type_get_medium_type (priv->source) == BRASERO_MEDIUM_NONE) {
 		priv->is_valid = BRASERO_SESSION_NO_INPUT_MEDIUM;
 		g_signal_emit (self,
 			       session_cfg_signals [IS_VALID_SIGNAL],
@@ -1101,13 +1123,11 @@ brasero_session_cfg_update (BraseroSessionCfg *self)
 		return;
 	}
 
-	if (brasero_track_type_get_has_image (source)
-	&&  brasero_track_type_get_image_format (source) == BRASERO_IMAGE_FORMAT_NONE) {
+	if (brasero_track_type_get_has_image (priv->source)
+	&&  brasero_track_type_get_image_format (priv->source) == BRASERO_IMAGE_FORMAT_NONE) {
 		gchar *uri;
 		GSList *tracks;
 
-		brasero_track_type_free (source);
-
 		tracks = brasero_burn_session_get_tracks (BRASERO_BURN_SESSION (self));
 
 		/* It can be two cases:
@@ -1137,8 +1157,6 @@ brasero_session_cfg_update (BraseroSessionCfg *self)
 	/* make sure there is an output set */
 	burner = brasero_burn_session_get_burner (BRASERO_BURN_SESSION (self));
 	if (!burner) {
-		brasero_track_type_free (source);
-
 		priv->is_valid = BRASERO_SESSION_NO_OUTPUT;
 		g_signal_emit (self,
 			       session_cfg_signals [IS_VALID_SIGNAL],
@@ -1147,45 +1165,45 @@ brasero_session_cfg_update (BraseroSessionCfg *self)
 	}
 
 	/* Check that current input and output work */
-	if (brasero_track_type_get_has_stream (source)) {
+	if (brasero_track_type_get_has_stream (priv->source)) {
 		if (priv->CD_TEXT_modified) {
 			/* Try to redo what we undid (after all a new plugin
 			 * could have been activated in the mean time ...) and
 			 * see what happens */
-			brasero_track_type_set_stream_format (source,
+			brasero_track_type_set_stream_format (priv->source,
 							      BRASERO_METADATA_INFO|
-							      brasero_track_type_get_stream_format (source));
-			result = brasero_burn_session_input_supported (BRASERO_BURN_SESSION (self), source, FALSE);
+							      brasero_track_type_get_stream_format (priv->source));
+			result = brasero_burn_session_input_supported (BRASERO_BURN_SESSION (self), priv->source, FALSE);
 			if (result == BRASERO_BURN_OK) {
 				priv->CD_TEXT_modified = FALSE;
 
 				priv->configuring = TRUE;
 				brasero_session_cfg_set_tracks_audio_format (BRASERO_BURN_SESSION (self),
-									     brasero_track_type_get_stream_format (source));
+									     brasero_track_type_get_stream_format (priv->source));
 				priv->configuring = FALSE;
 			}
 			else {
 				/* No, nothing's changed */
-				brasero_track_type_set_stream_format (source,
+				brasero_track_type_set_stream_format (priv->source,
 								      (~BRASERO_METADATA_INFO) &
-								      brasero_track_type_get_stream_format (source));
-				result = brasero_burn_session_input_supported (BRASERO_BURN_SESSION (self), source, FALSE);
+								      brasero_track_type_get_stream_format (priv->source));
+				result = brasero_burn_session_input_supported (BRASERO_BURN_SESSION (self), priv->source, FALSE);
 			}
 		}
 		else {
 			result = brasero_burn_session_can_burn (BRASERO_BURN_SESSION (self), FALSE);
 
 			if (result != BRASERO_BURN_OK
-			&& (brasero_track_type_get_stream_format (source) & BRASERO_METADATA_INFO)) {
+			&& (brasero_track_type_get_stream_format (priv->source) & BRASERO_METADATA_INFO)) {
 				/* Another special case in case some burning backends 
 				 * don't support CD-TEXT for audio (libburn). If no
 				 * other backend is available remove CD-TEXT option but
 				 * tell user... */
-				brasero_track_type_set_stream_format (source,
+				brasero_track_type_set_stream_format (priv->source,
 								      (~BRASERO_METADATA_INFO) &
-								      brasero_track_type_get_stream_format (source));
+								      brasero_track_type_get_stream_format (priv->source));
 
-				result = brasero_burn_session_input_supported (BRASERO_BURN_SESSION (self), source, FALSE);
+				result = brasero_burn_session_input_supported (BRASERO_BURN_SESSION (self), priv->source, FALSE);
 
 				BRASERO_BURN_LOG ("Tested support without Metadata information (result %d)", result);
 				if (result == BRASERO_BURN_OK) {
@@ -1193,14 +1211,14 @@ brasero_session_cfg_update (BraseroSessionCfg *self)
 
 					priv->configuring = TRUE;
 					brasero_session_cfg_set_tracks_audio_format (BRASERO_BURN_SESSION (self),
-										     brasero_track_type_get_has_stream (source));
+										     brasero_track_type_get_has_stream (priv->source));
 					priv->configuring = FALSE;
 				}
 			}
 		}
 	}
-	else if (brasero_track_type_get_has_medium (source)
-	&&  (brasero_track_type_get_medium_type (source) & BRASERO_MEDIUM_HAS_AUDIO)) {
+	else if (brasero_track_type_get_has_medium (priv->source)
+	&&  (brasero_track_type_get_medium_type (priv->source) & BRASERO_MEDIUM_HAS_AUDIO)) {
 		BraseroImageFormat format = BRASERO_IMAGE_FORMAT_NONE;
 
 		/* If we copy an audio disc check the image
@@ -1253,9 +1271,9 @@ brasero_session_cfg_update (BraseroSessionCfg *self)
 	}
 
 	if (result != BRASERO_BURN_OK) {
-		if (brasero_track_type_get_has_medium (source)
-		&& (brasero_track_type_get_medium_type (source) & BRASERO_MEDIUM_PROTECTED)
-		&&  brasero_burn_library_input_supported (source) != BRASERO_BURN_OK) {
+		if (brasero_track_type_get_has_medium (priv->source)
+		&& (brasero_track_type_get_medium_type (priv->source) & BRASERO_MEDIUM_PROTECTED)
+		&&  brasero_burn_library_input_supported (priv->source) != BRASERO_BURN_OK) {
 			/* This is a special case to display a helpful message */
 			priv->is_valid = BRASERO_SESSION_DISC_PROTECTED;
 			g_signal_emit (self,
@@ -1268,14 +1286,12 @@ brasero_session_cfg_update (BraseroSessionCfg *self)
 				       session_cfg_signals [IS_VALID_SIGNAL],
 				       0);
 		}
-
-		brasero_track_type_free (source);
 		return;
 	}
 
 	/* Special case for video projects */
-	if (brasero_track_type_get_has_stream (source)
-	&& BRASERO_STREAM_FORMAT_HAS_VIDEO (brasero_track_type_get_stream_format (source))) {
+	if (brasero_track_type_get_has_stream (priv->source)
+	&& BRASERO_STREAM_FORMAT_HAS_VIDEO (brasero_track_type_get_stream_format (priv->source))) {
 		/* Only set if it was not already set */
 		if (brasero_burn_session_tag_lookup (BRASERO_BURN_SESSION (self), BRASERO_VCD_TYPE, NULL) != BRASERO_BURN_OK)
 			brasero_burn_session_tag_add_int (BRASERO_BURN_SESSION (self),
@@ -1283,8 +1299,6 @@ brasero_session_cfg_update (BraseroSessionCfg *self)
 							  BRASERO_SVCD);
 	}
 
-	brasero_track_type_free (source);
-
 	/* Configure flags */
 	priv->configuring = TRUE;
 
@@ -1323,6 +1337,8 @@ brasero_session_cfg_session_loaded (BraseroTrackDataCfg *track,
 	priv = BRASERO_SESSION_CFG_PRIVATE (session);
 	if (priv->disabled)
 		return;
+	
+	priv->session_size = 0;
 
 	session_flags = brasero_burn_session_get_flags (BRASERO_BURN_SESSION (session));
 	if (is_loaded) {
@@ -1343,10 +1359,12 @@ brasero_session_cfg_track_added (BraseroBurnSession *session,
 {
 	BraseroSessionCfgPrivate *priv;
 
-	priv = BRASERO_SESSION_CFG_PRIVATE (session);
-	if (priv->disabled)
+	if (!brasero_session_cfg_can_update (BRASERO_SESSION_CFG (session)))
 		return;
 
+	priv = BRASERO_SESSION_CFG_PRIVATE (session);
+	priv->session_size = 0;
+
 	if (BRASERO_IS_TRACK_DATA_CFG (track))
 		g_signal_connect (track,
 				  "session-loaded",
@@ -1358,7 +1376,8 @@ brasero_session_cfg_track_added (BraseroBurnSession *session,
 	 * - reload saved flags
 	 * - check if all flags are thereafter supported
 	 * - check available formats for path
-	 * - set one path */
+	 * - set one path
+	*/
 	brasero_session_cfg_update (BRASERO_SESSION_CFG (session));
 	brasero_session_cfg_set_drive_properties (BRASERO_SESSION_CFG (session));
 }
@@ -1370,10 +1389,12 @@ brasero_session_cfg_track_removed (BraseroBurnSession *session,
 {
 	BraseroSessionCfgPrivate *priv;
 
-	priv = BRASERO_SESSION_CFG_PRIVATE (session);
-	if (priv->disabled)
+	if (!brasero_session_cfg_can_update (BRASERO_SESSION_CFG (session)))
 		return;
 
+	priv = BRASERO_SESSION_CFG_PRIVATE (session);
+	priv->session_size = 0;
+
 	/* Just in case */
 	g_signal_handlers_disconnect_by_func (track,
 					      brasero_session_cfg_session_loaded,
@@ -1395,18 +1416,33 @@ brasero_session_cfg_track_changed (BraseroBurnSession *session,
 				   BraseroTrack *track)
 {
 	BraseroSessionCfgPrivate *priv;
+	BraseroTrackType *current;
+
+	if (!brasero_session_cfg_can_update (BRASERO_SESSION_CFG (session)))
+		return;
 
 	priv = BRASERO_SESSION_CFG_PRIVATE (session);
-	if (priv->disabled)
+	priv->session_size = 0;
+
+	current = brasero_track_type_new ();
+	brasero_burn_session_get_input_type (session, current);
+	if (brasero_track_type_equal (current, priv->source)) {
+		/* This is a shortcut if the source type has not changed */
+		brasero_track_type_free (current);
+		brasero_session_cfg_check_size (BRASERO_SESSION_CFG (session));
+		g_signal_emit (session,
+			       session_cfg_signals [IS_VALID_SIGNAL],
+			       0);
 		return;
+	}
+	brasero_track_type_free (current);
 
 	/* when that happens it's mostly because a medium source changed, or
 	 * a new image was set. 
 	 * - reload saved flags
 	 * - check if all flags are thereafter supported
 	 * - check available formats for path
-	 * - set one path
-	 */
+	 * - set one path			*/
 	brasero_session_cfg_update (BRASERO_SESSION_CFG (session));
 	brasero_session_cfg_set_drive_properties (BRASERO_SESSION_CFG (session));
 }
@@ -1416,18 +1452,17 @@ brasero_session_cfg_output_changed (BraseroBurnSession *session,
 				    BraseroMedium *former)
 {
 	BraseroSessionCfgPrivate *priv;
-	BraseroTrackType *type;
 
-	priv = BRASERO_SESSION_CFG_PRIVATE (session);
-	if (priv->disabled)
+	if (!brasero_session_cfg_can_update (BRASERO_SESSION_CFG (session)))
 		return;
 
-	/* Case for video project */
-	type = brasero_track_type_new ();
-	brasero_burn_session_get_input_type (session, type);
+	priv = BRASERO_SESSION_CFG_PRIVATE (session);
+	priv->disc_size = 0;
 
-	if (brasero_track_type_get_has_stream (type)
-	&&  BRASERO_STREAM_FORMAT_HAS_VIDEO (brasero_track_type_get_stream_format (type))) {
+	/* Case for video project */
+	if (priv->source
+	&&  brasero_track_type_get_has_stream (priv->source)
+	&&  BRASERO_STREAM_FORMAT_HAS_VIDEO (brasero_track_type_get_stream_format (priv->source))) {
 		BraseroMedia media;
 
 		media = brasero_burn_session_get_dest_media (session);
@@ -1454,8 +1489,6 @@ brasero_session_cfg_output_changed (BraseroBurnSession *session,
 		}
 	}
 
-	brasero_track_type_free (type);
-
 	brasero_session_cfg_save_drive_properties (BRASERO_SESSION_CFG (session),
 						   former);
 
@@ -1473,10 +1506,14 @@ brasero_session_cfg_caps_changed (BraseroPluginManager *manager,
 {
 	BraseroSessionCfgPrivate *priv;
 
-	priv = BRASERO_SESSION_CFG_PRIVATE (self);
-	if (priv->disabled)
+	if (!brasero_session_cfg_can_update (self))
 		return;
 
+	priv = BRASERO_SESSION_CFG_PRIVATE (self);
+
+	priv->disc_size = 0;
+	priv->session_size = 0;
+
 	/* In this case we need to check if:
 	 * - new flags are supported or not supported anymore
 	 * - new image types as input/output are supported
@@ -1494,6 +1531,9 @@ brasero_session_cfg_flags_changed (BraseroBurnSession *session)
 	if (priv->disabled)
 		return;
 
+	priv->disc_size = 0;
+	priv->session_size = 0;
+
 	/* when we update the flags we don't want a
 	 * whole series of "flags-changed" emitted.
 	 * so make sure there is just one at the end */
@@ -1525,7 +1565,9 @@ brasero_session_cfg_add_flags (BraseroSessionCfg *self,
 		return;
 
 	brasero_session_cfg_add_drive_properties_flags (self, flags);
-	brasero_session_cfg_update (self);
+
+	if (!brasero_session_cfg_can_update (self))
+		brasero_session_cfg_update (self);
 }
 
 /**
@@ -1559,7 +1601,8 @@ brasero_session_cfg_remove_flags (BraseroSessionCfg *self,
 	if (drive && brasero_drive_get_medium (drive))
 		brasero_session_cfg_save_drive_flags (self, brasero_drive_get_medium (drive));
 
-	brasero_session_cfg_update (self);
+	if (brasero_session_cfg_can_update (self))
+		brasero_session_cfg_update (self);
 }
 
 /**
@@ -1649,6 +1692,11 @@ brasero_session_cfg_finalize (GObject *object)
 	                                      brasero_session_cfg_caps_changed,
 	                                      object);
 
+	if (priv->source) {
+		brasero_track_type_free (priv->source);
+		priv->source = NULL;
+	}
+
 	G_OBJECT_CLASS (brasero_session_cfg_parent_class)->finalize (object);
 }
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]