X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~mdw/git/disorder/blobdiff_plain/c9fb35f42f28d2d158be9ff646248b16fc671d31..a3602333d0e12150d84396b1e5a1841ea3689e96:/disobedience/queue.c

diff --git a/disobedience/queue.c b/disobedience/queue.c
index 3a481a2..fe9e707 100644
--- a/disobedience/queue.c
+++ b/disobedience/queue.c
@@ -18,6 +18,7 @@
  * USA
  */
 #include "disobedience.h"
+#include "popup.h"
 #include "queue-generic.h"
 
 /** @brief The actual queue */
@@ -30,10 +31,33 @@ struct queue_entry *playing_track;
 /** @brief When we last got the playing track */
 time_t last_playing;
 
+static void queue_completed(void *v,
+                            const char *error,
+                            struct queue_entry *q);
+static void playing_completed(void *v,
+                              const char *error,
+                              struct queue_entry *q);
+
 /** @brief Called when either the actual queue or the playing track change */
 static void queue_playing_changed(void) {
-  struct queue_entry *q = xmalloc(sizeof *q);
 
+  /* Check that the playing track isn't in the queue.  There's a race here due
+   * to the fact that we issue the two commands at slightly different times.
+   * If it goes wrong we re-issue and try again, so that we never offer up an
+   * inconsistent state. */
+  if(actual_playing_track) {
+    struct queue_entry *q;
+    for(q = actual_queue; q; q = q->next)
+      if(!strcmp(q->id, actual_playing_track->id))
+        break;
+    if(q) {
+      disorder_eclient_playing(client, playing_completed, 0);
+      disorder_eclient_queue(client, queue_completed, 0);
+      return;
+    }
+  }
+  
+  struct queue_entry *q = xmalloc(sizeof *q);
   if(actual_playing_track) {
     *q = *actual_playing_track;
     q->next = actual_queue;
@@ -133,7 +157,7 @@ static const struct queue_column queue_columns[] = {
 };
 
 /** @brief Pop-up menu for queue */
-static struct queue_menuitem queue_menuitems[] = {
+static struct menuitem queue_menuitems[] = {
   { "Track properties", ql_properties_activate, ql_properties_sensitive, 0, 0 },
   { "Select all tracks", ql_selectall_activate, ql_selectall_sensitive, 0, 0 },
   { "Deselect all tracks", ql_selectnone_activate, ql_selectnone_sensitive, 0, 0 },
@@ -147,11 +171,173 @@ struct queuelike ql_queue = {
   .columns = queue_columns,
   .ncolumns = sizeof queue_columns / sizeof *queue_columns,
   .menuitems = queue_menuitems,
-  .nmenuitems = sizeof queue_menuitems / sizeof *queue_menuitems,
+  .nmenuitems = sizeof queue_menuitems / sizeof *queue_menuitems
 };
 
+/* Drag and drop has to be figured out experimentally, because it is not well
+ * documented.
+ *
+ * First you get a row-inserted.  The path argument points to the destination
+ * row but this will not yet have had its values set.  The source row is still
+ * present.  AFAICT the iter argument points to the same place.
+ *
+ * Then you get a row-deleted.  The path argument identifies the row that was
+ * deleted.  By this stage the row inserted above has acquired its values.
+ *
+ * A complication is that the deletion will move the inserted row.  For
+ * instance, if you do a drag that moves row 1 down to after the track that was
+ * formerly on row 9, in the row-inserted call it will show up as row 10, but
+ * in the row-deleted call, row 1 will have been deleted thus making the
+ * inserted row be row 9.
+ *
+ * So when we see the row-inserted we have no idea what track to move.
+ * Therefore we stash it until we see a row-deleted.
+ */
+
+/** @brief Target row for drag */
+static int queue_drag_target = -1;
+
+static void queue_move_completed(void attribute((unused)) *v,
+                                 const char *error) {
+  if(error) {
+    popup_protocol_error(0, error);
+    return;
+  }
+  /* The log should tell us the queue changed so we do no more here */
+}
+
+static void queue_row_deleted(GtkTreeModel *treemodel,
+                              GtkTreePath *path,
+                              gpointer attribute((unused)) user_data) {
+  if(!suppress_actions) {
+#if 0
+    char *ps = gtk_tree_path_to_string(path);
+    fprintf(stderr, "row-deleted path=%s queue_drag_target=%d\n",
+            ps, queue_drag_target);
+    GtkTreeIter j[1];
+    gboolean jt = gtk_tree_model_get_iter_first(treemodel, j);
+    int row = 0;
+    while(jt) {
+      struct queue_entry *q = ql_iter_to_q(treemodel, j);
+      fprintf(stderr, " %2d %s\n", row++, q ? q->track : "(no q)");
+      jt = gtk_tree_model_iter_next(GTK_TREE_MODEL(ql_queue.store), j);
+    }
+    g_free(ps);
+#endif
+    if(queue_drag_target < 0) {
+      error(0, "unsuppressed row-deleted with no row-inserted");
+      return;
+    }
+    int drag_source = gtk_tree_path_get_indices(path)[0];
+
+    /* If the drag is downwards (=towards higher row numbers) then the target
+     * will have been moved upwards (=towards lower row numbers) by one row. */
+    if(drag_source < queue_drag_target)
+      --queue_drag_target;
+    
+    /* Find the track to move */
+    GtkTreeIter src[1];
+    gboolean srcv = gtk_tree_model_iter_nth_child(treemodel, src, NULL,
+                                                  queue_drag_target);
+    if(!srcv) {
+      error(0, "cannot get iterator to drag target %d", queue_drag_target);
+      queue_playing_changed();
+      queue_drag_target = -1;
+      return;
+    }
+    struct queue_entry *srcq = ql_iter_to_q(treemodel, src);
+    assert(srcq);
+    //fprintf(stderr, "move %s %s\n", srcq->id, srcq->track);
+    
+    /* Don't allow the currently playing track to be moved.  As above, we put
+     * the queue back into the right order straight away. */
+    if(srcq == playing_track) {
+      //fprintf(stderr, "cannot move currently playing track\n");
+      queue_playing_changed();
+      queue_drag_target = -1;
+      return;
+    }
+
+    /* Find the destination */
+    struct queue_entry *dstq;
+    if(queue_drag_target) {
+      GtkTreeIter dst[1];
+      gboolean dstv = gtk_tree_model_iter_nth_child(treemodel, dst, NULL,
+                                                    queue_drag_target - 1);
+      if(!dstv) {
+        error(0, "cannot get iterator to drag target predecessor %d",
+              queue_drag_target - 1);
+        queue_playing_changed();
+        queue_drag_target = -1;
+        return;
+      }
+      dstq = ql_iter_to_q(treemodel, dst);
+      assert(dstq);
+      if(dstq == playing_track)
+        dstq = 0;
+    } else
+      dstq = 0;
+    /* NB if the user attempts to move a queued track before the currently
+     * playing track we assume they just missed a bit, and put it after. */
+    //fprintf(stderr, " target %s %s\n", dstq ? dstq->id : "(none)", dstq ? dstq->track : "(none)");
+    /* Now we know what is to be moved.  We need to know the preceding queue
+     * entry so we can move it. */
+    disorder_eclient_moveafter(client,
+                               dstq ? dstq->id : "",
+                               1, &srcq->id,
+                               queue_move_completed, NULL);
+    queue_drag_target = -1;
+  }
+}
+
+static void queue_row_inserted(GtkTreeModel attribute((unused)) *treemodel,
+                               GtkTreePath *path,
+                               GtkTreeIter attribute((unused)) *iter,
+                               gpointer attribute((unused)) user_data) {
+  if(!suppress_actions) {
+#if 0
+    char *ps = gtk_tree_path_to_string(path);
+    GtkTreeIter piter[1];
+    gboolean pi = gtk_tree_model_get_iter(treemodel, piter, path);
+    struct queue_entry *pq = pi ? ql_iter_to_q(treemodel, piter) : 0;
+    struct queue_entry *iq = ql_iter_to_q(treemodel, iter);
+
+    fprintf(stderr, "row-inserted path=%s pi=%d pq=%p path=%s iq=%p iter=%s\n",
+            ps,
+            pi,
+            pq,
+            (pi
+             ? (pq ? pq->track : "(pq=0)")
+             : "(pi=FALSE)"),
+            iq,
+            iq ? iq->track : "(iq=0)");
+
+    GtkTreeIter j[1];
+    gboolean jt = gtk_tree_model_get_iter_first(treemodel, j);
+    int row = 0;
+    while(jt) {
+      struct queue_entry *q = ql_iter_to_q(treemodel, j);
+      fprintf(stderr, " %2d %s\n", row++, q ? q->track : "(no q)");
+      jt = gtk_tree_model_iter_next(GTK_TREE_MODEL(ql_queue.store), j);
+    }
+    g_free(ps);
+#endif
+    queue_drag_target = gtk_tree_path_get_indices(path)[0];
+  }
+}
+
 GtkWidget *queue_widget(void) {
-  return init_queuelike(&ql_queue);
+  GtkWidget *const w = init_queuelike(&ql_queue);
+
+  /* Enable drag+drop */
+  gtk_tree_view_set_reorderable(GTK_TREE_VIEW(ql_queue.view), TRUE);
+  g_signal_connect(ql_queue.store,
+                   "row-inserted",
+                   G_CALLBACK(queue_row_inserted), &ql_queue);
+  g_signal_connect(ql_queue.store,
+                   "row-deleted",
+                   G_CALLBACK(queue_row_deleted), &ql_queue);
+  return w;
 }
 
 /** @brief Return nonzero if @p track is in the queue */