static void commit_cb (GtkWidget * button, void * unused)
{
if (aud_drct_get_playing ())
aud_drct_stop ();
g_signal_emit_by_name (button, "ap-commit");
}
static gboolean skins_init (void)
{
plugin_is_active = TRUE;
g_log_set_handler(NULL, G_LOG_LEVEL_WARNING, g_log_default_handler, NULL);
skins_init_paths();
skins_cfg_load();
audgui_set_default_icon();
audgui_register_stock_icons();
ui_manager_init();
ui_manager_create_menus();
init_skins(config.skin);
mainwin_setup_menus();
if (aud_drct_get_playing ())
{
ui_main_evlistener_playback_begin (NULL, NULL);
if (aud_drct_get_paused ())
ui_main_evlistener_playback_pause (NULL, NULL);
}
else
mainwin_update_song_info ();
update_source = g_timeout_add (250, update_cb, NULL);
return TRUE;
}
static void ui_infoarea_set_title (void)
{
g_return_if_fail (area);
if (! aud_drct_get_playing ())
return;
int playlist = aud_playlist_get_playing ();
int entry = aud_playlist_get_position (playlist);
char * title, * artist, * album;
aud_playlist_entry_describe (playlist, entry, & title, & artist, & album, TRUE);
if (! g_strcmp0 (title, area->title) && ! g_strcmp0 (artist, area->artist)
&& ! g_strcmp0 (album, area->album))
{
str_unref (title);
str_unref (artist);
str_unref (album);
return;
}
str_unref (area->title);
str_unref (area->artist);
str_unref (area->album);
area->title = title;
area->artist = artist;
area->album = album;
gtk_widget_queue_draw (area->main);
}
static bool_t title_change_cb (void)
{
if (delayed_title_change_source)
{
g_source_remove (delayed_title_change_source);
delayed_title_change_source = 0;
}
if (aud_drct_get_playing ())
{
if (aud_drct_get_ready ())
{
char * title = aud_drct_get_title ();
SPRINTF (title_s, _("%s - Audacious"), title);
gtk_window_set_title ((GtkWindow *) window, title_s);
str_unref (title);
}
else
gtk_window_set_title ((GtkWindow *) window, _("Buffering ..."));
}
else
gtk_window_set_title ((GtkWindow *) window, _("Audacious"));
return FALSE;
}
static gboolean title_change_cb (void)
{
if (delayed_title_change_source)
{
g_source_remove (delayed_title_change_source);
delayed_title_change_source = 0;
}
if (aud_drct_get_playing ())
{
if (aud_drct_get_ready ())
{
gchar * title = aud_drct_get_title ();
gchar * title_s = g_strdup_printf (_("%s - Audacious"), title);
gtk_window_set_title ((GtkWindow *) window, title_s);
g_free (title_s);
str_unref (title);
}
else
gtk_window_set_title ((GtkWindow *) window, _("Buffering ..."));
}
else
gtk_window_set_title ((GtkWindow *) window, _("Audacious"));
return FALSE;
}
EXPORT void audgui_jump_to_time (void)
{
if (audgui_reshow_unique_window (AUDGUI_JUMP_TO_TIME_WINDOW))
return;
GtkWidget * entry = gtk_entry_new ();
gtk_entry_set_activates_default ((GtkEntry *) entry, TRUE);
GtkWidget * button1 = audgui_button_new (_("Jump"), "go-jump", jump_cb, entry);
GtkWidget * button2 = audgui_button_new (_("Cancel"), "process-stop", NULL, NULL);
GtkWidget * dialog = audgui_dialog_new (GTK_MESSAGE_OTHER,
_("Jump to Time"), _("Enter time (minutes:seconds):"), button1, button2);
audgui_dialog_add_widget (dialog, entry);
if (aud_drct_get_playing ())
{
int time = aud_drct_get_time () / 1000;
SPRINTF (buf, "%u:%02u", time / 60, time % 60);
gtk_entry_set_text ((GtkEntry *) entry, buf);
}
audgui_show_unique_window (AUDGUI_JUMP_TO_TIME_WINDOW, dialog);
}
static void jump_cb (void * entry)
{
const char * text = gtk_entry_get_text ((GtkEntry *) entry);
unsigned minutes, seconds;
if (sscanf (text, "%u:%u", & minutes, & seconds) == 2 && aud_drct_get_playing ())
aud_drct_seek ((minutes * 60 + seconds) * 1000);
}
static bool_t stop_cb (MprisMediaPlayer2Player * object, GDBusMethodInvocation *
call, void * unused)
{
if (aud_drct_get_playing ())
aud_drct_stop ();
mpris_media_player2_player_complete_stop (object, call);
return TRUE;
}
static bool_t seek_cb (MprisMediaPlayer2Player * object,
GDBusMethodInvocation * call, int64_t offset, void * unused)
{
if (aud_drct_get_playing ())
aud_drct_seek (aud_drct_get_time () + offset / 1000);
mpris_media_player2_player_complete_seek (object, call);
return TRUE;
}
void audgui_jump_to_time (void)
{
if (! aud_drct_get_playing ())
return;
if (window)
{
gtk_window_present ((GtkWindow *) window);
return;
}
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (window, "destroy", (GCallback) gtk_widget_destroyed,
& window);
gtk_window_set_type_hint ((GtkWindow *) window, GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_title ((GtkWindow *) window, _("Jump to Time"));
gtk_window_set_resizable ((GtkWindow *) window, FALSE);
gtk_container_set_border_width ((GtkContainer *) window, 6);
audgui_destroy_on_escape (window);
GtkWidget * vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_container_add ((GtkContainer *) window, vbox);
GtkWidget * hbox_new = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start ((GtkBox *) vbox, hbox_new, FALSE, FALSE, 0);
GtkWidget * time_entry = gtk_entry_new ();
gtk_entry_set_activates_default ((GtkEntry *) time_entry, TRUE);
gtk_box_pack_start ((GtkBox *) hbox_new, time_entry, FALSE, FALSE, 0);
GtkWidget * label = gtk_label_new (_("mm:ss"));
gtk_box_pack_start ((GtkBox *) hbox_new, label, FALSE, FALSE, 0);
GtkWidget * bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start ((GtkBox *) vbox, bbox, TRUE, TRUE, 0);
gtk_button_box_set_layout ((GtkButtonBox *) bbox, GTK_BUTTONBOX_END);
gtk_box_set_spacing ((GtkBox *) bbox, 6);
GtkWidget * cancel = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
gtk_container_add ((GtkContainer *) bbox, cancel);
g_signal_connect_swapped (cancel, "clicked", (GCallback) gtk_widget_destroy,
window);
GtkWidget * jump = gtk_button_new_from_stock (GTK_STOCK_JUMP_TO);
gtk_widget_set_can_default (jump, TRUE);
gtk_container_add ((GtkContainer *) bbox, jump);
g_signal_connect (jump, "clicked", (GCallback) jump_to_time_cb, time_entry);
unsigned int tindex = aud_drct_get_time () / 1000;
char time_str[10];
snprintf (time_str, sizeof time_str, "%u:%2.2u", tindex / 60, tindex % 60);
gtk_entry_set_text ((GtkEntry *) time_entry, time_str);
gtk_editable_select_region ((GtkEditable *) time_entry, 0, -1);
gtk_widget_show_all (window);
gtk_widget_grab_default (jump);
}
static void album_update (void * unused, GtkWidget * widget)
{
if (! aud_drct_get_playing ())
return;
GdkPixbuf * unscaled = audgui_pixbuf_request_current ();
album_set_unscaled (widget, unscaled ? unscaled : audgui_pixbuf_fallback ());
gtk_widget_queue_draw (widget);
}
static bool_t set_position_cb (MprisMediaPlayer2Player * object,
GDBusMethodInvocation * call, const char * track, int64_t pos, void * unused)
{
if (aud_drct_get_playing ())
aud_drct_seek (pos / 1000);
mpris_media_player2_player_complete_set_position (object, call);
return TRUE;
}
void set_ab_repeat_b (void)
{
if (! aud_drct_get_playing ())
return;
int a, b;
aud_drct_get_ab_repeat (& a, & b);
b = aud_drct_get_time ();
aud_drct_set_ab_repeat (a, b);
}
static void album_art_ready (void)
{
g_return_if_fail (area);
if (! aud_drct_get_playing ())
return;
set_album_art ();
gtk_widget_queue_draw (area->main);
}
static bool_t play_pause_cb (MprisMediaPlayer2Player * object,
GDBusMethodInvocation * call, void * unused)
{
if (aud_drct_get_playing () && ! aud_drct_get_paused ())
aud_drct_pause ();
else
aud_drct_play ();
mpris_media_player2_player_complete_play_pause (object, call);
return TRUE;
}
static void update_playback_status (void * data, GObject * object)
{
const char * status;
if (aud_drct_get_playing ())
status = aud_drct_get_paused () ? "Paused" : "Playing";
else
status = "Stopped";
g_object_set (object, "playback-status", status, NULL);
update (object);
}
static void response_cb (GtkWidget * window, int response)
{
if (response == GTK_RESPONSE_OK)
{
if (aud_drct_get_playing ())
aud_drct_stop ();
g_signal_emit_by_name (window, "ap-commit");
i_configure_commit (window);
}
else
i_configure_cancel (window);
}
static bool_t update (GObject * object)
{
int64_t pos = 0;
int vol = 0;
if (aud_drct_get_playing () && aud_drct_get_ready ())
pos = (int64_t) aud_drct_get_time () * 1000;
aud_drct_get_volume_main (& vol);
g_signal_handlers_block_by_func (object, (void *) volume_changed, NULL);
g_object_set (object, "position", pos, "volume", (double) vol / 100, NULL);
g_signal_handlers_unblock_by_func (object, (void *) volume_changed, NULL);
return TRUE;
}
static void jump_to_time_cb (GtkWidget * widget, GtkWidget * entry)
{
unsigned int min = 0, sec = 0;
int params = sscanf (gtk_entry_get_text ((GtkEntry *) entry), "%u:%u", & min,
& sec);
int time;
if (params == 2)
time = 60 * min + sec;
else if (params == 1)
time = min;
else
return;
if (aud_drct_get_playing ())
aud_drct_seek (1000 * time);
if (window)
gtk_widget_destroy (window);
}
static void lyricwiki_playback_began(void)
{
if (!aud_drct_get_playing())
return;
/* FIXME: cancel previous VFS requests (not possible with current API) */
str_unref(state.filename);
str_unref(state.title);
str_unref(state.artist);
str_unref(state.uri);
int playlist = aud_playlist_get_playing();
int pos = aud_playlist_get_position(playlist);
state.filename = aud_playlist_entry_get_filename(playlist, pos);
aud_playlist_entry_describe(playlist, pos, &state.title, &state.artist, NULL, FALSE);
state.uri = NULL;
get_lyrics_step_1();
}
GtkWidget * ui_infoarea_new (void)
{
g_return_val_if_fail (! area, NULL);
area = g_slice_new0 (UIInfoArea);
area->box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
area->main = gtk_drawing_area_new ();
gtk_widget_set_size_request (area->main, ICON_SIZE + 2 * SPACING, HEIGHT);
gtk_box_pack_start ((GtkBox *) area->box, area->main, TRUE, TRUE, 0);
g_signal_connect (area->main, "draw", (GCallback) draw_cb, NULL);
hook_associate ("playlist update", (HookFunction) ui_infoarea_set_title, NULL);
hook_associate ("playback begin", (HookFunction) ui_infoarea_playback_start, NULL);
hook_associate ("playback stop", (HookFunction) ui_infoarea_playback_stop, NULL);
hook_associate ("current art ready", (HookFunction) album_art_ready, NULL);
g_signal_connect (area->box, "destroy", (GCallback) destroy_cb, NULL);
if (aud_drct_get_playing ())
{
ui_infoarea_playback_start ();
/* skip fade-in */
area->alpha = 1;
if (area->fade_timeout)
{
g_source_remove (area->fade_timeout);
area->fade_timeout = 0;
}
}
GtkWidget * frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type ((GtkFrame *) frame, GTK_SHADOW_IN);
gtk_container_add ((GtkContainer *) frame, area->box);
return frame;
}
void osd_setup_buttons (NotifyNotification *notification)
{
notify_notification_clear_actions (notification);
if (! aud_get_bool ("notify", "actions"))
return;
notify_notification_add_action (notification, "default", _("Show"),
NOTIFY_ACTION_CALLBACK (show_cb), NULL, NULL);
bool_t playing = aud_drct_get_playing ();
bool_t paused = aud_drct_get_paused ();
if (playing && ! paused)
notify_notification_add_action (notification, "media-playback-pause",
_("Pause"), NOTIFY_ACTION_CALLBACK (aud_drct_pause), NULL, NULL);
else
notify_notification_add_action (notification, "media-playback-start",
_("Play"), NOTIFY_ACTION_CALLBACK (aud_drct_play), NULL, NULL);
if (playing)
notify_notification_add_action (notification, "media-skip-forward",
_("Next"), NOTIFY_ACTION_CALLBACK (aud_drct_pl_next), NULL, NULL);
}
static bool_t ui_infoarea_do_fade (void)
{
g_return_val_if_fail (area, FALSE);
bool_t ret = FALSE;
if (aud_drct_get_playing () && area->alpha < 1)
{
area->alpha += 0.1;
ret = TRUE;
}
if (area->last_alpha > 0)
{
area->last_alpha -= 0.1;
ret = TRUE;
}
gtk_widget_queue_draw (area->main);
if (! ret)
area->fade_timeout = 0;
return ret;
}
static gboolean init (void)
{
search_tool = aud_plugin_lookup_basename ("search-tool");
aud_config_set_defaults ("gtkui", gtkui_defaults);
audgui_set_default_icon();
audgui_register_stock_icons();
pw_col_init ();
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_has_resize_grip ((GtkWindow *) window, FALSE);
g_signal_connect(G_OBJECT(window), "delete-event", G_CALLBACK(window_delete), NULL);
accel = gtk_accel_group_new ();
gtk_window_add_accel_group ((GtkWindow *) window, accel);
vbox_outer = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add ((GtkContainer *) window, vbox_outer);
menu_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start ((GtkBox *) vbox_outer, menu_box, FALSE, FALSE, 0);
toolbar = gtk_toolbar_new ();
gtk_toolbar_set_style ((GtkToolbar *) toolbar, GTK_TOOLBAR_ICONS);
GtkStyleContext * context = gtk_widget_get_style_context (toolbar);
gtk_style_context_add_class (context, GTK_STYLE_CLASS_PRIMARY_TOOLBAR);
gtk_box_pack_start ((GtkBox *) vbox_outer, toolbar, FALSE, FALSE, 0);
/* search button */
if (search_tool)
{
search_button = toggle_button_new (GTK_STOCK_FIND, NULL, toggle_search_tool);
gtk_toolbar_insert ((GtkToolbar *) toolbar, search_button, -1);
gtk_toggle_tool_button_set_active ((GtkToggleToolButton *) search_button,
aud_plugin_get_enabled (search_tool));
aud_plugin_add_watch (search_tool, search_tool_toggled, NULL);
}
/* playback buttons */
toolbar_button_add (toolbar, button_open_pressed, GTK_STOCK_OPEN);
toolbar_button_add (toolbar, button_add_pressed, GTK_STOCK_ADD);
button_play = toolbar_button_add (toolbar, aud_drct_play_pause, GTK_STOCK_MEDIA_PLAY);
button_stop = toolbar_button_add (toolbar, aud_drct_stop, GTK_STOCK_MEDIA_STOP);
toolbar_button_add (toolbar, aud_drct_pl_prev, GTK_STOCK_MEDIA_PREVIOUS);
toolbar_button_add (toolbar, aud_drct_pl_next, GTK_STOCK_MEDIA_NEXT);
/* time slider and label */
GtkToolItem * boxitem1 = gtk_tool_item_new ();
gtk_tool_item_set_expand (boxitem1, TRUE);
gtk_toolbar_insert ((GtkToolbar *) toolbar, boxitem1, -1);
GtkWidget * box1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_add ((GtkContainer *) boxitem1, box1);
slider = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, NULL);
gtk_range_set_increments ((GtkRange *) slider, 5000, 5000);
gtk_scale_set_draw_value(GTK_SCALE(slider), FALSE);
gtk_widget_set_size_request(slider, 120, -1);
gtk_widget_set_valign (slider, GTK_ALIGN_CENTER);
gtk_widget_set_can_focus(slider, FALSE);
gtk_box_pack_start ((GtkBox *) box1, slider, TRUE, TRUE, 6);
label_time = markup_label_new(NULL);
gtk_box_pack_end ((GtkBox *) box1, label_time, FALSE, FALSE, 6);
gtk_widget_set_no_show_all (slider, TRUE);
gtk_widget_set_no_show_all (label_time, TRUE);
/* repeat and shuffle buttons */
button_repeat = toggle_button_new ("media-playlist-repeat", "RP", toggle_repeat);
gtk_toolbar_insert ((GtkToolbar *) toolbar, button_repeat, -1);
button_shuffle = toggle_button_new ("media-playlist-shuffle", "SF", toggle_shuffle);
gtk_toolbar_insert ((GtkToolbar *) toolbar, button_shuffle, -1);
/* volume button */
GtkToolItem * boxitem2 = gtk_tool_item_new ();
gtk_toolbar_insert ((GtkToolbar *) toolbar, boxitem2, -1);
GtkWidget * box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_add ((GtkContainer *) boxitem2, box2);
volume = gtk_volume_button_new();
gtk_button_set_relief(GTK_BUTTON(volume), GTK_RELIEF_NONE);
gtk_scale_button_set_adjustment(GTK_SCALE_BUTTON(volume), GTK_ADJUSTMENT(gtk_adjustment_new(0, 0, 100, 1, 5, 0)));
gtk_widget_set_can_focus(volume, FALSE);
gint lvol = 0, rvol = 0;
aud_drct_get_volume(&lvol, &rvol);
gtk_scale_button_set_value(GTK_SCALE_BUTTON(volume), (lvol + rvol) / 2);
gtk_box_pack_start ((GtkBox *) box2, volume, FALSE, FALSE, 0);
/* main UI layout */
layout_load ();
GtkWidget * layout = layout_new ();
gtk_box_pack_start ((GtkBox *) vbox_outer, layout, TRUE, TRUE, 0);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
layout_add_center (vbox);
ui_playlist_notebook_new ();
gtk_box_pack_start ((GtkBox *) vbox, (GtkWidget *) UI_PLAYLIST_NOTEBOOK, TRUE, TRUE, 0);
/* optional UI elements */
show_menu (aud_get_bool ("gtkui", "menu_visible"));
show_infoarea (aud_get_bool ("gtkui", "infoarea_visible"));
if (aud_get_bool ("gtkui", "statusbar_visible"))
{
statusbar = ui_statusbar_new ();
gtk_box_pack_end ((GtkBox *) vbox_outer, statusbar, FALSE, FALSE, 0);
}
AUDDBG("hooks associate\n");
ui_hooks_associate();
AUDDBG("playlist associate\n");
ui_playlist_notebook_populate();
g_signal_connect(slider, "change-value", G_CALLBACK(ui_slider_change_value_cb), NULL);
g_signal_connect(slider, "button-press-event", G_CALLBACK(ui_slider_button_press_cb), NULL);
g_signal_connect(slider, "button-release-event", G_CALLBACK(ui_slider_button_release_cb), NULL);
volume_change_handler_id = g_signal_connect(volume, "value-changed", G_CALLBACK(ui_volume_value_changed_cb), NULL);
g_signal_connect(volume, "pressed", G_CALLBACK(ui_volume_pressed_cb), NULL);
g_signal_connect(volume, "released", G_CALLBACK(ui_volume_released_cb), NULL);
update_volume_timeout_source = g_timeout_add(250, (GSourceFunc) ui_volume_slider_update, volume);
g_signal_connect (window, "map-event", (GCallback) window_mapped_cb, NULL);
g_signal_connect (window, "key-press-event", (GCallback) window_keypress_cb, NULL);
g_signal_connect (UI_PLAYLIST_NOTEBOOK, "key-press-event", (GCallback) playlist_keypress_cb, NULL);
if (aud_drct_get_playing ())
{
ui_playback_begin ();
if (aud_drct_get_ready ())
ui_playback_ready ();
}
else
ui_playback_stop ();
title_change_cb ();
gtk_widget_show_all (vbox_outer);
update_toggles (NULL, NULL);
menu_rclick = make_menu_rclick (accel);
menu_tab = make_menu_tab (accel);
return TRUE;
}
static gboolean window_keypress_cb (GtkWidget * widget, GdkEventKey * event, void * unused)
{
switch (event->state & (GDK_SHIFT_MASK | GDK_CONTROL_MASK | GDK_MOD1_MASK))
{
case 0:;
GtkWidget * focused = gtk_window_get_focus ((GtkWindow *) window);
/* escape key returns focus to playlist */
if (event->keyval == GDK_KEY_Escape)
{
if (! focused || ! gtk_widget_is_ancestor (focused, (GtkWidget *) UI_PLAYLIST_NOTEBOOK))
gtk_widget_grab_focus (playlist_get_treeview (aud_playlist_get_active ()));
return FALSE;
}
/* single-key shortcuts; must not interfere with text entry */
if (focused && GTK_IS_ENTRY (focused))
return FALSE;
switch (event->keyval)
{
case 'z':
aud_drct_pl_prev ();
return TRUE;
case 'x':
aud_drct_play ();
return TRUE;
case 'c':
case ' ':
aud_drct_pause ();
return TRUE;
case 'v':
aud_drct_stop ();
return TRUE;
case 'b':
aud_drct_pl_next ();
return TRUE;
case GDK_KEY_Left:
if (aud_drct_get_playing ())
do_seek (aud_drct_get_time () - 5000);
return TRUE;
case GDK_KEY_Right:
if (aud_drct_get_playing ())
do_seek (aud_drct_get_time () + 5000);
return TRUE;
}
return FALSE;
case GDK_CONTROL_MASK:
switch (event->keyval)
{
case GDK_KEY_ISO_Left_Tab:
case GDK_KEY_Tab:
aud_playlist_set_active ((aud_playlist_get_active () + 1) %
aud_playlist_count ());
break;
default:
return FALSE;
}
break;
case (GDK_CONTROL_MASK | GDK_SHIFT_MASK):
switch (event->keyval)
{
case GDK_KEY_ISO_Left_Tab:
case GDK_KEY_Tab:
aud_playlist_set_active (aud_playlist_get_active () ?
aud_playlist_get_active () - 1 : aud_playlist_count () - 1);
break;
default:
return FALSE;
}
break;
case GDK_MOD1_MASK:
switch (event->keyval)
{
case GDK_KEY_Left:
if (aud_drct_get_playing ())
do_seek (aud_drct_get_time () - 5000);
break;
case GDK_KEY_Right:
if (aud_drct_get_playing ())
do_seek (aud_drct_get_time () + 5000);
break;
default:
return FALSE;
}
default:
return FALSE;
}
return TRUE;
}
static gboolean lirc_input_callback (GIOChannel * source, GIOCondition condition, void * data)
{
char *code;
char *c;
gint playlist_time, playlist_pos, output_time, v;
int ret;
char *ptr;
gint balance;
#if 0
gboolean show_pl;
#endif
int n;
gchar *utf8_title_markup;
while ((ret = lirc_nextcode (&code)) == 0 && code != NULL)
{
while ((ret = lirc_code2char (config, code, &c)) == 0 && c != NULL)
{
if (strcasecmp ("PLAY", c) == 0)
{
aud_drct_play ();
}
else if (strcasecmp ("STOP", c) == 0)
{
aud_drct_stop ();
}
else if (strcasecmp ("PAUSE", c) == 0)
{
aud_drct_pause ();
}
else if (strcasecmp ("PLAYPAUSE", c) == 0)
{
if (aud_drct_get_playing ())
aud_drct_pause ();
else
aud_drct_play ();
}
else if (strncasecmp ("NEXT", c, 4) == 0)
{
ptr = c + 4;
while (isspace (*ptr))
ptr++;
n = atoi (ptr);
if (n <= 0)
n = 1;
for (; n > 0; n--)
{
aud_drct_pl_next ();
}
}
else if (strncasecmp ("PREV", c, 4) == 0)
{
ptr = c + 4;
while (isspace (*ptr))
ptr++;
n = atoi (ptr);
if (n <= 0)
n = 1;
for (; n > 0; n--)
{
aud_drct_pl_prev ();
}
}
else if (strcasecmp ("SHUFFLE", c) == 0)
{
aud_set_bool (NULL, "shuffle",
!aud_get_bool (NULL, "shuffle"));
}
else if (strcasecmp ("REPEAT", c) == 0)
{
aud_set_bool (NULL, "repeat", !aud_get_bool (NULL, "repeat"));
}
else if (strncasecmp ("FWD", c, 3) == 0)
{
ptr = c + 3;
while (isspace (*ptr))
ptr++;
n = atoi (ptr) * 1000;
if (n <= 0)
n = 5000;
output_time = aud_drct_get_time ();
int playlist = aud_playlist_get_active ();
playlist_pos = aud_playlist_get_position (playlist);
playlist_time =
aud_playlist_entry_get_length (playlist, playlist_pos,
FALSE);
if (playlist_time - output_time < n)
output_time = playlist_time - n;
aud_drct_seek (output_time + n);
}
else if (strncasecmp ("BWD", c, 3) == 0)
{
ptr = c + 3;
while (isspace (*ptr))
ptr++;
n = atoi (ptr) * 1000;
if (n <= 0)
n = 5000;
output_time = aud_drct_get_time ();
if (output_time < n)
output_time = n;
aud_drct_seek (output_time - n);
}
else if (strncasecmp ("VOL_UP", c, 6) == 0)
{
ptr = c + 6;
while (isspace (*ptr))
ptr++;
n = atoi (ptr);
if (n <= 0)
n = 5;
aud_drct_get_volume_main (&v);
if (v > (100 - n))
v = 100 - n;
aud_drct_set_volume_main (v + n);
}
else if (strncasecmp ("VOL_DOWN", c, 8) == 0)
{
ptr = c + 8;
while (isspace (*ptr))
ptr++;
n = atoi (ptr);
if (n <= 0)
n = 5;
aud_drct_get_volume_main (&v);
if (v < n)
v = n;
aud_drct_set_volume_main (v - n);
}
else if (strcasecmp ("QUIT", c) == 0)
{
aud_drct_quit ();
}
else if (strcasecmp ("MUTE", c) == 0)
{
if (mute == 0)
{
mute = 1;
/* store the master volume so
we can restore it on unmute. */
aud_drct_get_volume_main (&mute_vol);
aud_drct_set_volume_main (0);
}
else
{
mute = 0;
aud_drct_set_volume_main (mute_vol);
}
}
else if (strncasecmp ("BAL_LEFT", c, 8) == 0)
{
ptr = c + 8;
while (isspace (*ptr))
ptr++;
n = atoi (ptr);
if (n <= 0)
n = 5;
aud_drct_get_volume_balance (&balance);
balance -= n;
if (balance < -100)
balance = -100;
aud_drct_set_volume_balance (balance);
}
else if (strncasecmp ("BAL_RIGHT", c, 9) == 0)
{
ptr = c + 9;
while (isspace (*ptr))
ptr++;
n = atoi (ptr);
if (n <= 0)
n = 5;
aud_drct_get_volume_balance (&balance);
balance += n;
if (balance > 100)
balance = 100;
aud_drct_set_volume_balance (balance);
}
else if (strcasecmp ("BAL_CENTER", c) == 0)
{
balance = 0;
aud_drct_set_volume_balance (balance);
}
else if (strcasecmp ("LIST", c) == 0)
{
#if 0
show_pl = aud_drct_pl_win_is_visible ();
show_pl = (show_pl) ? 0 : 1;
aud_drct_pl_win_toggle (show_pl);
#endif
}
else if (strcasecmp ("PLAYLIST_CLEAR", c) == 0)
{
aud_drct_stop ();
int playlist = aud_playlist_get_active ();
aud_playlist_entry_delete (playlist, 0,
aud_playlist_entry_count
(playlist));
}
else if (strncasecmp ("PLAYLIST_ADD ", c, 13) == 0)
{
aud_drct_pl_add (c + 13, -1);
}
else if ((strlen (c) == 1) && ((*c >= '0') || (*c <= '9')))
{
if (track_no_pos < 63)
{
if (tid)
g_source_remove (tid);
track_no[track_no_pos++] = *c;
track_no[track_no_pos] = 0;
tid = g_timeout_add (1500, jump_to, NULL);
utf8_title_markup = g_markup_printf_escaped ("%s", track_no);
hook_call ("aosd toggle", utf8_title_markup);
}
}
else
{
fprintf (stderr, _("%s: unknown command \"%s\"\n"),
plugin_name, c);
}
}
free (code);
if (ret == -1)
break;
}
if (ret == -1)
{
/* something went badly wrong */
fprintf (stderr, _("%s: disconnected from LIRC\n"), plugin_name);
cleanup ();
if (aud_get_bool ("lirc", "enable_reconnect"))
{
int reconnect_timeout = aud_get_int ("lirc", "reconnect_timeout");
fprintf (stderr,
_("%s: will try reconnect every %d seconds...\n"),
plugin_name, reconnect_timeout);
g_timeout_add (1000 * reconnect_timeout, reconnect_lirc, NULL);
}
}
return TRUE;
}
bool_t mpris2_init (void)
{
GError * error = NULL;
bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, & error);
if (! bus)
{
fprintf (stderr, "mpris2: %s\n", error->message);
g_error_free (error);
return FALSE;
}
g_bus_own_name_on_connection (bus, "org.mpris.MediaPlayer2.audacious", 0,
NULL, NULL, NULL, NULL);
object_core = (GObject *) mpris_media_player2_skeleton_new ();
g_object_set (object_core,
"can-quit", TRUE,
"can-raise", TRUE,
"desktop-entry", "audacious",
"identity", "Audacious",
NULL);
g_signal_connect (object_core, "handle-quit", (GCallback) quit_cb, NULL);
g_signal_connect (object_core, "handle-raise", (GCallback) raise_cb, NULL);
object_player = (GObject *) mpris_media_player2_player_skeleton_new ();
g_object_set (object_player,
"can-control", TRUE,
"can-go-next", TRUE,
"can-go-previous", TRUE,
"can-pause", TRUE,
"can-play", TRUE,
"can-seek", TRUE,
NULL);
update_timer = g_timeout_add (250, (GSourceFunc) update, object_player);
update_playback_status (NULL, object_player);
if (aud_drct_get_playing () && aud_drct_get_ready ())
emit_seek (NULL, object_player);
hook_associate ("playback begin", (HookFunction) update_playback_status, object_player);
hook_associate ("playback pause", (HookFunction) update_playback_status, object_player);
hook_associate ("playback stop", (HookFunction) update_playback_status, object_player);
hook_associate ("playback unpause", (HookFunction) update_playback_status, object_player);
hook_associate ("playlist set playing", (HookFunction) update_metadata, object_player);
hook_associate ("playlist position", (HookFunction) update_metadata, object_player);
hook_associate ("playlist update", (HookFunction) update_metadata, object_player);
hook_associate ("playback ready", (HookFunction) emit_seek, object_player);
hook_associate ("playback seek", (HookFunction) emit_seek, object_player);
g_signal_connect (object_player, "handle-next", (GCallback) next_cb, NULL);
g_signal_connect (object_player, "handle-pause", (GCallback) pause_cb, NULL);
g_signal_connect (object_player, "handle-play", (GCallback) play_cb, NULL);
g_signal_connect (object_player, "handle-play-pause", (GCallback) play_pause_cb, NULL);
g_signal_connect (object_player, "handle-previous", (GCallback) previous_cb, NULL);
g_signal_connect (object_player, "handle-seek", (GCallback) seek_cb, NULL);
g_signal_connect (object_player, "handle-set-position", (GCallback) set_position_cb, NULL);
g_signal_connect (object_player, "handle-stop", (GCallback) stop_cb, NULL);
g_signal_connect (object_player, "notify::volume", (GCallback) volume_changed, NULL);
if (! g_dbus_interface_skeleton_export ((GDBusInterfaceSkeleton *)
object_core, bus, "/org/mpris/MediaPlayer2", & error) ||
! g_dbus_interface_skeleton_export ((GDBusInterfaceSkeleton *)
object_player, bus, "/org/mpris/MediaPlayer2", & error))
{
mpris2_cleanup ();
fprintf (stderr, "mpris2: %s\n", error->message);
g_error_free (error);
return FALSE;
}
return TRUE;
}
/* do_command(): do @cmd after replacing the format codes
@cmd: command to run */
static void do_command (char * cmd)
{
int playlist = aud_playlist_get_playing ();
int pos = aud_playlist_get_position (playlist);
char *shstring = NULL, *temp, numbuf[32];
gboolean playing;
Formatter *formatter;
if (cmd && strlen(cmd) > 0)
{
formatter = formatter_new();
char * ctitle = aud_playlist_entry_get_title (playlist, pos, FALSE);
if (ctitle)
{
temp = escape_shell_chars (ctitle);
formatter_associate(formatter, 's', temp);
formatter_associate(formatter, 'n', temp);
g_free(temp);
str_unref (ctitle);
}
else
{
formatter_associate(formatter, 's', "");
formatter_associate(formatter, 'n', "");
}
char * filename = aud_playlist_entry_get_filename (playlist, pos);
if (filename)
{
temp = escape_shell_chars (filename);
formatter_associate(formatter, 'f', temp);
g_free(temp);
str_unref (filename);
}
else
formatter_associate(formatter, 'f', "");
g_snprintf(numbuf, sizeof(numbuf), "%02d", pos + 1);
formatter_associate(formatter, 't', numbuf);
int length = aud_playlist_entry_get_length (playlist, pos, FALSE);
if (length > 0)
{
g_snprintf(numbuf, sizeof(numbuf), "%d", length);
formatter_associate(formatter, 'l', numbuf);
}
else
formatter_associate(formatter, 'l', "0");
playing = aud_drct_get_playing();
g_snprintf(numbuf, sizeof(numbuf), "%d", playing);
formatter_associate(formatter, 'p', numbuf);
if (playing)
{
int brate, srate, chans;
aud_drct_get_info (& brate, & srate, & chans);
snprintf (numbuf, sizeof numbuf, "%d", brate);
formatter_associate (formatter, 'r', numbuf);
snprintf (numbuf, sizeof numbuf, "%d", srate);
formatter_associate (formatter, 'F', numbuf);
snprintf (numbuf, sizeof numbuf, "%d", chans);
formatter_associate (formatter, 'c', numbuf);
}
Tuple * tuple = aud_playlist_entry_get_tuple
(aud_playlist_get_active (), pos, 0);
char * artist = tuple ? tuple_get_str (tuple, FIELD_ARTIST, NULL) : NULL;
if (artist)
{
formatter_associate(formatter, 'a', artist);
str_unref(artist);
}
else
formatter_associate(formatter, 'a', "");
char * album = tuple ? tuple_get_str (tuple, FIELD_ALBUM, NULL) : NULL;
if (album)
{
formatter_associate(formatter, 'b', album);
str_unref(album);
}
else
formatter_associate(formatter, 'b', "");
char * title = tuple ? tuple_get_str (tuple, FIELD_TITLE, NULL) : NULL;
if (title)
{
formatter_associate(formatter, 'T', title);
str_unref(title);
}
else
formatter_associate(formatter, 'T', "");
if (tuple)
tuple_unref (tuple);
shstring = formatter_format(formatter, cmd);
formatter_destroy(formatter);
if (shstring)
{
execute_command(shstring);
/* FIXME: This can possibly be freed too early */
g_free(shstring);
}
}
}
/* handle keys */
gboolean handle_keyevent (EVENT event)
{
gint current_volume, old_volume;
static gint volume_static = 0;
gboolean play, mute;
/* playing or not */
play = aud_drct_get_playing ();
/* get current volume */
aud_drct_get_volume_main (¤t_volume);
old_volume = current_volume;
if (current_volume)
{
/* volume is not mute */
mute = FALSE;
} else {
/* volume is mute */
mute = TRUE;
}
/* mute the playback */
if (event == EVENT_MUTE)
{
if (!mute)
{
volume_static = current_volume;
aud_drct_set_volume_main (0);
mute = TRUE;
} else {
aud_drct_set_volume_main (volume_static);
mute = FALSE;
}
return TRUE;
}
/* decreace volume */
if (event == EVENT_VOL_DOWN)
{
if (mute)
{
current_volume = old_volume;
old_volume = 0;
mute = FALSE;
}
if ((current_volume -= plugin_cfg.vol_decrement) < 0)
{
current_volume = 0;
}
if (current_volume != old_volume)
{
aud_drct_set_volume_main (current_volume);
}
old_volume = current_volume;
return TRUE;
}
/* increase volume */
if (event == EVENT_VOL_UP)
{
if (mute)
{
current_volume = old_volume;
old_volume = 0;
mute = FALSE;
}
if ((current_volume += plugin_cfg.vol_increment) > 100)
{
current_volume = 100;
}
if (current_volume != old_volume)
{
aud_drct_set_volume_main (current_volume);
}
old_volume = current_volume;
return TRUE;
}
/* play */
if (event == EVENT_PLAY)
{
aud_drct_play ();
return TRUE;
}
/* pause */
if (event == EVENT_PAUSE)
{
if (!play) aud_drct_play ();
else aud_drct_pause ();
return TRUE;
}
/* stop */
if (event == EVENT_STOP)
{
aud_drct_stop ();
return TRUE;
}
/* prev track */
if (event == EVENT_PREV_TRACK)
{
aud_drct_pl_prev ();
return TRUE;
}
/* next track */
if (event == EVENT_NEXT_TRACK)
{
aud_drct_pl_next ();
return TRUE;
}
/* forward */
if (event == EVENT_FORWARD)
{
aud_drct_seek (aud_drct_get_time () + 5000);
return TRUE;
}
/* backward */
if (event == EVENT_BACKWARD)
{
gint time = aud_drct_get_time ();
if (time > 5000) time -= 5000; /* Jump 5s back */
else time = 0;
aud_drct_seek (time);
return TRUE;
}
/* Open Jump-To-File dialog */
if (event == EVENT_JUMP_TO_FILE)
{
aud_interface_show_jump_to_track ();
return TRUE;
}
/* Toggle Windows */
if (event == EVENT_TOGGLE_WIN)
{
aud_interface_show (! (aud_interface_is_shown () && aud_interface_is_focused ()));
return TRUE;
}
/* Show OSD through AOSD plugin*/
if (event == EVENT_SHOW_AOSD)
{
hook_call("aosd toggle", NULL);
return TRUE;
}
if (event == EVENT_TOGGLE_REPEAT)
{
aud_set_bool (NULL, "repeat", ! aud_get_bool (NULL, "repeat"));
return TRUE;
}
if (event == EVENT_TOGGLE_SHUFFLE)
{
aud_set_bool (NULL, "shuffle", ! aud_get_bool (NULL, "shuffle"));
return TRUE;
}
if (event == EVENT_TOGGLE_STOP)
{
aud_set_bool (NULL, "stop_after_current_song", ! aud_get_bool (NULL, "stop_after_current_song"));
return TRUE;
}
if (event == EVENT_RAISE)
{
aud_interface_show (TRUE);
return TRUE;
}
return FALSE;
}
