GNOME.org
 

brasero r1266 - in trunk: . src

Author: philippr
Date: Wed Sep 10 19:44:17 2008
New Revision: 1266
URL: http://svn.gnome.org/viewvc/brasero?rev=1266&view=rev

Log:
	Improved flag management when copying a medium

	* src/brasero-dest-selection.c
	(brasero_dest_selection_drive_properties),
	(brasero_dest_selection_add_drive_properties_flags),
	(brasero_dest_selection_set_drive_properties),
	(brasero_dest_selection_check_drive_settings):
	* src/burn-caps.c (brasero_burn_caps_get_blanking_flags_real),
	(brasero_burn_caps_get_blanking_flags),
	(brasero_burn_caps_can_blank_real), (brasero_burn_caps_can_blank),
	(brasero_caps_link_check_media_restrictions),
	(brasero_burn_caps_is_session_supported_same_src_dest),
	(brasero_burn_caps_get_flags_for_medium),
	(brasero_burn_caps_get_flags_same_src_dest),
	(brasero_burn_caps_get_flags):

Modified:
   trunk/ChangeLog
   trunk/src/brasero-dest-selection.c
   trunk/src/burn-caps.c

Modified: trunk/src/brasero-dest-selection.c
==============================================================================
--- trunk/src/brasero-dest-selection.c	(original)
+++ trunk/src/brasero-dest-selection.c	Wed Sep 10 19:44:17 2008
@@ -211,17 +211,10 @@
 					    rate);
 
 	flags = brasero_burn_session_get_flags (priv->session);
-	if (!brasero_dest_selection_check_same_src_dest (self)) {
-		brasero_burn_caps_get_flags (priv->caps,
-					     priv->session,
-					     &supported,
-					     &compulsory);
-	}
-	else {
-		supported = BRASERO_DRIVE_PROPERTIES_FLAGS;
-		supported &= ~BRASERO_BURN_FLAG_NO_TMP_FILES;
-		compulsory = BRASERO_BURN_FLAG_NONE;
-	}
+	brasero_burn_caps_get_flags (priv->caps,
+				     priv->session,
+				     &supported,
+				     &compulsory);
 
 	brasero_drive_properties_set_flags (BRASERO_DRIVE_PROPERTIES (priv->drive_prop),
 					    flags,
@@ -788,6 +781,11 @@
 		if (!(flags & flag))
 			continue;
 
+		/* Don't set write modes now in this case */
+		if (brasero_burn_session_same_src_dest_drive (priv->session)
+		&& (flag & (BRASERO_BURN_FLAG_DAO|BRASERO_BURN_FLAG_RAW)))
+			continue;
+
 		if (compulsory)
 			brasero_burn_session_add_flag (priv->session, compulsory);
 
@@ -806,13 +804,16 @@
 	if (flags != (flags | compulsory))
 		brasero_burn_session_add_flag (priv->session, compulsory);
 
-	/* use DAO whenever it's possible */
-	if (supported & BRASERO_BURN_FLAG_DAO) {
-		brasero_burn_session_add_flag (priv->session, BRASERO_BURN_FLAG_DAO);
-		brasero_burn_caps_get_flags (priv->caps,
-					     priv->session,
-					     &supported,
-					     &compulsory);
+	/* When copying with same drive don't set write mode, it'll be set later */
+	if (!brasero_burn_session_same_src_dest_drive (priv->session)) {
+		/* use DAO whenever it's possible */
+		if (supported & BRASERO_BURN_FLAG_DAO) {
+			brasero_burn_session_add_flag (priv->session, BRASERO_BURN_FLAG_DAO);
+			brasero_burn_caps_get_flags (priv->caps,
+						     priv->session,
+						     &supported,
+						     &compulsory);
+		}
 	}
 
 	if (supported_retval)
@@ -919,6 +920,9 @@
 	g_free (key);
 
 	if (brasero_dest_selection_check_same_src_dest (self)) {
+		BraseroBurnFlag supported = BRASERO_BURN_FLAG_NONE;
+		BraseroBurnFlag compulsory = BRASERO_BURN_FLAG_NONE;
+
 		/* Special case */
 
 		/* wipe out previous flags */
@@ -934,17 +938,18 @@
 			flags = BRASERO_BURN_FLAG_EJECT|
 				BRASERO_BURN_FLAG_BURNPROOF;
 
-		brasero_burn_session_add_flag (priv->session, flags);
+		brasero_dest_selection_add_drive_properties_flags (self,
+								   flags|
+								   BRASERO_BURN_FLAG_BLANK_BEFORE_WRITE|
+								   BRASERO_BURN_FLAG_FAST_BLANK,
+								   &supported,
+								   &compulsory);
 
 		/* NOTE: of course NO_TMP is not possible; DAO and BLANK_BEFORE
 		 * could be yet. The problem here is that we cannot test all
 		 * this since we don't know yet what the disc type is going to 
 		 * be. So we set DAO and BLANK_BEFORE_WRITE just in case.
 		 * Hopefully burn.c will be able to handle that later. */
-		brasero_burn_session_add_flag (priv->session,
-					       BRASERO_BURN_FLAG_BLANK_BEFORE_WRITE|
-					       BRASERO_BURN_FLAG_FAST_BLANK|
-					       BRASERO_BURN_FLAG_DAO);
 	}
 	else if (!value) {
 		BraseroBurnFlag supported = BRASERO_BURN_FLAG_NONE;
@@ -1159,10 +1164,11 @@
 	if (brasero_dest_selection_check_same_src_dest (self)) {
 		/* These are always set in any case and there is no way to check
 		 * the current flags */
-		brasero_burn_session_add_flag (priv->session,
-					       BRASERO_BURN_FLAG_DAO|
-					       BRASERO_BURN_FLAG_FAST_BLANK|
-					       BRASERO_BURN_FLAG_BLANK_BEFORE_WRITE);
+		brasero_dest_selection_add_drive_properties_flags (self,
+								   BRASERO_BURN_FLAG_BLANK_BEFORE_WRITE|
+								   BRASERO_BURN_FLAG_FAST_BLANK,
+								   &supported,
+								   &compulsory);
 	}
 	else {
 		/* Try to properly update the flags for the current drive */

Modified: trunk/src/burn-caps.c
==============================================================================
--- trunk/src/burn-caps.c	(original)
+++ trunk/src/burn-caps.c	Wed Sep 10 19:44:17 2008
@@ -412,21 +412,18 @@
 }
 
 BraseroBurnResult
-brasero_burn_caps_get_blanking_flags (BraseroBurnCaps *caps,
-				      BraseroBurnSession *session,
-				      BraseroBurnFlag *supported,
-				      BraseroBurnFlag *compulsory)
+brasero_burn_caps_get_blanking_flags_real (BraseroBurnCaps *caps,
+					   BraseroMedia media,
+					   BraseroBurnFlag session_flags,
+					   BraseroBurnFlag *supported,
+					   BraseroBurnFlag *compulsory)
 {
 	GSList *iter;
-	BraseroMedia media;
 	gboolean supported_media;
-	BraseroBurnFlag session_flags;
 	BraseroBurnFlag supported_flags = BRASERO_BURN_FLAG_NONE;
 	BraseroBurnFlag compulsory_flags = BRASERO_BURN_FLAG_ALL;
 
-	media = brasero_burn_session_get_dest_media (session);
 	BRASERO_BURN_LOG_DISC_TYPE (media, "Getting blanking flags for");
-
 	if (media == BRASERO_MEDIUM_NONE) {
 		BRASERO_BURN_LOG ("Blanking not possible: no media");
 		if (supported)
@@ -437,7 +434,6 @@
 	}
 
 	supported_media = FALSE;
-	session_flags = brasero_burn_session_get_flags (session);
 	for (iter = caps->priv->caps_list; iter; iter = iter->next) {
 		BraseroCaps *caps;
 		GSList *links;
@@ -497,6 +493,35 @@
 	return BRASERO_BURN_OK;
 }
 
+BraseroBurnResult
+brasero_burn_caps_get_blanking_flags (BraseroBurnCaps *caps,
+				      BraseroBurnSession *session,
+				      BraseroBurnFlag *supported,
+				      BraseroBurnFlag *compulsory)
+{
+	BraseroMedia media;
+	BraseroBurnFlag session_flags;
+
+	media = brasero_burn_session_get_dest_media (session);
+	BRASERO_BURN_LOG_DISC_TYPE (media, "Getting blanking flags for");
+
+	if (media == BRASERO_MEDIUM_NONE) {
+		BRASERO_BURN_LOG ("Blanking not possible: no media");
+		if (supported)
+			*supported = BRASERO_BURN_FLAG_NONE;
+		if (compulsory)
+			*compulsory = BRASERO_BURN_FLAG_NONE;
+		return BRASERO_BURN_NOT_SUPPORTED;
+	}
+
+	session_flags = brasero_burn_session_get_flags (session);
+	return brasero_burn_caps_get_blanking_flags_real (caps,
+							  media,
+							  session_flags,
+							  supported,
+							  compulsory);
+}
+
 BraseroTask *
 brasero_burn_caps_new_blanking_task (BraseroBurnCaps *self,
 				     BraseroBurnSession *session,
@@ -594,22 +619,18 @@
 }
 
 BraseroBurnResult
-brasero_burn_caps_can_blank (BraseroBurnCaps *self,
-			     BraseroBurnSession *session)
+brasero_burn_caps_can_blank_real (BraseroBurnCaps *self,
+				  BraseroMedia media,
+				  BraseroBurnFlag flags)
 {
 	GSList *iter;
-	BraseroMedia media;
-	BraseroBurnFlag flags;
 
-	media = brasero_burn_session_get_dest_media (session);
 	BRASERO_BURN_LOG_DISC_TYPE (media, "Testing blanking caps for");
-
 	if (media == BRASERO_MEDIUM_NONE) {
 		BRASERO_BURN_LOG ("no media => no blanking possible");
 		return BRASERO_BURN_NOT_SUPPORTED;
 	}
 
-	flags = brasero_burn_session_get_flags (session);
 	for (iter = self->priv->caps_list; iter; iter = iter->next) {
 		BraseroCaps *caps;
 		GSList *links;
@@ -657,6 +678,25 @@
 	return BRASERO_BURN_NOT_SUPPORTED;
 }
 
+BraseroBurnResult
+brasero_burn_caps_can_blank (BraseroBurnCaps *self,
+			     BraseroBurnSession *session)
+{
+	BraseroMedia media;
+	BraseroBurnFlag flags;
+
+	media = brasero_burn_session_get_dest_media (session);
+	BRASERO_BURN_LOG_DISC_TYPE (media, "Testing blanking caps for");
+
+	if (media == BRASERO_MEDIUM_NONE) {
+		BRASERO_BURN_LOG ("no media => no blanking possible");
+		return BRASERO_BURN_NOT_SUPPORTED;
+	}
+
+	flags = brasero_burn_session_get_flags (session);
+	return brasero_burn_caps_can_blank_real (self, media, flags);
+}
+
 /**
  *
  */
@@ -819,7 +859,7 @@
 {
 	GSList *iter;
 
-	/* Go through all plugins: at least one must support record flags */
+	/* Go through all plugins: at least one must support media */
 	for (iter = link->plugins; iter; iter = iter->next) {
 		gboolean result;
 		BraseroPlugin *plugin;
@@ -1998,17 +2038,17 @@
 	output.type = BRASERO_TRACK_TYPE_IMAGE;
 
 	for (; format > BRASERO_IMAGE_FORMAT_NONE; format >>= 1) {
-		BraseroBurnResult result;
+		gboolean supported;
 
 		output.subtype.img_format = format;
 
 		BRASERO_BURN_LOG_TYPE (&output, "Testing temporary image format");
-		result = brasero_caps_try_output_with_blanking (self,
-								session,
-								&output,
-								&input,
-								BRASERO_PLUGIN_IO_ACCEPT_FILE);
-		if (result != BRASERO_BURN_OK)
+		supported = brasero_caps_try_output_with_blanking (self,
+								   session,
+								   &output,
+								   &input,
+								   BRASERO_PLUGIN_IO_ACCEPT_FILE);
+		if (!supported)
 			continue;
 
 		/* This format can be used to create an image. Check if can be
@@ -2353,76 +2393,21 @@
 	return BRASERO_BURN_OK;
 }
 
-BraseroBurnResult
-brasero_burn_caps_get_flags (BraseroBurnCaps *self,
-			     BraseroBurnSession *session,
-			     BraseroBurnFlag *supported,
-			     BraseroBurnFlag *compulsory)
+static BraseroBurnResult
+brasero_burn_caps_get_flags_for_medium (BraseroBurnCaps *self,
+					BraseroMedia media,
+					BraseroBurnFlag session_flags,
+					BraseroTrackType *input,
+					BraseroBurnFlag *supported_flags,
+					BraseroBurnFlag *compulsory_flags)
 {
-	BraseroMedia media;
-	BraseroTrackType input;
 	BraseroBurnResult result;
 
-	BraseroBurnFlag session_flags;
-	/* FIXME: what's the meaning of NOGRACE when outputting ? */
-	BraseroBurnFlag compulsory_flags = BRASERO_BURN_FLAG_NONE;
-	BraseroBurnFlag supported_flags = BRASERO_BURN_FLAG_DONT_OVERWRITE|
-					  BRASERO_BURN_FLAG_DONT_CLEAN_OUTPUT|
-					  BRASERO_BURN_FLAG_CHECK_SIZE|
-					  BRASERO_BURN_FLAG_NOGRACE;
-
-	g_return_val_if_fail (BRASERO_IS_BURNCAPS (self), BRASERO_BURN_ERR);
-
-	brasero_burn_session_get_input_type (session, &input);
-	BRASERO_BURN_LOG_WITH_TYPE (&input,
-				    BRASERO_PLUGIN_IO_NONE,
-				    "FLAGS: searching available flags for input");
-
-	if (brasero_burn_session_is_dest_file (session)) {
-		BRASERO_BURN_LOG ("FLAGS: image required");
-
-		/* In this case no APPEND/MERGE is possible */
-		if (input.type == BRASERO_TRACK_TYPE_DISC)
-			supported_flags |= BRASERO_BURN_FLAG_EJECT;
-
-		/* FIXME: do the flag have the same meaning now with session
-		 * making a clear distinction between tmp files and output */
-		compulsory_flags |= BRASERO_BURN_FLAG_DONT_CLEAN_OUTPUT;
-
-		*supported = supported_flags;
-		*compulsory = compulsory_flags;
-
-		BRASERO_BURN_LOG_FLAGS (supported_flags, "FLAGS: supported");
-		BRASERO_BURN_LOG_FLAGS (compulsory_flags, "FLAGS: compulsory");
-		return BRASERO_BURN_OK;
-	}
-
-	supported_flags |= BRASERO_BURN_FLAG_EJECT;
-
-	session_flags = brasero_burn_session_get_flags (session);
-	BRASERO_BURN_LOG_FLAGS (session_flags, "FLAGS (session):");
-
-	/* sanity check:
-	 * - drive must support flags
-	 * - MERGE and BLANK are not possible together.
-	 * - APPEND and MERGE are compatible. MERGE wins
-	 * - APPEND and BLANK are incompatible */
-	if (!brasero_burn_caps_flags_check_for_drive (session)) {
-		BRASERO_BURN_LOG ("Session flags not supported by drive");
-		return BRASERO_BURN_ERR;
-	}
-
-	if ((session_flags & (BRASERO_BURN_FLAG_MERGE|BRASERO_BURN_FLAG_APPEND))
-	&&  (session_flags & BRASERO_BURN_FLAG_BLANK_BEFORE_WRITE))
-		return BRASERO_BURN_NOT_SUPPORTED;
-	
-	/* Let's get flags for recording */
-	media = brasero_burn_session_get_dest_media (session);
 	result = brasero_caps_get_flags_for_disc (session_flags,
 						  media,
-						  &input,
-						  &supported_flags,
-						  &compulsory_flags);
+						  input,
+						  supported_flags,
+						  compulsory_flags);
 
 	if (result != BRASERO_BURN_OK) {
 		/* we reached this point in two cases:
@@ -2448,11 +2433,11 @@
 			return BRASERO_BURN_NOT_SUPPORTED;
 		}
 
-		if (brasero_burn_caps_can_blank (self, session) != BRASERO_BURN_OK)
+		if (brasero_burn_caps_can_blank_real (self, media, session_flags) != BRASERO_BURN_OK)
 			return BRASERO_BURN_NOT_SUPPORTED;
 
-		supported_flags |= BRASERO_BURN_FLAG_BLANK_BEFORE_WRITE;
-		compulsory_flags |= BRASERO_BURN_FLAG_BLANK_BEFORE_WRITE;
+		(*supported_flags) |= BRASERO_BURN_FLAG_BLANK_BEFORE_WRITE;
+		(*compulsory_flags) |= BRASERO_BURN_FLAG_BLANK_BEFORE_WRITE;
 
 		/* pretends it is blank and formatted to see if it would work.
 		 * If it works then that means that the BLANK_BEFORE_WRITE flag
@@ -2465,9 +2450,9 @@
 		media |= BRASERO_MEDIUM_BLANK;
 		result = brasero_caps_get_flags_for_disc (session_flags,
 							  media,
-							  &input,
-							  &supported_flags,
-							  &compulsory_flags);
+							  input,
+							  supported_flags,
+							  compulsory_flags);
 		if (result != BRASERO_BURN_OK)
 			return result;
 	}
@@ -2475,8 +2460,8 @@
 		/* see if we can add BRASERO_BURN_FLAG_BLANK_BEFORE_WRITE */
 		if ((media & (BRASERO_MEDIUM_HAS_AUDIO|BRASERO_MEDIUM_HAS_DATA))
 		&& !(session_flags & (BRASERO_BURN_FLAG_MERGE|BRASERO_BURN_FLAG_APPEND))
-		&&  brasero_burn_caps_can_blank (self, session) == BRASERO_BURN_OK)
-			supported_flags |= BRASERO_BURN_FLAG_BLANK_BEFORE_WRITE;
+		&&  brasero_burn_caps_can_blank_real (self, media, session_flags) == BRASERO_BURN_OK)
+			(*supported_flags) |= BRASERO_BURN_FLAG_BLANK_BEFORE_WRITE;
 		else if (session_flags & BRASERO_BURN_FLAG_BLANK_BEFORE_WRITE)
 			return BRASERO_BURN_NOT_SUPPORTED;
 	}
@@ -2484,24 +2469,229 @@
 	if (session_flags & BRASERO_BURN_FLAG_BLANK_BEFORE_WRITE) {
 		/* make sure we remove MERGE/APPEND from supported and
 		 * compulsory since that's not possible anymore */
-		supported_flags &= ~(BRASERO_BURN_FLAG_MERGE|BRASERO_BURN_FLAG_APPEND);
-		compulsory_flags &= ~(BRASERO_BURN_FLAG_MERGE|BRASERO_BURN_FLAG_APPEND);
+		(*supported_flags) &= ~(BRASERO_BURN_FLAG_MERGE|BRASERO_BURN_FLAG_APPEND);
+		(*compulsory_flags) &= ~(BRASERO_BURN_FLAG_MERGE|BRASERO_BURN_FLAG_APPEND);
 	}
 
-	if (supported_flags & BRASERO_BURN_FLAG_BLANK_BEFORE_WRITE) {
+	if ((*supported_flags) & BRASERO_BURN_FLAG_BLANK_BEFORE_WRITE) {
 		BraseroBurnFlag blank_compulsory = BRASERO_BURN_FLAG_NONE;
 		BraseroBurnFlag blank_supported = BRASERO_BURN_FLAG_NONE;
 
 		/* need to add blanking flags */
-		brasero_burn_caps_get_blanking_flags (self,
-						      session,
-						      &blank_supported,
-						      &blank_compulsory);
-		supported_flags |= blank_supported;
-		compulsory_flags |= blank_compulsory;
+		brasero_burn_caps_get_blanking_flags_real (self,
+							   media,
+							   session_flags,
+							   &blank_supported,
+							   &blank_compulsory);
+		(*supported_flags) |= blank_supported;
+		(*compulsory_flags) |= blank_compulsory;
 	}
 
-	supported_flags = brasero_burn_caps_flags_update_for_drive (supported_flags, session);
+	return BRASERO_BURN_OK;
+}
+
+static BraseroBurnResult
+brasero_burn_caps_get_flags_same_src_dest (BraseroBurnCaps *self,
+					   BraseroBurnSession *session,
+					   BraseroBurnFlag *supported_ret,
+					   BraseroBurnFlag *compulsory_ret)
+{
+	GSList *iter;
+	gboolean copy_supported;
+	BraseroTrackType input;
+	BraseroTrackType output;
+	BraseroImageFormat format;
+	BraseroBurnFlag session_flags;
+	BraseroBurnFlag supported_final = BRASERO_BURN_FLAG_NONE;
+	BraseroBurnFlag compulsory_final = BRASERO_BURN_FLAG_ALL;
+
+	BRASERO_BURN_LOG ("Retrieving disc copy flags with same source and destination");
+
+	/* To determine if a CD/DVD can be copied using the same source/dest,
+	 * we first determine if can be imaged and then what are the flags when
+	 * we can burn it to a particular medium type. */
+	memset (&input, 0, sizeof (BraseroTrackType));
+	brasero_burn_session_get_input_type (session, &input);
+	BRASERO_BURN_LOG_TYPE (&input, "input");
+
+	session_flags = brasero_burn_session_get_flags (session);
+	BRASERO_BURN_LOG_FLAGS (session_flags, "(FLAGS) Session flags");
+
+	/* Check the current flags are possible */
+	if (session_flags & (BRASERO_BURN_FLAG_MERGE|BRASERO_BURN_FLAG_NO_TMP_FILES))
+		return BRASERO_BURN_NOT_SUPPORTED;
+
+	/* Check flags for all available format */
+	format = BRASERO_IMAGE_FORMAT_CDRDAO;
+	output.type = BRASERO_TRACK_TYPE_IMAGE;
+
+	copy_supported = FALSE;
+	for (; format > BRASERO_IMAGE_FORMAT_NONE; format >>= 1) {
+		BraseroBurnResult result;
+		gboolean format_supported;
+
+		/* check this image type is possible given the current flags */
+		if (format != BRASERO_IMAGE_FORMAT_CLONE
+		&& (session_flags & BRASERO_BURN_FLAG_RAW))
+			continue;
+
+		output.subtype.img_format = format;
+
+		/* NOTE: there is no need to get the flags here since there are
+		 * no specific DISC => IMAGE flags. We just want to know if that
+		 * is possible. */
+		BRASERO_BURN_LOG_TYPE (&output, "Testing temporary image format");
+		format_supported = brasero_caps_try_output_with_blanking (self,
+									  session,
+									  &output,
+									  &input,
+									  BRASERO_PLUGIN_IO_ACCEPT_FILE);
+		if (!format_supported) {
+			BRASERO_BURN_LOG_TYPE (&output, "Format not supported");
+			continue;
+		}
+
+		/* This format can be used to create an image. Check if can be
+		 * burnt now. Just find at least one medium. */
+		format_supported = FALSE;
+		for (iter = self->priv->caps_list; iter; iter = iter->next) {
+			BraseroBurnFlag compulsory;
+			BraseroBurnFlag supported;
+			BraseroCaps *caps;
+
+			caps = iter->data;
+			if (caps->type.type != BRASERO_TRACK_TYPE_DISC)
+				continue;
+
+			/* Merge all available flags for each possible medium type */
+			supported = BRASERO_BURN_FLAG_NONE;
+			compulsory = BRASERO_BURN_FLAG_NONE;
+			result = brasero_burn_caps_get_flags_for_medium (self,
+									 caps->type.subtype.media,
+									 session_flags,
+									 &output,
+									 &supported,
+									 &compulsory);
+			if (result != BRASERO_BURN_OK)
+				continue;
+
+			format_supported = TRUE;
+			supported_final |= supported;
+			compulsory_final &= compulsory;
+		}
+
+		BRASERO_BURN_LOG_TYPE (&output, "Format supported %i", format_supported);
+		if (format_supported)
+			copy_supported = TRUE;
+	}
+
+	if (!copy_supported)
+		return BRASERO_BURN_NOT_SUPPORTED;
+
+	*supported_ret |= supported_final;
+	*compulsory_ret |= compulsory_final;
+	
+	return BRASERO_BURN_OK;
+}
+
+BraseroBurnResult
+brasero_burn_caps_get_flags (BraseroBurnCaps *self,
+			     BraseroBurnSession *session,
+			     BraseroBurnFlag *supported,
+			     BraseroBurnFlag *compulsory)
+{
+	BraseroMedia media;
+	BraseroTrackType input;
+	BraseroBurnResult result;
+
+	BraseroBurnFlag session_flags;
+	/* FIXME: what's the meaning of NOGRACE when outputting ? */
+	BraseroBurnFlag compulsory_flags = BRASERO_BURN_FLAG_NONE;
+	BraseroBurnFlag supported_flags = BRASERO_BURN_FLAG_DONT_OVERWRITE|
+					  BRASERO_BURN_FLAG_DONT_CLEAN_OUTPUT|
+					  BRASERO_BURN_FLAG_CHECK_SIZE|
+					  BRASERO_BURN_FLAG_NOGRACE;
+
+	g_return_val_if_fail (BRASERO_IS_BURNCAPS (self), BRASERO_BURN_ERR);
+
+	brasero_burn_session_get_input_type (session, &input);
+	BRASERO_BURN_LOG_WITH_TYPE (&input,
+				    BRASERO_PLUGIN_IO_NONE,
+				    "FLAGS: searching available flags for input");
+
+	if (brasero_burn_session_is_dest_file (session)) {
+		BRASERO_BURN_LOG ("FLAGS: image required");
+
+		/* In this case no APPEND/MERGE is possible */
+		if (input.type == BRASERO_TRACK_TYPE_DISC)
+			supported_flags |= BRASERO_BURN_FLAG_EJECT;
+
+		/* FIXME: do the flag have the same meaning now with session
+		 * making a clear distinction between tmp files and output */
+		compulsory_flags |= BRASERO_BURN_FLAG_DONT_CLEAN_OUTPUT;
+
+		*supported = supported_flags;
+		*compulsory = compulsory_flags;
+
+		BRASERO_BURN_LOG_FLAGS (supported_flags, "FLAGS: supported");
+		BRASERO_BURN_LOG_FLAGS (compulsory_flags, "FLAGS: compulsory");
+		return BRASERO_BURN_OK;
+	}
+
+	supported_flags |= BRASERO_BURN_FLAG_EJECT;
+
+	/* special case */
+	if (brasero_burn_session_same_src_dest_drive (session)) {
+		result = brasero_burn_caps_get_flags_same_src_dest (self,
+								    session,
+								    &supported_flags,
+								    &compulsory_flags);
+
+		/* These flags are of course never possible */
+		supported_flags &= ~(BRASERO_BURN_FLAG_NO_TMP_FILES|
+				     BRASERO_BURN_FLAG_MERGE);
+
+		if (result == BRASERO_BURN_OK) {
+			BRASERO_BURN_LOG_FLAGS (supported_flags, "FLAGS: supported");
+			BRASERO_BURN_LOG_FLAGS (compulsory_flags, "FLAGS: compulsory");
+
+			*supported = supported_flags;
+			*compulsory = compulsory_flags;
+		}
+		else
+			BRASERO_BURN_LOG ("No available flags for copy");
+
+		return result;
+	}
+
+	session_flags = brasero_burn_session_get_flags (session);
+	BRASERO_BURN_LOG_FLAGS (session_flags, "FLAGS (session):");
+
+	/* sanity check:
+	 * - drive must support flags
+	 * - MERGE and BLANK are not possible together.
+	 * - APPEND and MERGE are compatible. MERGE wins
+	 * - APPEND and BLANK are incompatible */
+	if (!brasero_burn_caps_flags_check_for_drive (session)) {
+		BRASERO_BURN_LOG ("Session flags not supported by drive");
+		return BRASERO_BURN_ERR;
+	}
+
+	if ((session_flags & (BRASERO_BURN_FLAG_MERGE|BRASERO_BURN_FLAG_APPEND))
+	&&  (session_flags & BRASERO_BURN_FLAG_BLANK_BEFORE_WRITE))
+		return BRASERO_BURN_NOT_SUPPORTED;
+	
+	/* Let's get flags for recording */
+	media = brasero_burn_session_get_dest_media (session);
+	brasero_burn_caps_get_flags_for_medium (self,
+						media,
+						session_flags,
+						&input,
+						&supported_flags,
+						&compulsory_flags);
+
+	supported_flags = brasero_burn_caps_flags_update_for_drive (supported_flags,
+								    session);
 
 	if (supported)
 		*supported = supported_flags;
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]