/*
* This file is part of DisOrder
- * Copyright (C) 2006-2008 Richard Kettlewell
+ * Copyright (C) 2006-2009 Richard Kettlewell
*
- * This program is free software; you can redistribute it and/or modify
+ * This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
+ * the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * General Public License for more details.
- *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
* You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
- * USA
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/** @file disobedience/queue-generic.c
- * @brief Queue widgets
+ * @brief Disobedience queue widgets
*
* This file provides contains code shared between all the queue-like
* widgets - the queue, the recent list and the added tracks list.
#include "disobedience.h"
#include "popup.h"
#include "queue-generic.h"
-
-static struct queuelike *const queuelikes[] = {
- &ql_queue, &ql_recent, &ql_added
+#include "multidrag.h"
+#include "autoscroll.h"
+
+static const GtkTargetEntry queuelike_targets[] = {
+ {
+ (char *)"text/x-disorder-queued-tracks", /* drag type */
+ GTK_TARGET_SAME_WIDGET, /* rearrangement within a widget */
+ 0 /* ID value */
+ },
+ {
+ (char *)"text/x-disorder-playable-tracks", /* drag type */
+ GTK_TARGET_SAME_APP|GTK_TARGET_OTHER_WIDGET, /* copying between widgets */
+ 1 /* ID value */
+ },
};
-#define NQUEUELIKES (sizeof queuelikes / sizeof *queuelikes)
/* Track detail lookup ----------------------------------------------------- */
if(last_state & DISORDER_TRACK_PAUSED)
l = playing_track->sofar;
else {
- time(&now);
+ if(!last_playing)
+ return NULL;
+ xtime(&now);
l = playing_track->sofar + (now - last_playing);
}
byte_xasprintf(&played, "%ld:%02ld/%s", l / 60, l % 60, length);
return q;
}
+/** @brief Return the @ref queue_entry corresponding to @p path
+ * @param model Model to query
+ * @param path Path into tree
+ * @return Pointer to queue entry or NULL
+ */
+struct queue_entry *ql_path_to_q(GtkTreeModel *model,
+ GtkTreePath *path) {
+ GtkTreeIter iter[1];
+ if(!gtk_tree_model_get_iter(model, iter, path))
+ return NULL;
+ return ql_iter_to_q(model, iter);
+}
+
/** @brief Update one row of a list store
* @param q Queue entry
* @param iter Iterator referring to row or NULL to work it out
iter = my_iter;
}
/* Update all the columns */
- for(int col = 0; col < ql->ncolumns; ++col)
- gtk_list_store_set(ql->store, iter,
- col, ql->columns[col].value(q,
- ql->columns[col].data),
- -1);
+ for(int col = 0; col < ql->ncolumns; ++col) {
+ const char *const v = ql->columns[col].value(q,
+ ql->columns[col].data);
+ if(v)
+ gtk_list_store_set(ql->store, iter,
+ col, v,
+ -1);
+ }
gtk_list_store_set(ql->store, iter,
ql->ncolumns + QUEUEPOINTER_COLUMN, q,
-1);
hash_add(h, id, empty, HASH_INSERT);
nqd = hash_find(h, id);
}
- if(old)
+ if(old) {
+#if DEBUG_QUEUE
+ fprintf(stderr, " old: %s\n", id);
+#endif
nqd->old = old;
- if(new)
+ }
+ if(new) {
+#if DEBUG_QUEUE
+ fprintf(stderr, " new: %s\n", id);
+#endif
nqd->new = new;
+ }
}
-#if 0
+#if DEBUG_QUEUE
static void dump_queue(struct queue_entry *head, struct queue_entry *mark) {
for(struct queue_entry *q = head; q; q = q->next) {
if(q == mark)
- fprintf(stderr, "!");
- fprintf(stderr, "%s", q->id);
- if(q->next)
- fprintf(stderr, " ");
+ fprintf(stderr, " !");
+ fprintf(stderr, " %s\n", q->id);
}
- fprintf(stderr, "\n");
}
static void dump_rows(struct queuelike *ql) {
while(it) {
struct queue_entry *q = ql_iter_to_q(GTK_TREE_MODEL(ql->store), iter);
it = gtk_tree_model_iter_next(GTK_TREE_MODEL(ql->store), iter);
- fprintf(stderr, "%s", q->id);
- if(it)
- fprintf(stderr, " ");
+ fprintf(stderr, " %s\n", q->id);
}
- fprintf(stderr, "\n");
}
#endif
++suppress_actions;
/* Tell every queue entry which queue owns it */
- //fprintf(stderr, "%s: filling in q->ql\n", ql->name);
+#if DEBUG_QUEUE
+ fprintf(stderr, "%s: filling in q->ql\n", ql->name);
+#endif
for(struct queue_entry *q = newq; q; q = q->next)
q->ql = ql;
- //fprintf(stderr, "%s: constructing h\n", ql->name);
+#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)
/* The easy bit: delete rows not present any more. In the same pass we
* update the secret column containing the queue_entry pointer. */
- //fprintf(stderr, "%s: deleting rows...\n", ql->name);
+#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);
++kept;
} else {
/* Delete this row (and move iter to the next one) */
- //fprintf(stderr, " delete %s", q->id);
+#if DEBUG_QUEUE
+ fprintf(stderr, " delete %s\n", q->id);
+#endif
it = gtk_list_store_remove(ql->store, iter);
++deleted;
}
/* We're going to have to support arbitrary rearrangements, so we might as
* well add new elements at the end. */
- //fprintf(stderr, "%s: adding rows...\n", ql->name);
+#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);
gtk_list_store_set(ql->store, iter,
ql->ncolumns + QUEUEPOINTER_COLUMN, q,
-1);
- //fprintf(stderr, " add %s", q->id);
+#if DEBUG_QUEUE
+ fprintf(stderr, " add %s\n", q->id);
+#endif
++inserted;
}
after = newq;
* 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.
*/
- //fprintf(stderr, "%s: rearranging rows\n", ql->name);
- //fprintf(stderr, "%s: queue state: ", ql->name);
- //dump_queue(newq, 0);
- //fprintf(stderr, "%s: row state: ", ql->name);
- //dump_rows(ql);
- it = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(ql->store),
- iter);
- struct queue_entry *rq = newq; /* r for 'right, correct' */
+#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 *q = ql_iter_to_q(GTK_TREE_MODEL(ql->store), iter);
- //fprintf(stderr, " rq = %p, q = %p\n", rq, q);
- //fprintf(stderr, " rq->id = %s, q->id = %s\n", rq->id, q->id);
-
- if(q != rq) {
- //fprintf(stderr, " mismatch\n");
+ 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);
- //fprintf(stderr, " candidate: %s\n", nq->id);
- if(nq == rq)
+#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;
}
assert(nit);
- //fprintf(stderr, " found it\n");
gtk_list_store_swap(ql->store, iter, next);
*iter = *next;
- //fprintf(stderr, "%s: new row state: ", ql->name);
- //dump_rows(ql);
+#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);
- rq = rq->next;
+ tq = tq->next;
+ ++row;
}
-#if 0
+#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
- //fprintf(stderr, "done\n");
ql->q = newq;
/* Set the rest of the columns in new rows */
ql_update_list_store(ql);
--suppress_actions;
}
-/* 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.
+/* 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
*
- * 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.
+ * 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!
*
- * 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.
+ * Remember to free the returned path.
*/
-
-/** @brief row-inserted callback */
-static void ql_row_inserted(GtkTreeModel attribute((unused)) *treemodel,
- GtkTreePath *path,
- GtkTreeIter attribute((unused)) *iter,
- gpointer user_data) {
- struct queuelike *const ql = 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 %s path=%s pi=%d pq=%p path=%s iq=%p iter=%s\n",
- ql->name,
- 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->store), j);
+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;
}
- g_free(ps);
-#endif
- /* Remember an iterator pointing at the insertion target */
- if(ql->drag_target)
- gtk_tree_path_free(ql->drag_target);
- ql->drag_target = gtk_tree_path_copy(path);
+ } 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 row-deleted callback */
-static void ql_row_deleted(GtkTreeModel attribute((unused)) *treemodel,
- GtkTreePath *path,
- gpointer user_data) {
+/** @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;
+ /*fprintf(stderr, "suggested %#x actions %#x result %#x\n",
+ dc->suggested_action, dc->actions, 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 */
+}
- if(!suppress_actions) {
-#if 0
- char *ps = gtk_tree_path_to_string(path);
- fprintf(stderr, "row-deleted %s path=%s ql->drag_target=%s\n",
- ql->name, ps, gtk_tree_path_to_string(ql->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->store), j);
- }
- g_free(ps);
-#endif
- if(!ql->drag_target) {
- error(0, "%s: unsuppressed row-deleted with no row-inserted",
- ql->name);
- return;
- }
-
- /* Get the source and destination row numbers. */
- int srcrow = gtk_tree_path_get_indices(path)[0];
- int dstrow = gtk_tree_path_get_indices(ql->drag_target)[0];
- //fprintf(stderr, "srcrow=%d dstrow=%d\n", srcrow, dstrow);
+/** @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));
+}
- /* Note that the source row is computed AFTER the destination has been
- * inserted, since GTK+ does the insert before the delete. Therefore if
- * the source row is south (higher row number) of the destination, it will
- * be one higher than expected.
- *
- * For instance if we drag row 1 to before row 0 we will see row-inserted
- * for row 0 but then a row-deleted for row 2.
- */
- if(srcrow > dstrow)
- --srcrow;
+/** @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');
+}
- /* Tell the queue implementation */
- ql->drop(srcrow, dstrow);
+/** @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];
+
+ 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);
+}
- /* Dispose of stashed data */
- gtk_tree_path_free(ql->drag_target);
- ql->drag_target = 0;
+/** @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 attribute((unused)) 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);
+ } 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)
+ ;
}
+ 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)
+ return;
+ /* Note that q->id can match one of ids[]. This doesn't matter for
+ * moveafter but TODO may matter for playlist support. */
+ switch(info_) {
+ case 0:
+ /* Rearrangement. Send ID and track data. */
+ ql->drop(ql, tracks->nvec, tracks->vec, ids->vec, q);
+ break;
+ case 1:
+ /* Copying between widgets. IDs mean nothing so don't send them. */
+ ql->drop(ql, tracks->nvec, tracks->vec, NULL, q);
+ break;
+ }
+ if(path)
+ gtk_tree_path_free(path);
}
/** @brief Initialize a @ref queuelike */
/* The selection should support multiple things being selected */
ql->selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(ql->view));
+ g_object_ref(ql->selection);
gtk_tree_selection_set_mode(ql->selection, GTK_SELECTION_MULTIPLE);
/* Catch button presses */
/* Drag+drop*/
if(ql->drop) {
- gtk_tree_view_set_reorderable(GTK_TREE_VIEW(ql->view), TRUE);
- g_signal_connect(ql->store,
- "row-inserted",
- G_CALLBACK(ql_row_inserted), ql);
- g_signal_connect(ql->store,
- "row-deleted",
- G_CALLBACK(ql_row_deleted), ql);
+ /* Originally this was:
+ *
+ * gtk_tree_view_set_reorderable(GTK_TREE_VIEW(ql->view), TRUE);
+ *
+ * However this has a two deficiencies:
+ *
+ * 1) Only one row can be dragged at once. It would be nice
+ * to be able to do bulk rearrangements since the server
+ * can cope with that well.
+ * 2) Dragging between windows is not possible. When playlist
+ * support appears, it should be possible to drag tracks
+ * from the choose tag into the playlist.
+ *
+ * At the time of writing neither of these problems are fully solved, the
+ * code as it stands is just a stepping stone in that direction.
+ */
+
+ /* This view will act as a drag source */
+ gtk_drag_source_set(ql->view,
+ GDK_BUTTON1_MASK,
+ queuelike_targets,
+ sizeof queuelike_targets / sizeof *queuelike_targets,
+ GDK_ACTION_MOVE);
+ /* This view will act as a drag destination */
+ gtk_drag_dest_set(ql->view,
+ GTK_DEST_DEFAULT_HIGHLIGHT|GTK_DEST_DEFAULT_DROP,
+ queuelike_targets,
+ sizeof queuelike_targets / sizeof *queuelike_targets,
+ GDK_ACTION_MOVE|GDK_ACTION_COPY);
+ g_signal_connect(ql->view, "drag-motion",
+ G_CALLBACK(ql_drag_motion), ql);
+ g_signal_connect(ql->view, "drag-leave",
+ G_CALLBACK(ql_drag_leave), ql);
+ g_signal_connect(ql->view, "drag-data-get",
+ 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, 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,
+ GDK_BUTTON1_MASK,
+ queuelike_targets,
+ sizeof queuelike_targets / sizeof *queuelike_targets,
+ GDK_ACTION_COPY);
+ g_signal_connect(ql->view, "drag-data-get",
+ G_CALLBACK(ql_drag_data_get), ql);
+ make_treeview_multidrag(ql->view, NULL);
}
/* TODO style? */
- ql->init();
+ if(ql->init)
+ ql->init(ql);
/* Update display text when lookups complete */
event_register("lookups-completed", queue_lookups_completed, ql);
return scrolled;
}
+/** @brief Destroy a queuelike
+ * @param ql Queuelike to destroy
+ *
+ * Returns @p ql to its initial state.
+ */
+void destroy_queuelike(struct queuelike *ql) {
+ if(ql->store) {
+ g_object_unref(ql->store);
+ ql->store = NULL;
+ }
+ if(ql->view) {
+ gtk_object_destroy(GTK_OBJECT(ql->view));
+ ql->view = NULL;
+ }
+ if(ql->menu) {
+ gtk_object_destroy(GTK_OBJECT(ql->menu));
+ ql->menu = NULL;
+ }
+ if(ql->selection) {
+ g_object_unref(ql->selection);
+ ql->selection = NULL;
+ }
+ ql->q = NULL;
+}
+
/*
Local Variables:
c-basic-offset:2
~mdw / disorder / blobdiff