+
+#if DEBUG_QUEUE
+ fprintf(stderr, "%s: constructing h\n", ql->name);
+#endif
+ /* Construct map from id to new and old structures */
+ hash *h = hash_new(sizeof(struct newqueue_data));
+ for(struct queue_entry *q = ql->q; q; q = q->next)
+ record_queue_map(h, q->id, q, NULL);
+ for(struct queue_entry *q = newq; q; q = q->next)
+ record_queue_map(h, q->id, NULL, q);
+
+ /* The easy bit: delete rows not present any more. In the same pass we
+ * update the secret column containing the queue_entry pointer. */
+#if DEBUG_QUEUE
+ fprintf(stderr, "%s: deleting rows...\n", ql->name);
+#endif
+ GtkTreeIter iter[1];
+ gboolean it = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(ql->store),
+ iter);
+ int inserted = 0, deleted = 0, kept = 0;
+ while(it) {
+ struct queue_entry *q = ql_iter_to_q(GTK_TREE_MODEL(ql->store), iter);
+ const struct newqueue_data *nqd = hash_find(h, q->id);
+ if(nqd->new) {
+ /* Tell this row that it belongs to the new version of the queue */
+ gtk_list_store_set(ql->store, iter,
+ ql->ncolumns + QUEUEPOINTER_COLUMN, nqd->new,
+ -1);
+ it = gtk_tree_model_iter_next(GTK_TREE_MODEL(ql->store), iter);
+ ++kept;
+ } else {
+ /* Delete this row (and move iter to the next one) */
+#if DEBUG_QUEUE
+ fprintf(stderr, " delete %s\n", q->id);
+#endif
+ it = gtk_list_store_remove(ql->store, iter);
+ ++deleted;
+ }
+ }
+
+ /* Now every row's secret column is right, but we might be missing new rows
+ * and they might be in the wrong order */
+
+ /* We're going to have to support arbitrary rearrangements, so we might as
+ * well add new elements at the end. */
+#if DEBUG_QUEUE
+ fprintf(stderr, "%s: adding rows...\n", ql->name);
+#endif
+ struct queue_entry *after = 0;
+ for(struct queue_entry *q = newq; q; q = q->next) {
+ const struct newqueue_data *nqd = hash_find(h, q->id);
+ if(!nqd->old) {
+ if(after) {
+ /* Try to insert at the right sort of place */
+ GtkTreeIter where[1];
+ gboolean wit = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(ql->store),
+ where);
+ while(wit && ql_iter_to_q(GTK_TREE_MODEL(ql->store), where) != after)
+ wit = gtk_tree_model_iter_next(GTK_TREE_MODEL(ql->store), where);
+ if(wit)
+ gtk_list_store_insert_after(ql->store, iter, where);
+ else
+ gtk_list_store_append(ql->store, iter);
+ } else
+ gtk_list_store_prepend(ql->store, iter);
+ gtk_list_store_set(ql->store, iter,
+ ql->ncolumns + QUEUEPOINTER_COLUMN, q,
+ -1);
+#if DEBUG_QUEUE
+ fprintf(stderr, " add %s\n", q->id);
+#endif
+ ++inserted;
+ }
+ after = newq;
+ }
+
+ /* Now exactly the right set of rows are present, and they have the right
+ * queue_entry pointers in their secret column, but they may be in the wrong
+ * order.
+ *
+ * The current code is simple but amounts to a bubble-sort - we might easily
+ * called gtk_tree_model_iter_next a couple of thousand times.
+ */
+#if DEBUG_QUEUE
+ fprintf(stderr, "%s: rearranging rows\n", ql->name);
+ fprintf(stderr, "%s: target state:\n", ql->name);
+ dump_queue(newq, 0);
+ fprintf(stderr, "%s: current state:\n", ql->name);
+ dump_rows(ql);
+#endif
+ it = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(ql->store), iter);
+ struct queue_entry *tq = newq; /* t-for-target */
+ int swaps = 0, searches = 0;
+ int row = 0;
+ while(it) {
+ struct queue_entry *cq = ql_iter_to_q(GTK_TREE_MODEL(ql->store), iter);
+ /* c-for-current */
+
+ /* Everything has the right queue pointer (see above) so it's sufficient to
+ * compare pointers to detect mismatches */
+ if(cq != tq) {
+#if DEBUG_QUEUE
+ fprintf(stderr, " pointer mismatch at row %d\n", row);
+ fprintf(stderr, " target id %s\n", tq->id);
+ fprintf(stderr, " actual id %s\n", cq->id);
+#endif
+ /* Start looking for the target row fromn the next row */
+ GtkTreeIter next[1] = { *iter };
+ gboolean nit = gtk_tree_model_iter_next(GTK_TREE_MODEL(ql->store), next);
+ while(nit) {
+ struct queue_entry *nq = ql_iter_to_q(GTK_TREE_MODEL(ql->store), next);
+#if DEBUG_QUEUE
+ fprintf(stderr, " candidate: %s\n", nq->id);
+#endif
+ if(nq == tq)
+ break;
+ nit = gtk_tree_model_iter_next(GTK_TREE_MODEL(ql->store), next);
+ ++searches;
+ }
+ /* Note that this assertion will fail in the face of duplicate IDs.
+ * q->id really does need to be unique. */
+ assert(nit);
+ gtk_list_store_swap(ql->store, iter, next);
+ *iter = *next;
+#if DEBUG_QUEUE
+ fprintf(stderr, "%s: found it. new row state:\n", ql->name);
+ dump_rows(ql);
+#endif
+ ++swaps;
+ }
+ /* ...and onto the next one */
+ it = gtk_tree_model_iter_next(GTK_TREE_MODEL(ql->store), iter);
+ tq = tq->next;
+ ++row;
+ }
+#if DEBUG_QUEUE
+ fprintf(stderr, "%6s: %3d kept %3d inserted %3d deleted %3d swaps %4d searches\n", ql->name,
+ kept, inserted, deleted, swaps, searches);
+ fprintf(stderr, "done\n");
+#endif
+ ql->q = newq;
+ /* Set the rest of the columns in new rows */
+ ql_update_list_store(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!
+ *
+ * Remember to free the returned path.
+ */
+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;
+}
+
+#if 0
+static const char *act(GdkDragAction action) {
+ struct dynstr d[1];
+
+ dynstr_init(d);
+ if(action & GDK_ACTION_DEFAULT)
+ dynstr_append_string(d, "|DEFAULT");
+ if(action & GDK_ACTION_COPY)
+ dynstr_append_string(d, "|COPY");
+ if(action & GDK_ACTION_MOVE)
+ dynstr_append_string(d, "|MOVE");
+ if(action & GDK_ACTION_LINK)
+ dynstr_append_string(d, "|LINK");
+ if(action & GDK_ACTION_PRIVATE)
+ dynstr_append_string(d, "|PRIVATE");
+ if(action & GDK_ACTION_ASK)
+ dynstr_append_string(d, "|ASK");
+ dynstr_terminate(d);
+ return d->nvec ? d->vec + 1 : "";
+}
+#endif
+
+/** @brief Called when a drag moves within a candidate destination
+ * @param w Destination widget
+ * @param dc Drag context
+ * @param x Current pointer location
+ * @param y Current pointer location
+ * @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 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.
+ // 2) otherwise if dc->actions intersects the gtk_drag_dest_set actions
+ // then the lowest-numbered member of the intersection is chosen.
+ // 3) otherwise no member is chosen and gdk_drag_status() is called
+ // with action=0 to refuse the drop.
+ if(dc->suggested_action) {
+ if(dc->suggested_action & (GDK_ACTION_MOVE|GDK_ACTION_COPY))
+ action = dc->suggested_action;
+ } else if(dc->actions & GDK_ACTION_MOVE)
+ action = GDK_ACTION_MOVE;
+ else if(dc->actions & GDK_ACTION_COPY)
+ action = GDK_ACTION_COPY;
+ /* TODO this comes up with the wrong answer sometimes. If we are in the
+ * middle of a rearrange then the suggested action will be COPY, which we'll
+ * take, even though MOVE would actually be appropriate. The drag still
+ * seems to work, but it _is_ wrong. The answer is to take the target into
+ * account. */
+ /*fprintf(stderr, "suggested %s actions %s result %s\n",
+ act(dc->suggested_action), act(dc->actions), act(action));*/
+ if(action) {
+ // If the action is acceptable then we see if this widget is acceptable
+ if(gtk_drag_dest_find_target(w, dc, NULL) == GDK_NONE)
+ action = 0;
+ }
+ // Report the status
+ //fprintf(stderr, "drag action: %u\n", action);
+ gdk_drag_status(dc, action, time_);
+ if(action) {
+ GtkTreeViewDropPosition pos;
+
+ // 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);
+ }
+ 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
+ * @param w Destination widget
+ * @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,
+ guint attribute((unused)) time_,
+ gpointer attribute((unused)) user_data) {
+ //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
+ *
+ * Called from ql_drag_data_get().
+ */
+static void ql_drag_data_get_collect(GtkTreeModel *model,
+ GtkTreePath attribute((unused)) *path,
+ GtkTreeIter *iter,
+ gpointer data) {
+ struct dynstr *const result = data;
+ struct queue_entry *const q = ql_iter_to_q(model, iter);
+
+ dynstr_append_string(result, q->id);
+ dynstr_append(result, '\n');
+ dynstr_append_string(result, q->track);
+ dynstr_append(result, '\n');
+}
+
+/** @brief Called to extract the dragged data from the source queuelike
+ * @param w Source widget (the tree view)
+ * @param dc Drag context
+ * @param data Where to put the answer
+ * @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,
+ GtkSelectionData *data,
+ guint attribute((unused)) info,
+ guint attribute((unused)) time_,
+ gpointer user_data) {
+ struct queuelike *const ql = user_data;
+ struct dynstr result[1];
+
+ //fprintf(stderr, "ql_drag_data_get %s info=%d\n", ql->name, info);
+ dynstr_init(result);
+ gtk_tree_selection_selected_foreach(ql->selection,
+ ql_drag_data_get_collect,
+ result);
+ // TODO must not be able to drag playing track!
+ //fprintf(stderr, "drag-data-get: %.*s\n",
+ // result->nvec, result->vec);
+ /* gtk_selection_data_set_text() insists that data->target is one of a
+ * variety of stringy atoms. TODO: where does this value actually come
+ * from? */
+ gtk_selection_data_set(data,
+ GDK_TARGET_STRING,
+ 8, (guchar *)result->vec, result->nvec);
+}
+
+/** @brief Called when drag data is received
+ * @param w Target widget (the tree view)
+ * @param dc Drag context
+ * @param x The drop location
+ * @param y The drop location
+ * @param data The selection data
+ * @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,
+ gint x,
+ gint y,
+ GtkSelectionData *data,
+ guint info_,
+ guint attribute((unused)) time_,
+ gpointer user_data) {
+ struct queuelike *const ql = user_data;
+ char *result, *p;
+ struct vector ids[1], tracks[1];
+ int parity = 0;
+
+ //fprintf(stderr, "drag-data-received: %d,%d info=%u\n", x, y, info_);
+ /* Get the selection string */
+ p = result = (char *)gtk_selection_data_get_text(data);
+ if(!result) {
+ //fprintf(stderr, "gtk_selection_data_get_text() returned NULL\n");
+ return;
+ }
+ //fprintf(stderr, "%s--\n", result);
+ /* Parse it back into IDs and track names */
+ vector_init(ids);
+ vector_init(tracks);
+ while(*p) {
+ char *nl = strchr(p, '\n');
+ if(!nl)
+ break;
+ *nl = 0;
+ //fprintf(stderr, " %s\n", p);
+ vector_append(parity++ & 1 ? tracks : ids, xstrdup(p));
+ p = nl + 1;
+ }
+ g_free(result);
+ if(ids->nvec != tracks->nvec) {
+ //fprintf(stderr, " inconsistent drag data!\n");
+ return;
+ }
+ vector_terminate(ids);
+ vector_terminate(tracks);
+ /* Figure out which row the drop precedes (if any) */
+ GtkTreeViewDropPosition pos;
+ struct queue_entry *q;
+ 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);
+ //fprintf(stderr, " drop path: %s q=%p pos=%d\n",
+ // gtk_tree_path_to_string(path), q, pos);
+ } 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)
+ ;
+ //fprintf(stderr, " after end. q=%p. pos=%d\n", q, pos);
+ }
+ 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;