/*
* 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
* it under the terms of the GNU General Public License as published by
* 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"
+
+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);
/** @brief Return the @ref queue_entry corresponding to @p iter
* @param model Model that owns @p iter
* @param iter Tree iterator
- * @return ID string
+ * @return Pointer to queue entry
*/
struct queue_entry *ql_iter_to_q(GtkTreeModel *model,
GtkTreeIter *iter) {
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);
--suppress_actions;
}
+/** @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
+ */
+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;
+ 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
+ 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);
+ }
+ }
+ return TRUE;
+}
+
+/** @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
+ */
+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);
+}
+
+/** @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
+ */
+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];
+
+ /* 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,
+ 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
+ */
+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) */
+ 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");
+ /* 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;
+ }
+ }
+ /* 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;
+ }
+}
+
/** @brief Initialize a @ref queuelike */
GtkWidget *init_queuelike(struct queuelike *ql) {
D(("init_queuelike"));
g_signal_connect(ql->view, "button-press-event",
G_CALLBACK(ql_button_release), ql);
+ /* Drag+drop*/
+ if(ql->drop) {
+ /* 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);
+ } 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);
+ }
+
/* TODO style? */
- ql->init();
+ ql->init(ql);
/* Update display text when lookups complete */
event_register("lookups-completed", queue_lookups_completed, ql);
~mdw / disorder / blobdiff