X-Git-Url: https://git.distorted.org.uk/~mdw/disorder/blobdiff_plain/846b01c278ea82514b09b029fb7c6b3aa8345f90..067cc12f8692c9567acb9d2e22aec24ac47a1913:/disobedience/queue-generic.c

diff --git a/disobedience/queue-generic.c b/disobedience/queue-generic.c
index 179998a..a2aa8ac 100644
--- a/disobedience/queue-generic.c
+++ b/disobedience/queue-generic.c
@@ -41,6 +41,7 @@
 #include "popup.h"
 #include "queue-generic.h"
 #include "multidrag.h"
+#include "autoscroll.h"
 
 static const GtkTargetEntry queuelike_targets[] = {
   {
@@ -424,6 +425,69 @@ void ql_new_queue(struct queuelike *ql,
   --suppress_actions;
 }
 
+/* Drag and drop ------------------------------------------------------------ */
+
+/** @brief Identify the drop path
+ * @param w Destination tree view widget
+ * @param model Underlying tree model
+ * @param wx X coordinate
+ * @param wy Y coordinate
+ * @param posp Where to store relative position
+ * @return Target path or NULL
+ *
+ * This is used by ql_drag_motion() and ql_drag_data_received() to identify a
+ * drop would or does land.  It's important that they use the same code since
+ * otherwise the visual feedback can be inconsistent with the actual effect!
+ */
+static GtkTreePath *ql_drop_path(GtkWidget *w,
+                                 GtkTreeModel *model,
+                                 int wx, int wy,
+                                 GtkTreeViewDropPosition *posp) {
+  GtkTreePath *path = NULL;
+  GtkTreeViewDropPosition pos;
+  GtkTreeIter iter[1], last[1];
+  int tx, ty;
+
+  gtk_tree_view_convert_widget_to_tree_coords(GTK_TREE_VIEW(w),
+                                              wx, wy, &tx, &ty);
+  if(gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(w),
+                                       wx, wy,
+                                       &path,
+                                       &pos)) {
+    //fprintf(stderr, "gtk_tree_view_get_dest_row_at_pos() -> TRUE\n");
+    // Normalize drop position
+    switch(pos) {
+    case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE:
+      pos = GTK_TREE_VIEW_DROP_BEFORE;
+      break;
+    case GTK_TREE_VIEW_DROP_INTO_OR_AFTER:
+      pos = GTK_TREE_VIEW_DROP_AFTER;
+      break;
+    default: break;
+    }
+  } else if(gtk_tree_model_get_iter_first(model, iter)) {
+    /* If the pointer isn't over any particular row then either it's below
+     * the last row, in which case we want the dropzone to be below that row;
+     * or it's above the first row (in the column headings) in which case we
+     * want the dropzone to be above that row. */
+    if(ty >= 0) {
+      /* Find the last row */
+      do {
+        *last = *iter;
+      } while(gtk_tree_model_iter_next(model, iter));
+      /* The drop target is just after it */
+      pos = GTK_TREE_VIEW_DROP_AFTER;
+      *iter = *last;
+    } else {
+      /* The drop target will be just before the first row */
+      pos = GTK_TREE_VIEW_DROP_BEFORE;
+    }
+    path = gtk_tree_model_get_path(model, iter);
+  }
+  *posp = pos;
+  return path;
+}
+
 /** @brief Called when a drag moves within a candidate destination
  * @param w Destination widget
  * @param dc Drag context
@@ -432,16 +496,18 @@ void ql_new_queue(struct queuelike *ql,
  * @param time_ Current time
  * @param user_data Pointer to queuelike
  * @return TRUE in a dropzone, otherwise FALSE
+ *
+ * This is the handler for the "drag-motion" signal.
  */
 static gboolean ql_drag_motion(GtkWidget *w,
                                GdkDragContext *dc,
                                gint x,
                                gint y,
                                guint time_,
-                               gpointer attribute((unused)) user_data) {
-  //struct queuelike *const ql = user_data;
+                               gpointer user_data) {
+  struct queuelike *const ql = user_data;
   GdkDragAction action = 0;
-  
+
   // GTK_DEST_DEFAULT_MOTION vets actions as follows:
   // 1) if dc->suggested_action is in the gtk_drag_dest_set actions
   //    then dc->suggested_action is taken as the action.
@@ -464,35 +530,20 @@ static gboolean ql_drag_motion(GtkWidget *w,
       action = 0;
   }
   // Report the status
+  //fprintf(stderr, "drag action: %u\n", action);
   gdk_drag_status(dc, action, time_);
   if(action) {
-    // Highlight the drop area
-    GtkTreePath *path;
     GtkTreeViewDropPosition pos;
 
-    if(gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(w),
-                                         x, y,
-                                         &path,
-                                         &pos)) {
-      //fprintf(stderr, "gtk_tree_view_get_dest_row_at_pos() -> TRUE\n");
-      // Normalize drop position
-      switch(pos) {
-      case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE:
-        pos = GTK_TREE_VIEW_DROP_BEFORE;
-        break;
-      case GTK_TREE_VIEW_DROP_INTO_OR_AFTER:
-        pos = GTK_TREE_VIEW_DROP_AFTER;
-        break;
-      default: break;
-      }
-      // Highlight drop target
-      gtk_tree_view_set_drag_dest_row(GTK_TREE_VIEW(w), path, pos);
-    } else {
-      //fprintf(stderr, "gtk_tree_view_get_dest_row_at_pos() -> FALSE\n");
-      gtk_tree_view_set_drag_dest_row(GTK_TREE_VIEW(w), NULL, 0);
-    }
+    // Find the drop target
+    GtkTreePath *path = ql_drop_path(w, GTK_TREE_MODEL(ql->store), x, y, &pos);
+    // Highlight drop target
+    gtk_tree_view_set_drag_dest_row(GTK_TREE_VIEW(w), path, pos);
+    if(path)
+      gtk_tree_path_free(path);
   }
-  return TRUE;
+  autoscroll_add(GTK_TREE_VIEW(w));
+  return TRUE;                          /* We are (always) in a drop zone */
 }
 
 /** @brief Called when a drag moves leaves a candidate destination
@@ -500,6 +551,13 @@ static gboolean ql_drag_motion(GtkWidget *w,
  * @param dc Drag context
  * @param time_ Current time
  * @param user_data Pointer to queuelike
+ *
+ * This is the handler for the "drag-leave" signal.
+ *
+ * It turns out that we get a drag-leave event when the data is dropped, too
+ * (See _gtk_drag_dest_handle_event).  This seems logically consistent and is
+ * convenient too - for instance it's why autoscroll_remove() gets called at
+ * the end of a drag+drop sequence.
  */
 static void ql_drag_leave(GtkWidget *w,
                           GdkDragContext attribute((unused)) *dc,
@@ -508,6 +566,7 @@ static void ql_drag_leave(GtkWidget *w,
   //struct queuelike *const ql = user_data;
 
   gtk_tree_view_set_drag_dest_row(GTK_TREE_VIEW(w), NULL, 0);
+  autoscroll_remove(GTK_TREE_VIEW(w));
 }
 
 /** @brief Callback to add selected tracks to the selection data
@@ -534,6 +593,15 @@ static void ql_drag_data_get_collect(GtkTreeModel *model,
  * @param info_ Target @c info parameter
  * @param time_ Time data requested (for some reason not a @c time_t)
  * @param user_data The queuelike
+ *
+ * The list of tracks is converted into a single string, consisting of IDs
+ * and track names.  Each is terminated by a newline.  Including both ID and
+ * track name means that the receiver can use whichever happens to be more
+ * convenient.
+ *
+ * If there are no IDs for rows in this widget then the ID half is undefined.
+ *
+ * This is the handler for the "drag-data-get" signal.
  */
 static void ql_drag_data_get(GtkWidget attribute((unused)) *w,
                              GdkDragContext attribute((unused)) *dc,
@@ -544,10 +612,6 @@ static void ql_drag_data_get(GtkWidget attribute((unused)) *w,
   struct queuelike *const ql = user_data;
   struct dynstr result[1];
 
-  /* The list of tracks is converted into a single string, consisting of IDs
-   * and track names.  Each is terminated by a newline.  Including both ID and
-   * track name means that the receiver can use whichever happens to be more
-   * convenient. */
   dynstr_init(result);
   gtk_tree_selection_selected_foreach(ql->selection,
                                       ql_drag_data_get_collect,
@@ -572,6 +636,8 @@ static void ql_drag_data_get(GtkWidget attribute((unused)) *w,
  * @param info_ The target type that was chosen
  * @param time_ Time data received (for some reason not a @c time_t)
  * @param user_data The queuelike
+ *
+ * This is the handler for the "drag-data-received" signal.
  */
 static void ql_drag_data_received(GtkWidget attribute((unused)) *w,
                                   GdkDragContext attribute((unused)) *dc,
@@ -614,37 +680,28 @@ static void ql_drag_data_received(GtkWidget attribute((unused)) *w,
   vector_terminate(ids);
   vector_terminate(tracks);
   /* Figure out which row the drop precedes (if any) */
-  GtkTreePath *path;
   GtkTreeViewDropPosition pos;
   struct queue_entry *q;
-  if(!gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(ql->view), x, y,
-                                        &path, &pos)) {
-    //fprintf(stderr, "gtk_tree_view_get_dest_row_at_pos returned FALSE\n");
+  GtkTreePath *path = ql_drop_path(w, GTK_TREE_MODEL(ql->store), x, y, &pos);
+  if(path) {
+    q = ql_path_to_q(GTK_TREE_MODEL(ql->store), path);
+  } else {
     /* This generally means a drop past the end of the queue.  We find the last
      * element in the queue and ask to move after that. */
     for(q = ql->q; q && q->next; q = q->next)
       ;
-  } else {
-    /* Convert the path to a queue entry pointer. */
-    q = ql_path_to_q(GTK_TREE_MODEL(ql->store), path);
-    //fprintf(stderr, "  tree view likes to drop near %s\n",
-    //        q->id ? q->id : "NULL");
-    /* TODO interpretation of q=NULL */
-    /* Q should point to the entry just before the insertion point, so that
-     * moveafter works, or NULL to insert right at the start.  We don't support
-     * dropping into a row, since that doesn't make sense for us. */
-    switch(pos) {
-    case GTK_TREE_VIEW_DROP_BEFORE:
-    case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE:
-      if(q) {
-        q = q->prev;
-        //fprintf(stderr, "  ...but we like to drop near %s\n",
-        //        q ? q->id : "NULL");
-      }
-      break;
-    default:
-      break;
+  }
+  switch(pos) {
+  case GTK_TREE_VIEW_DROP_BEFORE:
+  case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE:
+    if(q) {
+      q = q->prev;
+      //fprintf(stderr, "  ...but we like to drop near %s\n",
+      //        q ? q->id : "NULL");
     }
+    break;
+  default:
+    break;
   }
   /* Guarantee we never drop an empty list */
   if(!tracks->nvec)
@@ -747,7 +804,8 @@ GtkWidget *init_queuelike(struct queuelike *ql) {
                      G_CALLBACK(ql_drag_data_get), ql);
     g_signal_connect(ql->view, "drag-data-received",
                      G_CALLBACK(ql_drag_data_received), ql);
-    make_treeview_multidrag(ql->view);
+    make_treeview_multidrag(ql->view, NULL);
+    // TODO playing track should be refused by predicate arg
   } else {
     /* For queues that cannot accept a drop we still accept a copy out */
     gtk_drag_source_set(ql->view,
@@ -757,7 +815,7 @@ GtkWidget *init_queuelike(struct queuelike *ql) {
                         GDK_ACTION_COPY);
     g_signal_connect(ql->view, "drag-data-get",
                      G_CALLBACK(ql_drag_data_get), ql);
-    make_treeview_multidrag(ql->view);
+    make_treeview_multidrag(ql->view, NULL);
   }
   
   /* TODO style? */