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 clicked_icon(GtkButton
attribute((unused
)) *button
,
410 const struct icon
*icon
= userdata
;
412 if(!suppress_actions
)
413 icon
->action(client
, 0, 0);
416 static void clicked_menu(GtkMenuItem
attribute((unused
)) *menuitem
,
418 const struct icon
*icon
= userdata
;
420 if(!suppress_actions
)
421 icon
->action(client
, 0, 0);
424 static void toggled_menu(GtkCheckMenuItem
*menuitem
,
426 const struct icon
*icon
= userdata
;
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
)
439 icons
[n
].action(client
, 0, 0);
442 /** @brief Called when the volume has been adjusted */
443 static 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
);
449 /* This is the result of an update from the server, not a change from the
450 * user. Don't feedback! */
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
459 int l
= nearbyint(left(v
, b
) * 100), r
= nearbyint(right(v
, b
) * 100);
460 mixer_control(DEFAULT_BACKEND
, &l
, &r
, 1);
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),
469 /** @brief Formats the volume value */
470 static gchar
*format_volume(GtkScale
attribute((unused
)) *scale
,
474 snprintf(s
, sizeof s
, "%.1f", (double)value
);
478 /** @brief Formats the balance value */
479 static gchar
*format_balance(GtkScale
attribute((unused
)) *scale
,
483 if(fabs(value
) < 0.1)
484 return g_strdup("0");
485 snprintf(s
, sizeof s
, "%+.1f", (double)value
);
489 /* Volume mapping. We consider left, right, volume to be in [0,1]
490 * and balance to be in [-1,1].
492 * First, we just have volume = max(left, right).
494 * Balance we consider to linearly represent the amount by which the quieter
495 * channel differs from the louder. In detail:
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.)
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.)
511 * if left = right then we just have balance = 0.
513 * Thanks to Clive and Andrew.
516 /** @brief Return the greater of @p x and @p y */
517 static double max(double x
, double y
) {
518 return x
> y ? x
: y
;
521 /** @brief Compute the left channel volume */
522 static double left(double v
, double b
) {
523 if(b
> 0) /* volume = right */
525 else /* volume = left */
529 /** @brief Compute the right channel volume */
530 static double right(double v
, double b
) {
531 if(b
> 0) /* volume = right */
533 else /* volume = left */
537 /** @brief Compute the overall volume */
538 static double volume(double l
, double r
) {
542 /** @brief Compute the balance */
543 static double balance(double l
, double r
) {
548 else /* left = right */
552 /** @brief Called to enable RTP play
554 * Rather odd signature is to fit in with the other icons which all call @ref
555 * lib/eclient.h functions.
557 static int enable_rtp(disorder_eclient
attribute((unused
)) *c
,
558 disorder_eclient_no_response
attribute((unused
)) *completed
,
559 void attribute((unused
)) *v
) {
564 /** @brief Called to disable RTP play
566 * Rather odd signature is to fit in with the other icons which all call @ref
567 * lib/eclient.h functions.
569 static int disable_rtp(disorder_eclient
attribute((unused
)) *c
,
570 disorder_eclient_no_response
attribute((unused
)) *completed
,
571 void attribute((unused
)) *v
) {