GNOME.org
 

[rhythmbox] track-transfer-batch: avoid gtk_dialog_run for overwrite prompt

commit af163c03f7721a77917862b9642a24171b58f7ba
Author: Jonathan Matthew <jonathan d14n org>
Date:   Sat Feb 25 22:40:32 2012 +1000

    track-transfer-batch: avoid gtk_dialog_run for overwrite prompt
    
    Replace the RBEncoder 'overwrite' signal with a parameter to
    rb_encoder_encode, and just make it fail if overwrite is FALSE
    and the destination file exists.
    
    Change the transfer batch 'overwrite-prompt' signal to suspend
    the batch and add a method to resume it, either overwriting the
    existing destination file or skipping the track.
    
    This means the overwrite-prompt signal handler doesn't have to
    return the user's decision, so it doesn't have to call gtk_dialog_run.
    
    Friends don't let friends gtk_dialog_run.

 backends/gstreamer/rb-encoder-gst.c |   20 ++++--
 backends/rb-encoder.c               |   32 +--------
 backends/rb-encoder.h               |    7 +-
 shell/rb-track-transfer-batch.c     |  124 ++++++++++++++++++++++-------------
 shell/rb-track-transfer-batch.h     |    3 +
 shell/rb-track-transfer-queue.c     |   83 ++++++++++++++---------
 sources/rb-library-source.c         |    2 +-
 sources/rb-transfer-target.c        |    6 +-
 8 files changed, 159 insertions(+), 118 deletions(-)
---
diff --git a/backends/gstreamer/rb-encoder-gst.c b/backends/gstreamer/rb-encoder-gst.c
index 72a6eb4..88e0674 100644
--- a/backends/gstreamer/rb-encoder-gst.c
+++ b/backends/gstreamer/rb-encoder-gst.c
@@ -438,6 +438,7 @@ static gboolean
 attach_output_pipeline (RBEncoderGst *encoder,
 			GstElement *end,
 			const char *dest,
+			gboolean overwrite,
 			GError **error)
 {
 	GFile *file;
@@ -466,14 +467,18 @@ attach_output_pipeline (RBEncoderGst *encoder,
 			} else if (g_error_matches (local_error,
 						    G_IO_ERROR,
 						    G_IO_ERROR_EXISTS)) {
-				if (_rb_encoder_emit_overwrite (RB_ENCODER (encoder), file)) {
+				if (overwrite) {
 					g_error_free (local_error);
 					stream = g_file_replace (file, NULL, FALSE, G_FILE_CREATE_NONE, NULL, error);
 					if (stream == NULL) {
 						return FALSE;
 					}
 				} else {
-					g_propagate_error (error, local_error);
+					g_set_error (error,
+						     RB_ENCODER_ERROR,
+						     RB_ENCODER_ERROR_DEST_EXISTS,
+						     local_error->message);
+					g_error_free (local_error);
 					return FALSE;
 				}
 			} else {
@@ -549,6 +554,7 @@ static gboolean
 copy_track (RBEncoderGst *encoder,
 	    RhythmDBEntry *entry,
 	    const char *dest,
+	    gboolean overwrite,
 	    GError **error)
 {
 	/* source ! sink */
@@ -560,7 +566,7 @@ copy_track (RBEncoderGst *encoder,
 	if (src == NULL)
 		return FALSE;
 
-	if (!attach_output_pipeline (encoder, src, dest, error))
+	if (!attach_output_pipeline (encoder, src, dest, overwrite, error))
 		return FALSE;
 
 	start_pipeline (encoder);
@@ -571,6 +577,7 @@ static gboolean
 transcode_track (RBEncoderGst *encoder,
 	 	 RhythmDBEntry *entry,
 		 const char *dest,
+		 gboolean overwrite,
 		 GError **error)
 {
 	/* src ! decodebin2 ! encodebin ! sink */
@@ -616,7 +623,7 @@ transcode_track (RBEncoderGst *encoder,
 		      NULL);
 	gst_bin_add (GST_BIN (encoder->priv->pipeline), encoder->priv->encodebin);
 
-	if (!attach_output_pipeline (encoder, encoder->priv->encodebin, dest, error))
+	if (!attach_output_pipeline (encoder, encoder->priv->encodebin, dest, overwrite, error))
 		goto error;
 	if (!add_tags_from_entry (encoder, entry, error))
 		goto error;
@@ -680,6 +687,7 @@ static void
 impl_encode (RBEncoder *bencoder,
 	     RhythmDBEntry *entry,
 	     const char *dest,
+	     gboolean overwrite,
 	     GstEncodingProfile *profile)
 {
 	RBEncoderGst *encoder = RB_ENCODER_GST (bencoder);
@@ -712,7 +720,7 @@ impl_encode (RBEncoder *bencoder,
 		encoder->priv->position_format = GST_FORMAT_BYTES;
 		encoder->priv->dest_media_type = rhythmdb_entry_dup_string (entry, RHYTHMDB_PROP_MEDIA_TYPE);
 
-		result = copy_track (encoder, entry, dest, &error);
+		result = copy_track (encoder, entry, dest, overwrite, &error);
 	} else {
 		gst_encoding_profile_ref (profile);
 		encoder->priv->profile = profile;
@@ -720,7 +728,7 @@ impl_encode (RBEncoder *bencoder,
 		encoder->priv->position_format = GST_FORMAT_TIME;
 		encoder->priv->dest_media_type = rb_gst_encoding_profile_get_media_type (profile);
 
-		result = transcode_track (encoder, entry, dest, &error);
+		result = transcode_track (encoder, entry, dest, overwrite, &error);
 	}
 
 	if (result == FALSE && encoder->priv->cancelled == FALSE) {
diff --git a/backends/rb-encoder.c b/backends/rb-encoder.c
index 37fff53..3fa1ddf 100644
--- a/backends/rb-encoder.c
+++ b/backends/rb-encoder.c
@@ -52,7 +52,6 @@ enum {
 	COMPLETED,
 	PREPARE_SOURCE,		/* this is on RBEncoderFactory */
 	PREPARE_SINK,		/* this is on RBEncoderFactory */
-	OVERWRITE,
 	LAST_SIGNAL
 };
 
@@ -154,24 +153,6 @@ rb_encoder_interface_init (RBEncoderIface *iface)
 			      rb_marshal_VOID__UINT64_STRING_POINTER,
 			      G_TYPE_NONE,
 			      3, G_TYPE_UINT64, G_TYPE_STRING, G_TYPE_POINTER);
-	/**
-	 * RBEncoder::overwrite:
-	 * @encoder: the #RBEncoder instance
-	 * @file: the #GFile that may be overwritten
-	 *
-	 * Emitted when a destination file already exists.  If the
-	 * return value if %TRUE, the file will be overwritten, otherwise
-	 * the transfer will be aborted.
-	 */
-	signals[OVERWRITE] =
-		g_signal_new ("overwrite",
-			      G_TYPE_FROM_INTERFACE (iface),
-			      G_SIGNAL_RUN_LAST,
-			      G_STRUCT_OFFSET (RBEncoderIface, overwrite),
-			      NULL, NULL,		/* need an accumulator here? */
-			      rb_marshal_BOOLEAN__OBJECT,
-			      G_TYPE_BOOLEAN,
-			      1, G_TYPE_OBJECT);
 }
 
 GType
@@ -221,6 +202,7 @@ rb_encoder_factory_get ()
  * @encoder: the #RBEncoder
  * @entry: the #RhythmDBEntry to transcode
  * @dest: destination file URI
+ * @overwrite: if %TRUE, overwrite @dest if it already exists
  * @profile: encoding profile to use, or NULL to just copy
  *
  * Initiates encoding, transcoding to the specified profile if specified.
@@ -232,11 +214,12 @@ void
 rb_encoder_encode (RBEncoder *encoder,
 		   RhythmDBEntry *entry,
 		   const char *dest,
+		   gboolean overwrite,
 		   GstEncodingProfile *profile)
 {
 	RBEncoderIface *iface = RB_ENCODER_GET_IFACE (encoder);
 
-	iface->encode (encoder, entry, dest, profile);
+	iface->encode (encoder, entry, dest, overwrite, profile);
 }
 
 /**
@@ -302,14 +285,6 @@ _rb_encoder_emit_completed (RBEncoder *encoder, guint64 dest_size, const char *m
 	g_signal_emit (encoder, signals[COMPLETED], 0, dest_size, mediatype, error);
 }
 
-gboolean
-_rb_encoder_emit_overwrite (RBEncoder *encoder, GFile *file)
-{
-	gboolean ret = FALSE;
-	g_signal_emit (encoder, signals[OVERWRITE], 0, file, &ret);
-	return ret;
-}
-
 void
 _rb_encoder_emit_prepare_source (RBEncoder *encoder, const char *uri, GObject *source)
 {
@@ -346,6 +321,7 @@ rb_encoder_error_get_type (void)
 			ENUM_ENTRY (RB_ENCODER_ERROR_FILE_ACCESS, "file-access-error"),
 			ENUM_ENTRY (RB_ENCODER_ERROR_OUT_OF_SPACE, "out-of-space"),
 			ENUM_ENTRY (RB_ENCODER_ERROR_DEST_READ_ONLY, "destination-read-only"),
+			ENUM_ENTRY (RB_ENCODER_ERROR_DEST_EXISTS, "destination-exists"),
 			{ 0, 0, 0 }
 		};
 
diff --git a/backends/rb-encoder.h b/backends/rb-encoder.h
index fa82dc0..9a77415 100644
--- a/backends/rb-encoder.h
+++ b/backends/rb-encoder.h
@@ -55,7 +55,8 @@ typedef enum
 	RB_ENCODER_ERROR_INTERNAL,
 	RB_ENCODER_ERROR_FILE_ACCESS,
 	RB_ENCODER_ERROR_OUT_OF_SPACE,
-	RB_ENCODER_ERROR_DEST_READ_ONLY
+	RB_ENCODER_ERROR_DEST_READ_ONLY,
+	RB_ENCODER_ERROR_DEST_EXISTS
 } RBEncoderError;
 
 GType rb_encoder_error_get_type (void);
@@ -76,6 +77,7 @@ struct _RBEncoderIface
 	void		(*encode)	(RBEncoder *encoder,
 					 RhythmDBEntry *entry,
 					 const char *dest,
+					 gboolean overwrite,
 					 GstEncodingProfile *profile);
 	void		(*cancel)	(RBEncoder *encoder);
 	gboolean	(*get_missing_plugins) (RBEncoder *encoder,
@@ -85,7 +87,6 @@ struct _RBEncoderIface
 
 	/* signals */
 	void (*progress) (RBEncoder *encoder,  double fraction);
-	gboolean (*overwrite) (RBEncoder *encoder, GFile *file);
 	void (*completed) (RBEncoder *encoder, guint64 dest_size, const char *mediatype, GError *error);
 };
 
@@ -113,6 +114,7 @@ GType 		rb_encoder_get_type 	(void);
 void		rb_encoder_encode	(RBEncoder *encoder,
 					 RhythmDBEntry *entry,
 					 const char *dest,
+					 gboolean overwrite,
 					 GstEncodingProfile *profile);
 void		rb_encoder_cancel	(RBEncoder *encoder);
 
@@ -124,7 +126,6 @@ gboolean	rb_encoder_get_missing_plugins (RBEncoder *encoder,
 /* only to be used by subclasses */
 void	_rb_encoder_emit_progress (RBEncoder *encoder, double fraction);
 void	_rb_encoder_emit_completed (RBEncoder *encoder, guint64 dest_size, const char *mediatype, GError *error);
-gboolean _rb_encoder_emit_overwrite (RBEncoder *encoder, GFile *file);
 
 void	_rb_encoder_emit_prepare_source (RBEncoder *encoder, const char *uri, GObject *source);
 void	_rb_encoder_emit_prepare_sink (RBEncoder *encoder, const char *uri, GObject *sink);
diff --git a/shell/rb-track-transfer-batch.c b/shell/rb-track-transfer-batch.c
index e77ea7a..45fdc23 100644
--- a/shell/rb-track-transfer-batch.c
+++ b/shell/rb-track-transfer-batch.c
@@ -70,6 +70,8 @@ static void	rb_track_transfer_batch_class_init (RBTrackTransferBatchClass *klass
 static void	rb_track_transfer_batch_init (RBTrackTransferBatch *batch);
 
 static gboolean start_next (RBTrackTransferBatch *batch);
+static void start_encoding (RBTrackTransferBatch *batch, gboolean overwrite);
+static void track_transfer_completed (RBTrackTransferBatch *batch, guint64 dest_size, const char *mediatype, GError *error);
 
 static guint	signals[LAST_SIGNAL] = { 0 };
 
@@ -95,6 +97,7 @@ struct _RBTrackTransferBatchPrivate
 	char *current_dest_uri;
 	double current_fraction;
 	RBEncoder *current_encoder;
+	GstEncodingProfile *current_profile;
 	gboolean cancelled;
 };
 
@@ -406,6 +409,24 @@ _rb_track_transfer_batch_cancel (RBTrackTransferBatch *batch)
 	/* anything else? */
 }
 
+/**
+ * _rb_track_transfer_batch_continue:
+ * @batch: a #RBTrackTransferBatch
+ * @overwrite: if %TRUE, overwrite the current file, otherwise skip
+ *
+ * Continues a transfer that was suspended because the current
+ * destination URI exists.  Only to be called by the #RBTrackTransferQueue.
+ */
+void
+_rb_track_transfer_batch_continue (RBTrackTransferBatch *batch, gboolean overwrite)
+{
+	if (overwrite) {
+		start_encoding (batch, TRUE);
+	} else {
+		track_transfer_completed (batch, 0, NULL, NULL);
+	}
+}
+
 static void
 emit_progress (RBTrackTransferBatch *batch)
 {
@@ -434,26 +455,18 @@ encoder_progress_cb (RBEncoder *encoder, double fraction, RBTrackTransferBatch *
 }
 
 static void
-encoder_completed_cb (RBEncoder *encoder,
-		      guint64 dest_size,
-		      const char *mediatype,
-		      GError *error,
-		      RBTrackTransferBatch *batch)
+track_transfer_completed (RBTrackTransferBatch *batch,
+			  guint64 dest_size,
+			  const char *mediatype,
+			  GError *error)
 {
 	RhythmDBEntry *entry;
 
-	if (error != NULL) {
-		rb_debug ("encoder finished (error: %s)", error->message);
-	} else {
-		rb_debug ("encoder finished (size %" G_GUINT64_FORMAT ")", dest_size);
-	}
-
-	g_object_unref (batch->priv->current_encoder);
-	batch->priv->current_encoder = NULL;
-
 	entry = batch->priv->current;
 	batch->priv->current = NULL;
 
+	batch->priv->current_profile = NULL;
+
 	/* update batch state to reflect that the track is done */
 	batch->priv->total_fraction += batch->priv->current_entry_fraction;
 	batch->priv->done_entries = g_list_append (batch->priv->done_entries, entry);
@@ -476,13 +489,28 @@ encoder_completed_cb (RBEncoder *encoder,
 	}
 }
 
-static gboolean
-encoder_overwrite_cb (RBEncoder *encoder, GFile *file, RBTrackTransferBatch *batch)
+static void
+encoder_completed_cb (RBEncoder *encoder,
+		      guint64 dest_size,
+		      const char *mediatype,
+		      GError *error,
+		      RBTrackTransferBatch *batch)
 {
-	gboolean overwrite = FALSE;
-	g_signal_emit (batch, signals[OVERWRITE_PROMPT], 0, file, &overwrite);
+	g_object_unref (batch->priv->current_encoder);
+	batch->priv->current_encoder = NULL;
+
+	if (error == NULL) {
+		rb_debug ("encoder finished (size %" G_GUINT64_FORMAT ")", dest_size);
+	} else if (g_error_matches (error, RB_ENCODER_ERROR, RB_ENCODER_ERROR_DEST_EXISTS)) {
+		rb_debug ("encoder stopped because destination %s already exists",
+			  batch->priv->current_dest_uri);
+		g_signal_emit (batch, signals[OVERWRITE_PROMPT], 0, batch->priv->current_dest_uri);
+		return;
+	} else {
+		rb_debug ("encoder finished (error: %s)", error->message);
+	}
 
-	return overwrite;
+	track_transfer_completed (batch, dest_size, mediatype, error);
 }
 
 static char *
@@ -506,6 +534,28 @@ get_extension_from_location (RhythmDBEntry *entry)
 	return extension;
 }
 
+static void
+start_encoding (RBTrackTransferBatch *batch, gboolean overwrite)
+{
+	if (batch->priv->current_encoder != NULL) {
+		g_object_unref (batch->priv->current_encoder);
+	}
+	batch->priv->current_encoder = rb_encoder_new ();
+
+	g_signal_connect_object (batch->priv->current_encoder, "progress",
+				 G_CALLBACK (encoder_progress_cb),
+				 batch, 0);
+	g_signal_connect_object (batch->priv->current_encoder, "completed",
+				 G_CALLBACK (encoder_completed_cb),
+				 batch, 0);
+
+	rb_encoder_encode (batch->priv->current_encoder,
+			   batch->priv->current,
+			   batch->priv->current_dest_uri,
+			   overwrite,
+			   batch->priv->current_profile);
+}
+
 static gboolean
 start_next (RBTrackTransferBatch *batch)
 {
@@ -522,17 +572,6 @@ start_next (RBTrackTransferBatch *batch)
 	}
 
 	batch->priv->current_fraction = 0.0;
-	batch->priv->current_encoder = rb_encoder_new ();
-
-	g_signal_connect_object (batch->priv->current_encoder, "progress",
-				 G_CALLBACK (encoder_progress_cb),
-				 batch, 0);
-	g_signal_connect_object (batch->priv->current_encoder, "overwrite",
-				 G_CALLBACK (encoder_overwrite_cb),
-				 batch, 0);
-	g_signal_connect_object (batch->priv->current_encoder, "completed",
-				 G_CALLBACK (encoder_completed_cb),
-				 batch, 0);
 
 	rb_debug ("%d entries remain in the batch", g_list_length (batch->priv->entries));
 
@@ -607,21 +646,15 @@ start_next (RBTrackTransferBatch *batch)
 
 		batch->priv->current = entry;
 		batch->priv->current_entry_fraction = fraction;
+		batch->priv->current_profile = profile;
 		break;
 	}
 
-	if (batch->priv->current == NULL) {
-		g_object_unref (batch->priv->current_encoder);
-		batch->priv->current_encoder = NULL;
-	} else {
+	if (batch->priv->current != NULL) {
 		g_signal_emit (batch, signals[TRACK_STARTED], 0,
 			       batch->priv->current,
 			       batch->priv->current_dest_uri);
-
-		rb_encoder_encode (batch->priv->current_encoder,
-				   batch->priv->current,
-				   batch->priv->current_dest_uri,
-				   profile);
+		start_encoding (batch, FALSE);
 	}
 
 	return TRUE;
@@ -930,11 +963,12 @@ rb_track_transfer_batch_class_init (RBTrackTransferBatchClass *klass)
 	/**
 	 * RBTrackTransferBatch::overwrite-prompt:
 	 * @batch: the #RBTrackTransferBatch
-	 * @file: the #GFile that may be overwritten
+	 * @uri: the destination URI that already exists
 	 *
 	 * Emitted when the destination URI for a transfer already exists.
-	 * If a handler returns TRUE, the file will be overwritten, otherwise
-	 * the transfer will be skipped.
+	 * The handler must call _rb_track_transfer_batch_continue or
+	 * _rb_track_transfer_batch_cancel when it has figured out what to
+	 * do.
 	 */
 	signals [OVERWRITE_PROMPT] =
 		g_signal_new ("overwrite-prompt",
@@ -942,9 +976,9 @@ rb_track_transfer_batch_class_init (RBTrackTransferBatchClass *klass)
 			      G_SIGNAL_RUN_LAST,
 			      G_STRUCT_OFFSET (RBTrackTransferBatchClass, overwrite_prompt),
 			      NULL, NULL,
-			      rb_marshal_BOOLEAN__OBJECT,
-			      G_TYPE_BOOLEAN,
-			      1, G_TYPE_FILE);
+			      g_cclosure_marshal_VOID__STRING,
+			      G_TYPE_NONE,
+			      1, G_TYPE_STRING);
 
 	/**
 	 * RBTrackTransferBatch::track-started:
diff --git a/shell/rb-track-transfer-batch.h b/shell/rb-track-transfer-batch.h
index 8cc7d75..f748e94 100644
--- a/shell/rb-track-transfer-batch.h
+++ b/shell/rb-track-transfer-batch.h
@@ -101,6 +101,9 @@ void			_rb_track_transfer_batch_start		(RBTrackTransferBatch *batch,
 								 GObject *queue);	/* eh */
 void			_rb_track_transfer_batch_cancel		(RBTrackTransferBatch *batch);
 
+void			_rb_track_transfer_batch_continue	(RBTrackTransferBatch *batch,
+								 gboolean overwrite);
+
 G_END_DECLS
 
 #endif /* __RB_TRACK_TRANSFER_BATCH_H */
diff --git a/shell/rb-track-transfer-queue.c b/shell/rb-track-transfer-queue.c
index 0f63a7b..91d5dac 100644
--- a/shell/rb-track-transfer-queue.c
+++ b/shell/rb-track-transfer-queue.c
@@ -100,22 +100,63 @@ rb_track_transfer_queue_new (RBShell *shell)
 	return g_object_new (RB_TYPE_TRACK_TRANSFER_QUEUE, "shell", shell, NULL);
 }
 
-static gboolean
-overwrite_prompt (RBTrackTransferBatch *batch, GFile *file, RBTrackTransferQueue *queue)
+static void
+overwrite_response_cb (GtkDialog *dialog, int response, RBTrackTransferQueue *queue)
+{
+	gtk_widget_destroy (GTK_WIDGET (dialog));
+
+	switch (response) {
+	case GTK_RESPONSE_YES:
+		rb_debug ("replacing existing file");
+		_rb_track_transfer_batch_continue (queue->priv->current, TRUE);
+		break;
+
+	case GTK_RESPONSE_NO:
+		rb_debug ("skipping existing file");
+		_rb_track_transfer_batch_continue (queue->priv->current, FALSE);
+		break;
+
+	case GTK_RESPONSE_REJECT:
+		rb_debug ("skipping all existing files");
+		queue->priv->overwrite_decision = OVERWRITE_NONE;
+		_rb_track_transfer_batch_continue (queue->priv->current, FALSE);
+		break;
+
+	case GTK_RESPONSE_ACCEPT:
+		rb_debug ("replacing all existing files");
+		queue->priv->overwrite_decision = OVERWRITE_ALL;
+		_rb_track_transfer_batch_continue (queue->priv->current, TRUE);
+		break;
+
+	case GTK_RESPONSE_CANCEL:
+	case GTK_RESPONSE_DELETE_EVENT:		/* not sure what the user really wants here */
+		rb_debug ("cancelling batch");
+		rb_track_transfer_queue_cancel_batch (queue, queue->priv->current);
+		break;
+
+	default:
+		g_assert_not_reached ();
+		break;
+	}
+}
+
+static void
+overwrite_prompt (RBTrackTransferBatch *batch, const char *uri, RBTrackTransferQueue *queue)
 {
 	switch (queue->priv->overwrite_decision) {
 	case OVERWRITE_PROMPT:
 	{
 		GtkWindow *window;
 		GtkWidget *dialog;
+		GFile *file;
 		GFileInfo *info;
-		gint response;
 		char *text;
 		char *free_name;
 		const char *display_name;
 
 		free_name = NULL;
 		display_name = NULL;
+		file = g_file_new_for_uri (uri);
 		info = g_file_query_info (file,
 					  G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME,
 					  G_FILE_QUERY_INFO_NONE,
@@ -151,47 +192,25 @@ overwrite_prompt (RBTrackTransferBatch *batch, GFile *file, RBTrackTransferQueue
 					_("Replace _All"), GTK_RESPONSE_ACCEPT,
 					NULL);
 
+		g_signal_connect (dialog, "response", G_CALLBACK (overwrite_response_cb), queue);
 		gtk_widget_show (GTK_WIDGET (dialog));
-		response = gtk_dialog_run (GTK_DIALOG (dialog));
-		gtk_widget_destroy (dialog);
 		g_free (free_name);
 		if (info != NULL) {
 			g_object_unref (info);
 		}
-
-		switch (response) {
-		case GTK_RESPONSE_YES:
-			rb_debug ("replacing existing file");
-			return TRUE;
-
-		case GTK_RESPONSE_NO:
-			rb_debug ("skipping existing file");
-			return FALSE;
-
-		case GTK_RESPONSE_REJECT:
-			rb_debug ("skipping all existing files");
-			queue->priv->overwrite_decision = OVERWRITE_NONE;
-			return FALSE;
-
-		case GTK_RESPONSE_ACCEPT:
-			rb_debug ("replacing all existing files");
-			queue->priv->overwrite_decision = OVERWRITE_ALL;
-			return TRUE;
-
-		case GTK_RESPONSE_CANCEL:
-			rb_debug ("cancelling batch");
-			rb_track_transfer_queue_cancel_batch (queue, batch);
-			return FALSE;
-		}
+		g_object_unref (file);
+		break;
 	}
 
 	case OVERWRITE_ALL:
 		rb_debug ("already decided to replace all existing files");
-		return TRUE;
+		_rb_track_transfer_batch_continue (batch, TRUE);
+		break;
 
 	case OVERWRITE_NONE:
 		rb_debug ("already decided to skip all existing files");
-		return FALSE;
+		_rb_track_transfer_batch_continue (batch, FALSE);
+		break;
 
 	default:
 		g_assert_not_reached ();
diff --git a/sources/rb-library-source.c b/sources/rb-library-source.c
index d9b2014..b66610a 100644
--- a/sources/rb-library-source.c
+++ b/sources/rb-library-source.c
@@ -1276,7 +1276,7 @@ track_done_cb (RBTrackTransferBatch *batch,
 		} else {
 			rb_error_dialog (NULL, _("Error transferring track"), "%s", error->message);
 		}
-	} else {
+	} else if (dest != NULL) {
 		/* could probably do something smarter here to avoid
 		 * re-reading tags etc.
 		 */
diff --git a/sources/rb-transfer-target.c b/sources/rb-transfer-target.c
index 478127d..985312e 100644
--- a/sources/rb-transfer-target.c
+++ b/sources/rb-transfer-target.c
@@ -360,15 +360,15 @@ track_done_cb (RBTrackTransferBatch *batch,
 	       GError *error,
 	       RBTransferTarget *target)
 {
-	if (error == NULL) {
-		rb_transfer_target_track_added (target, entry, dest, dest_size, dest_mediatype);
-	} else {
+	if (error != NULL) {
 		if (g_error_matches (error, RB_ENCODER_ERROR, RB_ENCODER_ERROR_OUT_OF_SPACE) ||
 		    g_error_matches (error, RB_ENCODER_ERROR, RB_ENCODER_ERROR_DEST_READ_ONLY)) {
 			rb_debug ("fatal transfer error: %s", error->message);
 			rb_track_transfer_batch_cancel (batch);
 		}
 		rb_transfer_target_track_add_error (target, entry, dest, error);
+	} else if (dest_size != 0) {
+		rb_transfer_target_track_added (target, entry, dest, dest_size, dest_mediatype);
 	}
 }
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]