2 * This file is part of DisOrder.
3 * Copyright (C) 2006, 2007 Richard Kettlewell
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.
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.
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
20 /** @file disobedience/control.c
21 * @brief Volume control and buttons
24 #include "disobedience.h"
27 /* Forward declarations ---------------------------------------------------- */
39 static void update_pause(const struct icon *);
40 static void update_play(const struct icon *);
41 static void update_scratch(const struct icon *);
42 static void update_random_enable(const struct icon *);
43 static void update_random_disable(const struct icon *);
44 static void update_enable(const struct icon *);
45 static void update_disable(const struct icon *);
46 static void update_rtp(const struct icon *);
47 static void update_nortp(const struct icon *);
48 static void clicked_icon(GtkButton *, gpointer);
49 static void clicked_menu(GtkMenuItem *, gpointer userdata);
50 static void toggled_menu(GtkCheckMenuItem *, gpointer userdata);
52 static int enable_rtp(disorder_eclient *c,
53 disorder_eclient_no_response *completed,
55 static int disable_rtp(disorder_eclient *c,
56 disorder_eclient_no_response *completed,
59 static double left(double v, double b);
60 static double right(double v, double b);
61 static double volume(double l, double r);
62 static double balance(double l, double r);
64 static void volume_adjusted(GtkAdjustment *a, gpointer user_data);
65 static gchar *format_volume(GtkScale *scale, gdouble value);
66 static gchar *format_balance(GtkScale *scale, gdouble value);
68 /* Control bar ------------------------------------------------------------- */
70 /** @brief Guard against feedback */
71 int suppress_actions = 1;
73 /** @brief Definition of an icon
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.
79 /** @brief Filename for image */
82 /** @brief Text for tooltip */
85 /** @brief Associated menu item or NULL */
88 /** @brief Called to update button when state may have changed */
89 void (*update)(const struct icon *i);
91 /** @brief @ref eclient.h function to call */
92 int (*action)(disorder_eclient *c,
93 disorder_eclient_no_response *completed,
99 /** @brief Pointer to button */
102 /** @brief Pointer to menu item */
106 /** @brief This is the active half of a pair */
107 #define ICON_ACTIVE 0x0001
109 /** @brief This is the inactive half of a pair */
110 #define ICON_INACTIVE 0x0002
112 /** @brief Table of all icons */
113 static struct icon icons[] = {
115 "pause.png", /* icon */
116 "Pause playing track", /* tip */
117 "<GdisorderMain>/Control/Playing", /* menuitem */
118 update_pause, /* update */
119 disorder_eclient_pause, /* action */
120 ICON_ACTIVE, /* flags */
125 "play.png", /* icon */
126 "Resume playing track", /* tip */
127 "<GdisorderMain>/Control/Playing", /* menuitem */
128 update_play, /* update */
129 disorder_eclient_resume, /* action */
130 ICON_INACTIVE, /* flags */
135 "cross.png", /* icon */
136 "Cancel playing track", /* tip */
137 "<GdisorderMain>/Control/Scratch", /* menuitem */
138 update_scratch, /* update */
139 disorder_eclient_scratch_playing, /* action */
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 */
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 */
165 "notes.png", /* icon */
166 "Enable play", /* tip */
168 update_enable, /* update */
169 disorder_eclient_enable, /* action */
170 ICON_INACTIVE, /* flags */
175 "notescross.png", /* icon */
176 "Disable play", /* tip */
178 update_disable, /* update */
179 disorder_eclient_disable, /* action */
180 ICON_ACTIVE, /* flags */
185 "speaker.png", /* icon */
186 "Play network stream", /* tip */
187 "<GdisorderMain>/Control/Network player", /* menuitem */
188 update_rtp, /* update */
189 enable_rtp, /* action */
190 ICON_INACTIVE, /* flags */
195 "speakercross.png", /* icon */
196 "Stop playing network stream", /* tip */
197 "<GdisorderMain>/Control/Network player", /* menuitem */
198 update_nortp, /* update */
199 disable_rtp, /* action */
200 ICON_ACTIVE, /* flags */
206 /** @brief Count of icons */
207 #define NICONS (int)(sizeof icons / sizeof *icons)
209 static GtkAdjustment *volume_adj;
210 static GtkAdjustment *balance_adj;
211 static GtkWidget *volume_widget;
212 static GtkWidget *balance_widget;
214 /** @brief Called whenever last_state changes in any way */
215 void control_monitor(void attribute((unused)) *u) {
217 gboolean volume_supported;
219 D(("control_monitor"));
220 for(n = 0; n < NICONS; ++n)
221 icons[n].update(&icons[n]);
222 /* Only display volume/balance controls if they will work */
224 || (rtp_supported && mixer_supported(DEFAULT_BACKEND)))
225 volume_supported = TRUE;
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);
232 /** @brief Create the control bar */
233 GtkWidget *control_widget(void) {
234 GtkWidget *hbox = gtk_hbox_new(FALSE, 1), *vbox;
238 D(("control_widget"));
239 assert(mainmenufactory); /* ordering must be right */
240 for(n = 0; n < NICONS; ++n) {
242 icons[n].button = iconbutton(icons[n].icon, icons[n].tip);
243 g_signal_connect(G_OBJECT(icons[n].button), "clicked",
244 G_CALLBACK(clicked_icon), &icons[n]);
245 /* pop the icon in a vbox so it doesn't get vertically stretch if there are
246 * taller things in the control bar */
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);
251 if(icons[n].menuitem) {
252 icons[n].item = gtk_item_factory_get_widget(mainmenufactory,
254 switch(icons[n].flags & (ICON_ACTIVE|ICON_INACTIVE)) {
256 g_signal_connect(G_OBJECT(icons[n].item), "toggled",
257 G_CALLBACK(toggled_menu), &icons[n]);
260 /* Don't connect two instances of the signal! */
263 g_signal_connect(G_OBJECT(icons[n].item), "activate",
264 G_CALLBACK(clicked_menu), &icons[n]);
269 /* create the adjustments for the volume control */
271 volume_adj = GTK_ADJUSTMENT(gtk_adjustment_new(0, 0, goesupto,
272 goesupto / 20, goesupto / 20,
275 balance_adj = GTK_ADJUSTMENT(gtk_adjustment_new(0, -1, 1,
277 /* the volume control */
279 volume_widget = gtk_hscale_new(volume_adj);
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);
292 /* space updates rather than hammering the server */
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);
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 */
301 g_signal_connect(G_OBJECT(volume_widget), "format-value",
302 G_CALLBACK(format_volume), 0);
303 g_signal_connect(G_OBJECT(balance_widget), "format-value",
304 G_CALLBACK(format_balance), 0);
305 register_monitor(control_monitor, 0, -1UL);
309 /** @brief Update the volume control when it changes */
310 void volume_update(void) {
313 D(("volume_update"));
314 l = volume_l / 100.0;
315 r = volume_r / 100.0;
317 gtk_adjustment_set_value(volume_adj, volume(l, r) * goesupto);
318 gtk_adjustment_set_value(balance_adj, balance(l, r));
322 /** @brief Update the state of one of the control icons
323 * @param icon Target icon
324 * @param visible True if this version of the button should be visible
325 * @param usable True if the button is currently usable
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
331 * @p usable need not take into account server availability, that is done
334 static void update_icon(const struct icon *icon,
335 int visible, int usable) {
336 /* If the connection is down nothing is ever usable */
337 if(!(last_state & DISORDER_CONNECTED))
339 (visible ? gtk_widget_show : gtk_widget_hide)(icon->button);
340 /* Only both updating usability if the button is visible */
342 gtk_widget_set_sensitive(icon->button, usable);
344 /* There's an associated menu item. These are always visible, but may not
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);
350 gtk_widget_set_sensitive(icon->item, usable);
354 static void update_pause(const struct icon *icon) {
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);
360 static void update_play(const struct icon *icon) {
361 const int visible = !!(last_state & DISORDER_TRACK_PAUSED);
362 const int usable = !!(last_state & DISORDER_PLAYING);
363 update_icon(icon, visible, usable);
366 static void update_scratch(const struct icon *icon) {
367 const int visible = 1;
368 const int usable = !!(last_state & DISORDER_PLAYING);
369 update_icon(icon, visible, usable);
372 static void update_random_enable(const struct icon *icon) {
373 const int visible = !(last_state & DISORDER_RANDOM_ENABLED);
374 const int usable = 1;
375 update_icon(icon, visible, usable);
378 static void update_random_disable(const struct icon *icon) {
379 const int visible = !!(last_state & DISORDER_RANDOM_ENABLED);
380 const int usable = 1;
381 update_icon(icon, visible, usable);
384 static void update_enable(const struct icon *icon) {
385 const int visible = !(last_state & DISORDER_PLAYING_ENABLED);
386 const int usable = 1;
387 update_icon(icon, visible, usable);
390 static void update_disable(const struct icon *icon) {
391 const int visible = !!(last_state & DISORDER_PLAYING_ENABLED);
392 const int usable = 1;
393 update_icon(icon, visible, usable);
396 static 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);
402 static 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);
408 static void icon_action_completed(void attribute((unused)) *v,
411 popup_protocol_error(0, error);
414 static void clicked_icon(GtkButton attribute((unused)) *button,
416 const struct icon *icon = userdata;
418 if(!suppress_actions)
419 icon->action(client, icon_action_completed, 0);
422 static void clicked_menu(GtkMenuItem attribute((unused)) *menuitem,
424 const struct icon *icon = userdata;
426 if(!suppress_actions)
427 icon->action(client, icon_action_completed, 0);
430 static void toggled_menu(GtkCheckMenuItem *menuitem,
432 const struct icon *icon = userdata;
437 /* This is a bit fiddlier than the others, we need to find the action for the
438 * new state. If the new state is active then we want the ICON_INACTIVE
439 * version and vica versa. */
440 for(n = 0; n < NICONS; ++n)
441 if(icons[n].item == icon->item
442 && !!(icons[n].flags & ICON_INACTIVE) == !!menuitem->active)
445 icons[n].action(client, icon_action_completed, 0);
448 /** @brief Called when a volume command completes */
449 static void volume_completed(void attribute((unused)) *v,
451 int attribute((unused)) l,
452 int attribute((unused)) r) {
454 popup_protocol_error(0, error);
455 /* We don't set the UI's notion of the volume here, it is set from the log
456 * regardless of the reason it changed */
459 /** @brief Called when the volume has been adjusted */
460 static void volume_adjusted(GtkAdjustment attribute((unused)) *a,
461 gpointer attribute((unused)) user_data) {
462 double v = gtk_adjustment_get_value(volume_adj) / goesupto;
463 double b = gtk_adjustment_get_value(balance_adj);
466 /* This is the result of an update from the server, not a change from the
467 * user. Don't feedback! */
469 D(("volume_adjusted"));
470 /* force to 'stereotypical' values */
471 v = nearbyint(100 * v) / 100;
472 b = nearbyint(5 * b) / 5;
473 /* Set the volume. We don't want a reply, we'll get the actual new volume
476 int l = nearbyint(left(v, b) * 100), r = nearbyint(right(v, b) * 100);
477 mixer_control(DEFAULT_BACKEND, &l, &r, 1);
479 disorder_eclient_volume(client, volume_completed,
480 nearbyint(left(v, b) * 100),
481 nearbyint(right(v, b) * 100),
485 /** @brief Formats the volume value */
486 static gchar *format_volume(GtkScale attribute((unused)) *scale,
490 snprintf(s, sizeof s, "%.1f", (double)value);
494 /** @brief Formats the balance value */
495 static gchar *format_balance(GtkScale attribute((unused)) *scale,
499 if(fabs(value) < 0.1)
500 return g_strdup("0");
501 snprintf(s, sizeof s, "%+.1f", (double)value);
505 /* Volume mapping. We consider left, right, volume to be in [0,1]
506 * and balance to be in [-1,1].
508 * First, we just have volume = max(left, right).
510 * Balance we consider to linearly represent the amount by which the quieter
511 * channel differs from the louder. In detail:
513 * if right > left then balance > 0:
514 * balance = 0 => left = right (as an endpoint, not an instance)
515 * balance = 1 => left = 0
516 * fitting to linear, left = right * (1 - balance)
517 * so balance = 1 - left / right
518 * (right > left => right > 0 so no division by 0.)
520 * if left > right then balance < 0:
521 * balance = 0 => right = left (same caveat as above)
522 * balance = -1 => right = 0
523 * again fitting to linear, right = left * (1 + balance)
524 * so balance = right / left - 1
525 * (left > right => left > 0 so no division by 0.)
527 * if left = right then we just have balance = 0.
529 * Thanks to Clive and Andrew.
532 /** @brief Return the greater of @p x and @p y */
533 static double max(double x, double y) {
534 return x > y ? x : y;
537 /** @brief Compute the left channel volume */
538 static double left(double v, double b) {
539 if(b > 0) /* volume = right */
541 else /* volume = left */
545 /** @brief Compute the right channel volume */
546 static double right(double v, double b) {
547 if(b > 0) /* volume = right */
549 else /* volume = left */
553 /** @brief Compute the overall volume */
554 static double volume(double l, double r) {
558 /** @brief Compute the balance */
559 static double balance(double l, double r) {
564 else /* left = right */
568 /** @brief Called to enable RTP play
570 * Rather odd signature is to fit in with the other icons which all call @ref
571 * lib/eclient.h functions.
573 static int enable_rtp(disorder_eclient attribute((unused)) *c,
574 disorder_eclient_no_response attribute((unused)) *completed,
575 void attribute((unused)) *v) {
580 /** @brief Called to disable RTP play
582 * Rather odd signature is to fit in with the other icons which all call @ref
583 * lib/eclient.h functions.
585 static int disable_rtp(disorder_eclient attribute((unused)) *c,
586 disorder_eclient_no_response attribute((unused)) *completed,
587 void attribute((unused)) *v) {