static bool_t seek_cb (MprisMediaPlayer2Player * object,
GDBusMethodInvocation * call, int64_t offset, void * unused)
{
aud_drct_seek (aud_drct_get_time () + offset / 1000);
mpris_media_player2_player_complete_seek (object, call);
return TRUE;
}
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);
}
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);
}
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 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 gboolean time_counter_cb (void)
{
if (slider_is_moving)
return TRUE;
slider_seek_time = -1; // delayed reset to avoid seeking twice
gint time = aud_drct_get_time ();
gint length = aud_drct_get_length ();
if (length > 0)
set_slider (time);
set_time_label (time, length);
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;
}
/* 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;
}
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)
aud_drct_play_pause ();
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;
}
static void emit_seek (void * data, GObject * object)
{
g_signal_emit_by_name (object, "seeked", (int64_t) aud_drct_get_time () * 1000);
}
