chiark / gitweb /
Add kvp_make(), to make a kvp list in a single function call.
[disorder] / disobedience / control.c
CommitLineData
460b9539 1/*
2 * This file is part of DisOrder.
eb525fcd 3 * Copyright (C) 2006, 2007 Richard Kettlewell
460b9539 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 */
219dc95c
RK
20/** @file disobedience/control.c
21 * @brief Volume control and buttons
22 */
460b9539 23
24#include "disobedience.h"
321f7536 25#include "mixer.h"
460b9539 26
e9b70a84 27/* Forward declarations ---------------------------------------------------- */
28
29WT(adjustment);
30WT(hscale);
31WT(hbox);
e9b70a84 32WT(button);
33WT(image);
34WT(label);
35WT(vbox);
460b9539 36
37struct icon;
38
39static void update_pause(const struct icon *);
40static void update_play(const struct icon *);
41static void update_scratch(const struct icon *);
42static void update_random_enable(const struct icon *);
43static void update_random_disable(const struct icon *);
44static void update_enable(const struct icon *);
45static void update_disable(const struct icon *);
a99c4e9a
RK
46static void update_rtp(const struct icon *);
47static void update_nortp(const struct icon *);
460b9539 48static void clicked_icon(GtkButton *, gpointer);
ac6bf2ba 49static void clicked_menu(GtkMenuItem *, gpointer userdata);
2d504956 50static void toggled_menu(GtkCheckMenuItem *, gpointer userdata);
460b9539 51
a99c4e9a
RK
52static int enable_rtp(disorder_eclient *c,
53 disorder_eclient_no_response *completed,
54 void *v);
55static int disable_rtp(disorder_eclient *c,
56 disorder_eclient_no_response *completed,
57 void *v);
58
460b9539 59static double left(double v, double b);
60static double right(double v, double b);
61static double volume(double l, double r);
62static double balance(double l, double r);
63
64static void volume_adjusted(GtkAdjustment *a, gpointer user_data);
65static gchar *format_volume(GtkScale *scale, gdouble value);
66static gchar *format_balance(GtkScale *scale, gdouble value);
67
68/* Control bar ------------------------------------------------------------- */
69
fb44b59e
RK
70/** @brief Guard against feedback */
71int suppress_actions = 1;
460b9539 72
219dc95c
RK
73/** @brief Definition of an icon
74 *
75 * The design here is rather mad: rather than changing the image displayed by
76 * icons according to their state, we flip the visibility of pairs of icons.
77 */
78struct icon {
79 /** @brief Filename for image */
460b9539 80 const char *icon;
219dc95c
RK
81
82 /** @brief Text for tooltip */
460b9539 83 const char *tip;
219dc95c 84
ac6bf2ba
RK
85 /** @brief Associated menu item or NULL */
86 const char *menuitem;
219dc95c
RK
87
88 /** @brief Called to update button when state may have changed */
460b9539 89 void (*update)(const struct icon *i);
219dc95c
RK
90
91 /** @brief @ref eclient.h function to call */
460b9539 92 int (*action)(disorder_eclient *c,
93 disorder_eclient_no_response *completed,
94 void *v);
219dc95c 95
2d504956
RK
96 /** @brief Flag */
97 unsigned flags;
98
219dc95c 99 /** @brief Pointer to button */
460b9539 100 GtkWidget *button;
ac6bf2ba
RK
101
102 /** @brief Pointer to menu item */
103 GtkWidget *item;
219dc95c
RK
104};
105
2d504956
RK
106/** @brief This is the active half of a pair */
107#define ICON_ACTIVE 0x0001
108
109/** @brief This is the inactive half of a pair */
110#define ICON_INACTIVE 0x0002
111
219dc95c
RK
112/** @brief Table of all icons */
113static struct icon icons[] = {
2d504956
RK
114 {
115 "pause.png", /* icon */
116 "Pause playing track", /* tip */
685bdfbd 117 "<GdisorderMain>/Control/Playing", /* menuitem */
2d504956
RK
118 update_pause, /* update */
119 disorder_eclient_pause, /* action */
685bdfbd 120 ICON_ACTIVE, /* flags */
2d504956
RK
121 0, /* button */
122 0 /* item */
123 },
124 {
125 "play.png", /* icon */
126 "Resume playing track", /* tip */
685bdfbd 127 "<GdisorderMain>/Control/Playing", /* menuitem */
2d504956
RK
128 update_play, /* update */
129 disorder_eclient_resume, /* action */
685bdfbd 130 ICON_INACTIVE, /* flags */
2d504956
RK
131 0, /* button */
132 0 /* item */
133 },
134 {
135 "cross.png", /* icon */
136 "Cancel playing track", /* tip */
137 "<GdisorderMain>/Control/Scratch", /* menuitem */
138 update_scratch, /* update */
139 disorder_eclient_scratch_playing, /* action */
140 0, /* flags */
141 0, /* button */
142 0 /* item */
143 },
144 {
145 "random.png", /* icon */
146 "Enable random play", /* tip */
147 "<GdisorderMain>/Control/Random play", /* menuitem */
148 update_random_enable, /* update */
149 disorder_eclient_random_enable, /* action */
150 ICON_INACTIVE, /* flags */
151 0, /* button */
152 0 /* item */
153 },
154 {
155 "randomcross.png", /* icon */
156 "Disable random play", /* tip */
157 "<GdisorderMain>/Control/Random play", /* menuitem */
158 update_random_disable, /* update */
159 disorder_eclient_random_disable, /* action */
160 ICON_ACTIVE, /* flags */
161 0, /* button */
162 0 /* item */
163 },
164 {
165 "notes.png", /* icon */
166 "Enable play", /* tip */
167 0, /* menuitem */
168 update_enable, /* update */
169 disorder_eclient_enable, /* action */
170 ICON_INACTIVE, /* flags */
171 0, /* button */
172 0 /* item */
173 },
174 {
175 "notescross.png", /* icon */
176 "Disable play", /* tip */
177 0, /* menuitem */
178 update_disable, /* update */
179 disorder_eclient_disable, /* action */
180 ICON_ACTIVE, /* flags */
181 0, /* button */
182 0 /* item */
183 },
184 {
185 "speaker.png", /* icon */
186 "Play network stream", /* tip */
685bdfbd 187 "<GdisorderMain>/Control/Network player", /* menuitem */
2d504956
RK
188 update_rtp, /* update */
189 enable_rtp, /* action */
190 ICON_INACTIVE, /* flags */
191 0, /* button */
192 0 /* item */
193 },
194 {
195 "speakercross.png", /* icon */
196 "Stop playing network stream", /* tip */
685bdfbd 197 "<GdisorderMain>/Control/Network player", /* menuitem */
2d504956
RK
198 update_nortp, /* update */
199 disable_rtp, /* action */
200 ICON_ACTIVE, /* flags */
201 0, /* button */
202 0 /* item */
203 },
460b9539 204};
219dc95c
RK
205
206/** @brief Count of icons */
460b9539 207#define NICONS (int)(sizeof icons / sizeof *icons)
208
219dc95c
RK
209static GtkAdjustment *volume_adj;
210static GtkAdjustment *balance_adj;
3c499fe7
RK
211static GtkWidget *volume_widget;
212static GtkWidget *balance_widget;
460b9539 213
6d1302f0 214/** @brief Called whenever last_state changes in any way */
a99c4e9a 215void control_monitor(void attribute((unused)) *u) {
6d1302f0 216 int n;
3c499fe7 217 gboolean volume_supported;
6d1302f0
RK
218
219 D(("control_monitor"));
220 for(n = 0; n < NICONS; ++n)
221 icons[n].update(&icons[n]);
3c499fe7
RK
222 /* Only display volume/balance controls if they will work */
223 if(!rtp_supported
224 || (rtp_supported && mixer_supported(DEFAULT_BACKEND)))
225 volume_supported = TRUE;
226 else
227 volume_supported = FALSE;
228 (volume_supported ? gtk_widget_show : gtk_widget_hide)(volume_widget);
229 (volume_supported ? gtk_widget_show : gtk_widget_hide)(balance_widget);
6d1302f0
RK
230}
231
219dc95c 232/** @brief Create the control bar */
e9b70a84 233GtkWidget *control_widget(void) {
460b9539 234 GtkWidget *hbox = gtk_hbox_new(FALSE, 1), *vbox;
460b9539 235 int n;
236
e9b70a84 237 NW(hbox);
460b9539 238 D(("control_widget"));
ac6bf2ba 239 assert(mainmenufactory); /* ordering must be right */
460b9539 240 for(n = 0; n < NICONS; ++n) {
e9b70a84 241 NW(button);
33288048 242 icons[n].button = iconbutton(icons[n].icon, icons[n].tip);
460b9539 243 g_signal_connect(G_OBJECT(icons[n].button), "clicked",
ac6bf2ba 244 G_CALLBACK(clicked_icon), &icons[n]);
460b9539 245 /* pop the icon in a vbox so it doesn't get vertically stretch if there are
246 * taller things in the control bar */
e9b70a84 247 NW(vbox);
460b9539 248 vbox = gtk_vbox_new(FALSE, 0);
249 gtk_box_pack_start(GTK_BOX(vbox), icons[n].button, TRUE, FALSE, 0);
250 gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 0);
ac6bf2ba
RK
251 if(icons[n].menuitem) {
252 icons[n].item = gtk_item_factory_get_widget(mainmenufactory,
253 icons[n].menuitem);
2d504956
RK
254 switch(icons[n].flags & (ICON_ACTIVE|ICON_INACTIVE)) {
255 case ICON_ACTIVE:
256 g_signal_connect(G_OBJECT(icons[n].item), "toggled",
257 G_CALLBACK(toggled_menu), &icons[n]);
258 break;
259 case ICON_INACTIVE:
260 /* Don't connect two instances of the signal! */
261 break;
262 default:
263 g_signal_connect(G_OBJECT(icons[n].item), "activate",
264 G_CALLBACK(clicked_menu), &icons[n]);
265 break;
266 }
ac6bf2ba 267 }
460b9539 268 }
269 /* create the adjustments for the volume control */
e9b70a84 270 NW(adjustment);
460b9539 271 volume_adj = GTK_ADJUSTMENT(gtk_adjustment_new(0, 0, goesupto,
272 goesupto / 20, goesupto / 20,
273 0));
e9b70a84 274 NW(adjustment);
460b9539 275 balance_adj = GTK_ADJUSTMENT(gtk_adjustment_new(0, -1, 1,
276 0.2, 0.2, 0));
277 /* the volume control */
e9b70a84 278 NW(hscale);
3c499fe7 279 volume_widget = gtk_hscale_new(volume_adj);
e9b70a84 280 NW(hscale);
3c499fe7
RK
281 balance_widget = gtk_hscale_new(balance_adj);
282 gtk_widget_set_style(volume_widget, tool_style);
283 gtk_widget_set_style(balance_widget, tool_style);
284 gtk_scale_set_digits(GTK_SCALE(volume_widget), 10);
285 gtk_scale_set_digits(GTK_SCALE(balance_widget), 10);
286 gtk_widget_set_size_request(volume_widget, 192, -1);
287 gtk_widget_set_size_request(balance_widget, 192, -1);
288 gtk_tooltips_set_tip(tips, volume_widget, "Volume", "");
289 gtk_tooltips_set_tip(tips, balance_widget, "Balance", "");
290 gtk_box_pack_start(GTK_BOX(hbox), volume_widget, FALSE, TRUE, 0);
291 gtk_box_pack_start(GTK_BOX(hbox), balance_widget, FALSE, TRUE, 0);
460b9539 292 /* space updates rather than hammering the server */
3c499fe7
RK
293 gtk_range_set_update_policy(GTK_RANGE(volume_widget), GTK_UPDATE_DELAYED);
294 gtk_range_set_update_policy(GTK_RANGE(balance_widget), GTK_UPDATE_DELAYED);
460b9539 295 /* notice when the adjustments are changed */
296 g_signal_connect(G_OBJECT(volume_adj), "value-changed",
297 G_CALLBACK(volume_adjusted), 0);
298 g_signal_connect(G_OBJECT(balance_adj), "value-changed",
299 G_CALLBACK(volume_adjusted), 0);
300 /* format the volume/balance values ourselves */
3c499fe7 301 g_signal_connect(G_OBJECT(volume_widget), "format-value",
460b9539 302 G_CALLBACK(format_volume), 0);
3c499fe7 303 g_signal_connect(G_OBJECT(balance_widget), "format-value",
460b9539 304 G_CALLBACK(format_balance), 0);
00959300 305 register_monitor(control_monitor, 0, -1UL);
460b9539 306 return hbox;
307}
308
6d1302f0
RK
309/** @brief Update the volume control when it changes */
310void volume_update(void) {
460b9539 311 double l, r;
312
6d1302f0 313 D(("volume_update"));
460b9539 314 l = volume_l / 100.0;
315 r = volume_r / 100.0;
fb44b59e 316 ++suppress_actions;
460b9539 317 gtk_adjustment_set_value(volume_adj, volume(l, r) * goesupto);
318 gtk_adjustment_set_value(balance_adj, balance(l, r));
fb44b59e 319 --suppress_actions;
460b9539 320}
321
ad58ebcc 322/** @brief Update the state of one of the control icons
00959300 323 * @param icon Target icon
ad58ebcc 324 * @param visible True if this version of the button should be visible
325 * @param usable True if the button is currently usable
326 *
327 * Several of the icons, rather bizarrely, come in pairs: for instance exactly
328 * one of the play and pause buttons is supposed to be visible at any given
329 * moment.
330 *
331 * @p usable need not take into account server availability, that is done
332 * automatically.
333 */
00959300 334static void update_icon(const struct icon *icon,
ad58ebcc 335 int visible, int usable) {
336 /* If the connection is down nothing is ever usable */
00959300 337 if(!(last_state & DISORDER_CONNECTED))
ad58ebcc 338 usable = 0;
00959300 339 (visible ? gtk_widget_show : gtk_widget_hide)(icon->button);
ad58ebcc 340 /* Only both updating usability if the button is visible */
341 if(visible)
00959300 342 gtk_widget_set_sensitive(icon->button, usable);
ac6bf2ba 343 if(icon->item) {
2d504956
RK
344 /* There's an associated menu item. These are always visible, but may not
345 * be usable. */
346 if((icon->flags & (ICON_ACTIVE|ICON_INACTIVE)) == ICON_ACTIVE) {
347 /* The active half of a pair */
348 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(icon->item), visible);
349 }
350 gtk_widget_set_sensitive(icon->item, usable);
ac6bf2ba 351 }
460b9539 352}
353
354static void update_pause(const struct icon *icon) {
00959300
RK
355 const int visible = !(last_state & DISORDER_TRACK_PAUSED);
356 const int usable = !!(last_state & DISORDER_PLAYING); /* TODO: might be a lie */
357 update_icon(icon, visible, usable);
460b9539 358}
359
360static void update_play(const struct icon *icon) {
00959300
RK
361 const int visible = !!(last_state & DISORDER_TRACK_PAUSED);
362 const int usable = !!(last_state & DISORDER_PLAYING);
363 update_icon(icon, visible, usable);
460b9539 364}
365
366static void update_scratch(const struct icon *icon) {
00959300
RK
367 const int visible = 1;
368 const int usable = !!(last_state & DISORDER_PLAYING);
369 update_icon(icon, visible, usable);
460b9539 370}
371
372static void update_random_enable(const struct icon *icon) {
00959300
RK
373 const int visible = !(last_state & DISORDER_RANDOM_ENABLED);
374 const int usable = 1;
375 update_icon(icon, visible, usable);
460b9539 376}
377
378static void update_random_disable(const struct icon *icon) {
00959300
RK
379 const int visible = !!(last_state & DISORDER_RANDOM_ENABLED);
380 const int usable = 1;
381 update_icon(icon, visible, usable);
460b9539 382}
383
384static void update_enable(const struct icon *icon) {
00959300
RK
385 const int visible = !(last_state & DISORDER_PLAYING_ENABLED);
386 const int usable = 1;
387 update_icon(icon, visible, usable);
460b9539 388}
389
390static void update_disable(const struct icon *icon) {
00959300
RK
391 const int visible = !!(last_state & DISORDER_PLAYING_ENABLED);
392 const int usable = 1;
393 update_icon(icon, visible, usable);
460b9539 394}
395
a99c4e9a
RK
396static void update_rtp(const struct icon *icon) {
397 const int visible = !rtp_is_running;
398 const int usable = rtp_supported;
399 update_icon(icon, visible, usable);
400}
401
402static void update_nortp(const struct icon *icon) {
403 const int visible = rtp_is_running;
404 const int usable = rtp_supported;
405 update_icon(icon, visible, usable);
406}
407
460b9539 408static void clicked_icon(GtkButton attribute((unused)) *button,
409 gpointer userdata) {
410 const struct icon *icon = userdata;
411
fb44b59e
RK
412 if(!suppress_actions)
413 icon->action(client, 0, 0);
460b9539 414}
415
ac6bf2ba
RK
416static void clicked_menu(GtkMenuItem attribute((unused)) *menuitem,
417 gpointer userdata) {
418 const struct icon *icon = userdata;
419
fb44b59e
RK
420 if(!suppress_actions)
421 icon->action(client, 0, 0);
ac6bf2ba
RK
422}
423
2d504956
RK
424static void toggled_menu(GtkCheckMenuItem *menuitem,
425 gpointer userdata) {
426 const struct icon *icon = userdata;
427 size_t n;
428
fb44b59e
RK
429 if(suppress_actions)
430 return;
2d504956
RK
431 /* This is a bit fiddlier than the others, we need to find the action for the
432 * new state. If the new state is active then we want the ICON_INACTIVE
433 * version and vica versa. */
434 for(n = 0; n < NICONS; ++n)
435 if(icons[n].item == icon->item
436 && !!(icons[n].flags & ICON_INACTIVE) == !!menuitem->active)
437 break;
438 if(n < NICONS)
439 icons[n].action(client, 0, 0);
440}
441
219dc95c 442/** @brief Called when the volume has been adjusted */
460b9539 443static void volume_adjusted(GtkAdjustment attribute((unused)) *a,
444 gpointer attribute((unused)) user_data) {
445 double v = gtk_adjustment_get_value(volume_adj) / goesupto;
446 double b = gtk_adjustment_get_value(balance_adj);
447
fb44b59e 448 if(suppress_actions)
460b9539 449 /* This is the result of an update from the server, not a change from the
450 * user. Don't feedback! */
451 return;
452 D(("volume_adjusted"));
453 /* force to 'stereotypical' values */
454 v = nearbyint(100 * v) / 100;
455 b = nearbyint(5 * b) / 5;
456 /* Set the volume. We don't want a reply, we'll get the actual new volume
457 * from the log. */
321f7536
RK
458 if(rtp_supported) {
459 int l = nearbyint(left(v, b) * 100), r = nearbyint(right(v, b) * 100);
3c499fe7 460 mixer_control(DEFAULT_BACKEND, &l, &r, 1);
321f7536
RK
461 } else
462 /* We don't want a reply, we'll get the actual new volume from the log. */
463 disorder_eclient_volume(client, 0,
464 nearbyint(left(v, b) * 100),
465 nearbyint(right(v, b) * 100),
466 0);
460b9539 467}
468
219dc95c 469/** @brief Formats the volume value */
460b9539 470static gchar *format_volume(GtkScale attribute((unused)) *scale,
471 gdouble value) {
472 char s[32];
473
474 snprintf(s, sizeof s, "%.1f", (double)value);
2fc4475d 475 return g_strdup(s);
460b9539 476}
477
219dc95c 478/** @brief Formats the balance value */
460b9539 479static gchar *format_balance(GtkScale attribute((unused)) *scale,
480 gdouble value) {
481 char s[32];
482
483 if(fabs(value) < 0.1)
2fc4475d 484 return g_strdup("0");
460b9539 485 snprintf(s, sizeof s, "%+.1f", (double)value);
2fc4475d 486 return g_strdup(s);
460b9539 487}
488
489/* Volume mapping. We consider left, right, volume to be in [0,1]
490 * and balance to be in [-1,1].
491 *
492 * First, we just have volume = max(left, right).
493 *
494 * Balance we consider to linearly represent the amount by which the quieter
495 * channel differs from the louder. In detail:
496 *
497 * if right > left then balance > 0:
498 * balance = 0 => left = right (as an endpoint, not an instance)
499 * balance = 1 => left = 0
500 * fitting to linear, left = right * (1 - balance)
501 * so balance = 1 - left / right
502 * (right > left => right > 0 so no division by 0.)
503 *
504 * if left > right then balance < 0:
505 * balance = 0 => right = left (same caveat as above)
506 * balance = -1 => right = 0
507 * again fitting to linear, right = left * (1 + balance)
508 * so balance = right / left - 1
509 * (left > right => left > 0 so no division by 0.)
510 *
511 * if left = right then we just have balance = 0.
512 *
513 * Thanks to Clive and Andrew.
514 */
515
219dc95c 516/** @brief Return the greater of @p x and @p y */
460b9539 517static double max(double x, double y) {
518 return x > y ? x : y;
519}
520
219dc95c 521/** @brief Compute the left channel volume */
460b9539 522static double left(double v, double b) {
523 if(b > 0) /* volume = right */
524 return v * (1 - b);
525 else /* volume = left */
526 return v;
527}
528
219dc95c 529/** @brief Compute the right channel volume */
460b9539 530static double right(double v, double b) {
531 if(b > 0) /* volume = right */
532 return v;
533 else /* volume = left */
534 return v * (1 + b);
535}
536
219dc95c 537/** @brief Compute the overall volume */
460b9539 538static double volume(double l, double r) {
539 return max(l, r);
540}
541
219dc95c 542/** @brief Compute the balance */
460b9539 543static double balance(double l, double r) {
544 if(l > r)
545 return r / l - 1;
546 else if(r > l)
547 return 1 - l / r;
548 else /* left = right */
549 return 0;
550}
551
a99c4e9a
RK
552/** @brief Called to enable RTP play
553 *
554 * Rather odd signature is to fit in with the other icons which all call @ref
555 * lib/eclient.h functions.
556 */
557static int enable_rtp(disorder_eclient attribute((unused)) *c,
558 disorder_eclient_no_response attribute((unused)) *completed,
559 void attribute((unused)) *v) {
560 start_rtp();
561 return 0;
562}
563
564/** @brief Called to disable RTP play
565 *
566 * Rather odd signature is to fit in with the other icons which all call @ref
567 * lib/eclient.h functions.
568 */
569static int disable_rtp(disorder_eclient attribute((unused)) *c,
570 disorder_eclient_no_response attribute((unused)) *completed,
571 void attribute((unused)) *v) {
572 stop_rtp();
573 return 0;
574}
575
460b9539 576/*
577Local Variables:
578c-basic-offset:2
579comment-column:40
580fill-column:79
581indent-tabs-mode:nil
582End:
583*/