[disorder] / disobedience / queue-menu.c

/*
 * This file is part of DisOrder
 * Copyright (C) 2006-2008 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
 * 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.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
/** @file disobedience/queue-menu.c
 * @brief Disobedience queue widget popup menu
 */
#include "disobedience.h"
#include "popup.h"
#include "queue-generic.h"

/* Select All */

int ql_selectall_sensitive(void *extra) {
  struct queuelike *ql = extra;
  return !!ql->q;
}

void ql_selectall_activate(GtkMenuItem attribute((unused)) *menuitem,
                           gpointer user_data) {
  struct queuelike *ql = user_data;

  gtk_tree_selection_select_all(ql->selection);
}

/* Select None */

int ql_selectnone_sensitive(void *extra) {
  struct queuelike *ql = extra;
  return gtk_tree_selection_count_selected_rows(ql->selection) > 0;
}

void ql_selectnone_activate(GtkMenuItem attribute((unused)) *menuitem,
                            gpointer user_data) {
  struct queuelike *ql = user_data;

  gtk_tree_selection_unselect_all(ql->selection);
}

/* Properties */

int ql_properties_sensitive(void *extra) {
  struct queuelike *ql = extra;
  return gtk_tree_selection_count_selected_rows(ql->selection) > 0;
}

void ql_properties_activate(GtkMenuItem attribute((unused)) *menuitem,
                            gpointer user_data) {
  struct queuelike *ql = user_data;
  struct vector v[1];
  GtkTreeIter iter[1];

  vector_init(v);
  gtk_tree_model_get_iter_first(GTK_TREE_MODEL(ql->store), iter);
  for(struct queue_entry *q = ql->q; q; q = q->next) {
    if(gtk_tree_selection_iter_is_selected(ql->selection, iter))
      vector_append(v, (char *)q->track);
    gtk_tree_model_iter_next(GTK_TREE_MODEL(ql->store), iter);
  }
  if(v->nvec)
    properties(v->nvec, (const char **)v->vec, ql->view);
}

/* Scratch */

int ql_scratch_sensitive(void attribute((unused)) *extra) {
  return !!(last_state & DISORDER_PLAYING)
    && right_scratchable(last_rights, config->username, playing_track);
}

static void ql_scratch_completed(void attribute((unused)) *v,
                                 const char *err) {
  if(err)
    popup_protocol_error(0, err);
}

void ql_scratch_activate(GtkMenuItem attribute((unused)) *menuitem,
                         gpointer attribute((unused)) user_data) {
  disorder_eclient_scratch_playing(client, ql_scratch_completed, 0);
}

/* Remove */

static void ql_remove_sensitive_callback(GtkTreeModel *model,
                                         GtkTreePath attribute((unused)) *path,
                                         GtkTreeIter *iter,
                                         gpointer data) {
  struct queue_entry *q = ql_iter_to_q(model, iter);
  const int removable = (q != playing_track
                         && right_removable(last_rights, config->username, q));
  int *const counts = data;
  ++counts[removable];
}

int ql_remove_sensitive(void *extra) {
  struct queuelike *ql = extra;
  int counts[2] = { 0, 0 };
  gtk_tree_selection_selected_foreach(ql->selection,
                                      ql_remove_sensitive_callback,
                                      counts);
  /* Remove will work if we have at least some removable tracks selected, and
   * no unremovable ones */
  return counts[1] > 0 && counts[0] == 0;
}

static void ql_remove_completed(void attribute((unused)) *v,
                                const char *err) {
  if(err)
    popup_protocol_error(0, err);
}

static void ql_remove_activate_callback(GtkTreeModel *model,
                                        GtkTreePath attribute((unused)) *path,
                                        GtkTreeIter *iter,
                                        gpointer attribute((unused)) data) {
  struct queue_entry *q = ql_iter_to_q(model, iter);

  if(q != playing_track)
    disorder_eclient_remove(client, ql_remove_completed, q->id, q);
}

void ql_remove_activate(GtkMenuItem attribute((unused)) *menuitem,
                        gpointer user_data) {
  struct queuelike *ql = user_data;
  gtk_tree_selection_selected_foreach(ql->selection,
                                      ql_remove_activate_callback,
                                      0);
}

/* Play */

int ql_play_sensitive(void *extra) {
  struct queuelike *ql = extra;
  return (last_rights & RIGHT_PLAY)
    && gtk_tree_selection_count_selected_rows(ql->selection) > 0;
}

static void ql_play_completed(void attribute((unused)) *v, const char *err,
                              const char attribute((unused)) *id) {
  if(err)
    popup_protocol_error(0, err);
}

static void ql_play_activate_callback(GtkTreeModel *model,
                                      GtkTreePath attribute((unused)) *path,
                                      GtkTreeIter *iter,
                                      gpointer attribute((unused)) data) {
  struct queue_entry *q = ql_iter_to_q(model, iter);

  disorder_eclient_play(client, ql_play_completed, q->track, q);
}

void ql_play_activate(GtkMenuItem attribute((unused)) *menuitem,
                         gpointer user_data) {
  struct queuelike *ql = user_data;
  gtk_tree_selection_selected_foreach(ql->selection,
                                      ql_play_activate_callback,
                                      0);
}

/** @brief Called when a button is released over a queuelike */
gboolean ql_button_release(GtkWidget *widget,
                           GdkEventButton *event,
                           gpointer user_data) {
  struct queuelike *ql = user_data;

  if(event->type == GDK_BUTTON_PRESS
     && event->button == 3) {
    /* Right button click. */
    ensure_selected(GTK_TREE_VIEW(widget), event);
    popup(&ql->menu, event, ql->menuitems, ql->nmenuitems, ql);
    return TRUE;                        /* hide the click from other widgets */
  }

  return FALSE;
}

/* Adopt */

static void ql_adopt_sensitive_callback(GtkTreeModel *model,
                                        GtkTreePath attribute((unused)) *path,
                                        GtkTreeIter *iter,
                                        gpointer data) {
  struct queue_entry *const q = ql_iter_to_q(model, iter);
  int *const count = data;

  if(*count < 0)
    return;
  if(q->origin == origin_random)
    ++*count;
  else
    *count = -1;
}

/** @brief Determine whether we're pointing at an adoptable track */
int ql_adopt_sensitive(void *extra) {
  struct queuelike *ql = extra;
  int count = 0;

  /* We'll need RIGHT_PLAY */
  if(!(last_rights & RIGHT_PLAY))
    return FALSE;
  /* Check that (1) only random tracks are selected (2) at least something is
   * selected */
  gtk_tree_selection_selected_foreach(ql->selection,
                                      ql_adopt_sensitive_callback,
                                      &count);
  if(count <= 0)
    return FALSE;
  return TRUE;
}

static void ql_adopt_completed(void attribute((unused)) *v, const char *err) {
  if(err)
    popup_protocol_error(0, err);
}

static void ql_adopt_activate_callback(GtkTreeModel *model,
                                       GtkTreePath attribute((unused)) *path,
                                       GtkTreeIter *iter,
                                       gpointer attribute((unused)) data) {
  struct queue_entry *const q = ql_iter_to_q(model, iter);

  disorder_eclient_adopt(client, ql_adopt_completed, q->id, q);
}

/** @brief Called to adopt a track */
void ql_adopt_activate(GtkMenuItem attribute((unused)) *menuitem,
                       gpointer user_data) {
  struct queuelike *ql = user_data;
  gtk_tree_selection_selected_foreach(ql->selection,
                                      ql_adopt_activate_callback,
                                      NULL);
}

struct tabtype *ql_tabtype(struct queuelike *ql) {
  static const struct tabtype queuelike_tabtype = {
    ql_properties_sensitive,
    ql_selectall_sensitive,
    ql_selectnone_sensitive,
    ql_properties_activate,
    ql_selectall_activate,
    ql_selectnone_activate,
    0,
    0
  };

  ql->tabtype = queuelike_tabtype;
  ql->tabtype.extra = ql;
  return &ql->tabtype;
}

/*
Local Variables:
c-basic-offset:2
comment-column:40
fill-column:79
indent-tabs-mode:nil
End:
*/
Commit	Line	Data
c133bd3c RK	1	/*
	2	* This file is part of DisOrder
	3	* Copyright (C) 2006-2008 Richard Kettlewell
	4	*
e7eb3a27	5	* This program is free software: you can redistribute it and/or modify
c133bd3c	6	* it under the terms of the GNU General Public License as published by
e7eb3a27	7	* the Free Software Foundation, either version 3 of the License, or
c133bd3c RK	8	* (at your option) any later version.
c133bd3c RK	9	*
e7eb3a27 RK	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*
c133bd3c	15	* You should have received a copy of the GNU General Public License
e7eb3a27	16	* along with this program. If not, see <http://www.gnu.org/licenses/>.
c133bd3c	17	*/
132a5a4a RK	18	/** @file disobedience/queue-menu.c
	19	* @brief Disobedience queue widget popup menu
	20	*/
c133bd3c	21	#include "disobedience.h"
6982880f	22	#include "popup.h"
c133bd3c RK	23	#include "queue-generic.h"
	24
	25	/* Select All */
	26
6982880f RK	27	int ql_selectall_sensitive(void *extra) {
6982880f RK	28	struct queuelike *ql = extra;
c133bd3c RK	29	return !!ql->q;
	30	}
	31
	32	void ql_selectall_activate(GtkMenuItem attribute((unused)) *menuitem,
	33	gpointer user_data) {
	34	struct queuelike *ql = user_data;
	35
	36	gtk_tree_selection_select_all(ql->selection);
	37	}
	38
	39	/* Select None */
	40
6982880f RK	41	int ql_selectnone_sensitive(void *extra) {
6982880f RK	42	struct queuelike *ql = extra;
c133bd3c RK	43	return gtk_tree_selection_count_selected_rows(ql->selection) > 0;
	44	}
	45
	46	void ql_selectnone_activate(GtkMenuItem attribute((unused)) *menuitem,
	47	gpointer user_data) {
	48	struct queuelike *ql = user_data;
	49
	50	gtk_tree_selection_unselect_all(ql->selection);
	51	}
	52
	53	/* Properties */
	54
6982880f RK	55	int ql_properties_sensitive(void *extra) {
6982880f RK	56	struct queuelike *ql = extra;
c133bd3c RK	57	return gtk_tree_selection_count_selected_rows(ql->selection) > 0;
	58	}
	59
	60	void ql_properties_activate(GtkMenuItem attribute((unused)) *menuitem,
	61	gpointer user_data) {
	62	struct queuelike *ql = user_data;
	63	struct vector v[1];
	64	GtkTreeIter iter[1];
	65
	66	vector_init(v);
	67	gtk_tree_model_get_iter_first(GTK_TREE_MODEL(ql->store), iter);
	68	for(struct queue_entry *q = ql->q; q; q = q->next) {
	69	if(gtk_tree_selection_iter_is_selected(ql->selection, iter))
	70	vector_append(v, (char *)q->track);
	71	gtk_tree_model_iter_next(GTK_TREE_MODEL(ql->store), iter);
	72	}
	73	if(v->nvec)
d8b71e03	74	properties(v->nvec, (const char **)v->vec, ql->view);
c133bd3c RK	75	}
	76
	77	/* Scratch */
	78
6982880f	79	int ql_scratch_sensitive(void attribute((unused)) *extra) {
c9fb35f4 RK	80	return !!(last_state & DISORDER_PLAYING)
	81	&& right_scratchable(last_rights, config->username, playing_track);
	82	}
	83
ac56170f	84	static void ql_scratch_completed(void attribute((unused)) *v,
abf99697 RK	85	const char *err) {
	86	if(err)
	87	popup_protocol_error(0, err);
c133bd3c RK	88	}
	89
	90	void ql_scratch_activate(GtkMenuItem attribute((unused)) *menuitem,
	91	gpointer attribute((unused)) user_data) {
ac56170f	92	disorder_eclient_scratch_playing(client, ql_scratch_completed, 0);
c133bd3c RK	93	}
	94
	95	/* Remove */
	96
ac56170f RK	97	static void ql_remove_sensitive_callback(GtkTreeModel *model,
	98	GtkTreePath attribute((unused)) *path,
	99	GtkTreeIter *iter,
	100	gpointer data) {
83fb99f9	101	struct queue_entry *q = ql_iter_to_q(model, iter);
22717074 RK	102	const int removable = (q != playing_track
	103	&& right_removable(last_rights, config->username, q));
	104	int *const counts = data;
	105	++counts[removable];
	106	}
	107
6982880f RK	108	int ql_remove_sensitive(void *extra) {
6982880f RK	109	struct queuelike *ql = extra;
22717074 RK	110	int counts[2] = { 0, 0 };
22717074 RK	111	gtk_tree_selection_selected_foreach(ql->selection,
ac56170f	112	ql_remove_sensitive_callback,
22717074 RK	113	counts);
	114	/* Remove will work if we have at least some removable tracks selected, and
	115	* no unremovable ones */
	116	return counts[1] > 0 && counts[0] == 0;
	117	}
	118
ac56170f	119	static void ql_remove_completed(void attribute((unused)) *v,
abf99697 RK	120	const char *err) {
	121	if(err)
	122	popup_protocol_error(0, err);
22717074 RK	123	}
22717074 RK	124
ac56170f RK	125	static void ql_remove_activate_callback(GtkTreeModel *model,
	126	GtkTreePath attribute((unused)) *path,
	127	GtkTreeIter *iter,
	128	gpointer attribute((unused)) data) {
83fb99f9	129	struct queue_entry *q = ql_iter_to_q(model, iter);
22717074	130
c10dd9af	131	if(q != playing_track)
ad131c25	132	disorder_eclient_remove(client, ql_remove_completed, q->id, q);
c133bd3c RK	133	}
	134
	135	void ql_remove_activate(GtkMenuItem attribute((unused)) *menuitem,
22717074 RK	136	gpointer user_data) {
	137	struct queuelike *ql = user_data;
	138	gtk_tree_selection_selected_foreach(ql->selection,
ac56170f	139	ql_remove_activate_callback,
22717074	140	0);
c133bd3c RK	141	}
	142
	143	/* Play */
	144
6982880f RK	145	int ql_play_sensitive(void *extra) {
6982880f RK	146	struct queuelike *ql = extra;
ac56170f RK	147	return (last_rights & RIGHT_PLAY)
ac56170f RK	148	&& gtk_tree_selection_count_selected_rows(ql->selection) > 0;
c133bd3c RK	149	}
c133bd3c RK	150
ad131c25 RK	151	static void ql_play_completed(void attribute((unused)) v, const char err,
ad131c25 RK	152	const char attribute((unused)) *id) {
abf99697 RK	153	if(err)
abf99697 RK	154	popup_protocol_error(0, err);
c133bd3c RK	155	}
c133bd3c RK	156
ac56170f RK	157	static void ql_play_activate_callback(GtkTreeModel *model,
	158	GtkTreePath attribute((unused)) *path,
	159	GtkTreeIter *iter,
	160	gpointer attribute((unused)) data) {
83fb99f9	161	struct queue_entry *q = ql_iter_to_q(model, iter);
ac56170f	162
ad131c25	163	disorder_eclient_play(client, ql_play_completed, q->track, q);
ac56170f RK	164	}
	165
	166	void ql_play_activate(GtkMenuItem attribute((unused)) *menuitem,
	167	gpointer user_data) {
	168	struct queuelike *ql = user_data;
	169	gtk_tree_selection_selected_foreach(ql->selection,
	170	ql_play_activate_callback,
	171	0);
	172	}
c133bd3c	173
c133bd3c	174	/** @brief Called when a button is released over a queuelike */
6982880f	175	gboolean ql_button_release(GtkWidget *widget,
c133bd3c RK	176	GdkEventButton *event,
	177	gpointer user_data) {
	178	struct queuelike *ql = user_data;
	179
	180	if(event->type == GDK_BUTTON_PRESS
	181	&& event->button == 3) {
be909398	182	/* Right button click. */
6982880f RK	183	ensure_selected(GTK_TREE_VIEW(widget), event);
6982880f RK	184	popup(&ql->menu, event, ql->menuitems, ql->nmenuitems, ql);
c133bd3c RK	185	return TRUE; /* hide the click from other widgets */
	186	}
	187
	188	return FALSE;
	189	}
	190
a49c2c0f RK	191	/* Adopt */
	192
	193	static void ql_adopt_sensitive_callback(GtkTreeModel *model,
	194	GtkTreePath attribute((unused)) *path,
	195	GtkTreeIter *iter,
	196	gpointer data) {
	197	struct queue_entry *const q = ql_iter_to_q(model, iter);
	198	int *const count = data;
	199
	200	if(*count < 0)
	201	return;
	202	if(q->origin == origin_random)
	203	++*count;
	204	else
	205	*count = -1;
	206	}
	207
	208	/** @brief Determine whether we're pointing at an adoptable track */
	209	int ql_adopt_sensitive(void *extra) {
	210	struct queuelike *ql = extra;
	211	int count = 0;
	212
	213	/* We'll need RIGHT_PLAY */
	214	if(!(last_rights & RIGHT_PLAY))
	215	return FALSE;
	216	/* Check that (1) only random tracks are selected (2) at least something is
	217	* selected */
	218	gtk_tree_selection_selected_foreach(ql->selection,
	219	ql_adopt_sensitive_callback,
	220	&count);
	221	if(count <= 0)
	222	return FALSE;
	223	return TRUE;
	224	}
	225
	226	static void ql_adopt_completed(void attribute((unused)) v, const char err) {
	227	if(err)
	228	popup_protocol_error(0, err);
	229	}
	230
	231	static void ql_adopt_activate_callback(GtkTreeModel *model,
	232	GtkTreePath attribute((unused)) *path,
	233	GtkTreeIter *iter,
	234	gpointer attribute((unused)) data) {
	235	struct queue_entry *const q = ql_iter_to_q(model, iter);
	236
	237	disorder_eclient_adopt(client, ql_adopt_completed, q->id, q);
	238	}
	239
	240	/** @brief Called to adopt a track */
	241	void ql_adopt_activate(GtkMenuItem attribute((unused)) *menuitem,
	242	gpointer user_data) {
	243	struct queuelike *ql = user_data;
	244	gtk_tree_selection_selected_foreach(ql->selection,
	245	ql_adopt_activate_callback,
	246	NULL);
	247	}
	248
ee7552f8	249	struct tabtype ql_tabtype(struct queuelike ql) {
abf99697	250	static const struct tabtype queuelike_tabtype = {
6982880f RK	251	ql_properties_sensitive,
	252	ql_selectall_sensitive,
	253	ql_selectnone_sensitive,
	254	ql_properties_activate,
	255	ql_selectall_activate,
	256	ql_selectnone_activate,
ee7552f8 RK	257	0,
	258	0
	259	};
	260
abf99697	261	ql->tabtype = queuelike_tabtype;
54156c62 RK	262	ql->tabtype.extra = ql;
54156c62 RK	263	return &ql->tabtype;
ee7552f8 RK	264	}
ee7552f8 RK	265
c133bd3c RK	266	/*
	267	Local Variables:
	268	c-basic-offset:2
	269	comment-column:40
	270	fill-column:79
	271	indent-tabs-mode:nil
	272	End:
	273	*/