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