static void
garu_headerbar_init_playback_buttons (GaruHeaderbar *self)
{
GSettings *settings;
GaruApplication *app;
GtkWidget *box, *button, *image;
app = GARU_APPLICATION (g_application_get_default ());
settings = garu_application_get_settings (app);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
/* shuffle */
button = garu_utils_new_icon_button ("media-playlist-shuffle-symbolic",
TRUE, FALSE);
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
gtk_widget_show (button);
/* repeat */
button = garu_utils_new_icon_button ("media-playlist-repeat-symbolic",
TRUE, FALSE);
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
gtk_widget_show (button);
/* volume */
button = gtk_volume_button_new ();
gtk_scale_button_set_value (GTK_SCALE_BUTTON (button), 1);
g_settings_bind (settings, "volume", button, "value",
G_SETTINGS_BIND_DEFAULT);
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
gtk_widget_show (button);
gtk_header_bar_pack_end (GTK_HEADER_BAR (self), box);
gtk_widget_show (box);
}
void FullscreenVideoControllerGtk::createHud()
{
m_hudWindow = gtk_window_new(GTK_WINDOW_POPUP);
gtk_window_set_gravity(GTK_WINDOW(m_hudWindow), GDK_GRAVITY_SOUTH_WEST);
gtk_window_set_type_hint(GTK_WINDOW(m_hudWindow), GDK_WINDOW_TYPE_HINT_NORMAL);
m_hudMotionNotifySignalId = g_signal_connect(m_hudWindow, "motion-notify-event", G_CALLBACK(onFullscreenGtkMotionNotifyEvent), this);
#ifdef GTK_API_VERSION_2
GtkWidget* hbox = gtk_hbox_new(FALSE, 4);
#else
GtkWidget* hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
#endif
gtk_container_add(GTK_CONTAINER(m_hudWindow), hbox);
m_playPauseAction = gtk_action_new("play", _("Play / Pause"), _("Play or pause the media"), PAUSE_ICON_NAME);
m_playActionActivateSignalId = g_signal_connect(m_playPauseAction, "activate", G_CALLBACK(togglePlayPauseActivated), this);
GtkWidget* item = gtk_action_create_tool_item(m_playPauseAction);
gtk_box_pack_start(GTK_BOX(hbox), item, FALSE, TRUE, 0);
GtkWidget* label = gtk_label_new(_("Time:"));
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0);
GtkAdjustment* adjustment = GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, 100.0, 0.1, 1.0, 1.0));
#ifdef GTK_API_VERSION_2
m_timeHScale = gtk_hscale_new(adjustment);
#else
m_timeHScale = gtk_scale_new(GTK_ORIENTATION_HORIZONTAL, adjustment);
#endif
gtk_scale_set_draw_value(GTK_SCALE(m_timeHScale), FALSE);
gtk_range_set_show_fill_level(GTK_RANGE(m_timeHScale), TRUE);
m_timeScaleButtonPressedSignalId = g_signal_connect(m_timeHScale, "button-press-event", G_CALLBACK(timeScaleButtonPressed), this);
m_timeScaleButtonReleasedSignalId = g_signal_connect(m_timeHScale, "button-release-event", G_CALLBACK(timeScaleButtonReleased), this);
m_hscaleUpdateId = g_signal_connect(m_timeHScale, "value-changed", G_CALLBACK(timeScaleValueChanged), this);
gtk_box_pack_start(GTK_BOX(hbox), m_timeHScale, TRUE, TRUE, 0);
m_timeLabel = gtk_label_new("");
gtk_box_pack_start(GTK_BOX(hbox), m_timeLabel, FALSE, TRUE, 0);
// Volume button.
m_volumeButton = gtk_volume_button_new();
gtk_box_pack_start(GTK_BOX(hbox), m_volumeButton, FALSE, TRUE, 0);
gtk_scale_button_set_value(GTK_SCALE_BUTTON(m_volumeButton), m_player->volume());
m_volumeUpdateId = g_signal_connect(m_volumeButton, "value-changed", G_CALLBACK(volumeValueChanged), this);
m_exitFullscreenAction = gtk_action_new("exit", _("Exit Fullscreen"), _("Exit from fullscreen mode"), EXIT_FULLSCREEN_ICON_NAME);
m_exitFullcreenActionActivateSignalId = g_signal_connect(m_exitFullscreenAction, "activate", G_CALLBACK(exitFullscreenActivated), this);
g_object_set(m_exitFullscreenAction, "icon-name", EXIT_FULLSCREEN_ICON_NAME, NULL);
item = gtk_action_create_tool_item(m_exitFullscreenAction);
gtk_box_pack_start(GTK_BOX(hbox), item, FALSE, TRUE, 0);
m_progressBarUpdateId = g_timeout_add(PROGRESS_BAR_UPDATE_INTERVAL, reinterpret_cast<GSourceFunc>(progressBarUpdateCallback), this);
playStateChanged();
}
static void
test_volume_button_basic (void)
{
GtkWidget *widget;
widget = gtk_volume_button_new ();
g_assert (GTK_IS_VOLUME_BUTTON (widget));
gtk_widget_destroy (widget);
}
int
main (int argc,
char **argv)
{
GtkWidget *window;
GtkWidget *button;
GtkWidget *button2;
GtkWidget *button3;
GtkWidget *box;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
button = gtk_volume_button_new ();
button2 = gtk_volume_button_new ();
box = gtk_hbox_new (FALSE, 0);
g_signal_connect (G_OBJECT (button), "value-changed",
G_CALLBACK (value_changed),
NULL);
gtk_container_add (GTK_CONTAINER (window), box);
gtk_container_add (GTK_CONTAINER (box), button);
gtk_container_add (GTK_CONTAINER (box), button2);
button3 = gtk_button_new_with_label ("Toggle orientation");
gtk_container_add (GTK_CONTAINER (box), button3);
g_signal_connect (G_OBJECT (button3), "clicked",
G_CALLBACK (toggle_orientation),
button);
g_signal_connect (G_OBJECT (button3), "clicked",
G_CALLBACK (toggle_orientation),
button2);
gtk_widget_show_all (window);
gtk_button_clicked (GTK_BUTTON (button));
g_timeout_add (4000, (GSourceFunc) show_error, window);
gtk_main ();
return 0;
}
gint main(gint argc, gchar *argv[])
{
GtkWidget *window;
GtkWidget *volumeButton;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width(GTK_CONTAINER(window),50);
g_signal_connect(G_OBJECT(window), "destroy",
G_CALLBACK(gtk_main_quit), NULL);
volumeButton =gtk_volume_button_new();
/*g_signal_connect(G_OBJECT(volumeButton), "clicked",
G_CALLBACK(hello), NULL);*/
gtk_container_add(GTK_CONTAINER(window), volumeButton);
gtk_widget_show(volumeButton);
gtk_widget_show(window);
gtk_main();
return 0;
}
static void
pragha_toolbar_init (PraghaToolbar *toolbar)
{
PraghaPreferences *preferences;
GtkToolItem *prev_button, *play_button, *stop_button, *next_button;
GtkToolItem *unfull_button, *shuffle_button, *repeat_button;
GtkWidget *vol_button;
const GBindingFlags binding_flags =
G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL;
preferences = pragha_preferences_get();
/* Setup Left control buttons */
prev_button = gtk_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON(prev_button), "media-skip-backward");
gtk_widget_set_tooltip_text(GTK_WIDGET(prev_button), _("Previous Track"));
toolbar->prev_button = prev_button;
play_button = gtk_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON(play_button), "media-playback-start");
gtk_widget_set_tooltip_text(GTK_WIDGET(play_button), _("Play / Pause Track"));
toolbar->play_button = play_button;
stop_button = gtk_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON(stop_button), "media-playback-stop");
gtk_widget_set_tooltip_text(GTK_WIDGET(stop_button), _("Stop playback"));
toolbar->stop_button = stop_button;
next_button = gtk_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON(next_button), "media-skip-forward");
gtk_widget_set_tooltip_text(GTK_WIDGET(next_button), _("Next Track"));
toolbar->next_button = next_button;
#if GTK_CHECK_VERSION (3, 12, 0)
gtk_header_bar_pack_start(GTK_HEADER_BAR(toolbar), GTK_WIDGET(prev_button));
gtk_header_bar_pack_start(GTK_HEADER_BAR(toolbar), GTK_WIDGET(play_button));
gtk_header_bar_pack_start(GTK_HEADER_BAR(toolbar), GTK_WIDGET(stop_button));
gtk_header_bar_pack_start(GTK_HEADER_BAR(toolbar), GTK_WIDGET(next_button));
#else
gtk_tool_insert_generic_item(GTK_TOOLBAR(toolbar), GTK_WIDGET(prev_button));
gtk_tool_insert_generic_item(GTK_TOOLBAR(toolbar), GTK_WIDGET(play_button));
gtk_tool_insert_generic_item(GTK_TOOLBAR(toolbar), GTK_WIDGET(stop_button));
gtk_tool_insert_generic_item(GTK_TOOLBAR(toolbar), GTK_WIDGET(next_button));
#endif
/* Song info Box */
#if !GTK_CHECK_VERSION (3, 12, 0)
GtkToolItem *boxitem = gtk_tool_item_new ();
gtk_tool_item_set_expand (GTK_TOOL_ITEM(boxitem), TRUE);
gtk_toolbar_insert (GTK_TOOLBAR(toolbar), GTK_TOOL_ITEM(boxitem), -1);
GtkWidget *box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_add (GTK_CONTAINER(boxitem), box);
GtkWidget *playing = pragha_toolbar_get_song_box (toolbar);
gtk_box_pack_start (GTK_BOX(box), playing, TRUE, TRUE, 5);
#endif
/* Setup Right control buttons */
unfull_button = gtk_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON(unfull_button), "view-restore");
gtk_widget_set_tooltip_text(GTK_WIDGET(unfull_button), _("Leave Fullscreen"));
toolbar->unfull_button = unfull_button;
shuffle_button = gtk_toggle_tool_button_new();
gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(shuffle_button), "media-playlist-shuffle");
gtk_widget_set_tooltip_text(GTK_WIDGET(shuffle_button), _("Play songs in a random order"));
repeat_button = gtk_toggle_tool_button_new ();
gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(repeat_button), "media-playlist-repeat");
gtk_widget_set_tooltip_text(GTK_WIDGET(repeat_button), _("Repeat playback list at the end"));
vol_button = gtk_volume_button_new();
g_object_set(vol_button, "use-symbolic", FALSE, NULL);
gtk_button_set_relief(GTK_BUTTON(vol_button), GTK_RELIEF_NONE);
g_object_set(G_OBJECT(vol_button), "size", GTK_ICON_SIZE_LARGE_TOOLBAR, NULL);
toolbar->vol_button = vol_button;
toolbar->extra_button_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
#if GTK_CHECK_VERSION (3, 12, 0)
gtk_header_bar_pack_end(GTK_HEADER_BAR(toolbar), GTK_WIDGET(toolbar->extra_button_box));
gtk_header_bar_pack_end(GTK_HEADER_BAR(toolbar), GTK_WIDGET(vol_button));
gtk_header_bar_pack_end(GTK_HEADER_BAR(toolbar), GTK_WIDGET(repeat_button));
gtk_header_bar_pack_end(GTK_HEADER_BAR(toolbar), GTK_WIDGET(shuffle_button));
gtk_header_bar_pack_end(GTK_HEADER_BAR(toolbar), GTK_WIDGET(unfull_button));
#else
gtk_tool_insert_generic_item(GTK_TOOLBAR(toolbar), GTK_WIDGET(unfull_button));
gtk_tool_insert_generic_item(GTK_TOOLBAR(toolbar), GTK_WIDGET(shuffle_button));
gtk_tool_insert_generic_item(GTK_TOOLBAR(toolbar), GTK_WIDGET(repeat_button));
gtk_tool_insert_generic_item(GTK_TOOLBAR(toolbar), GTK_WIDGET(vol_button));
gtk_tool_insert_generic_item(GTK_TOOLBAR(toolbar), GTK_WIDGET(toolbar->extra_button_box));
#endif
/* Connect signals */
g_signal_connect(G_OBJECT(prev_button), "clicked",
G_CALLBACK(prev_button_handler), toolbar);
g_signal_connect(G_OBJECT(play_button), "clicked",
G_CALLBACK(play_button_handler), toolbar);
g_signal_connect(G_OBJECT(stop_button), "clicked",
G_CALLBACK(stop_button_handler), toolbar);
g_signal_connect(G_OBJECT(next_button), "clicked",
G_CALLBACK(next_button_handler), toolbar);
g_signal_connect(G_OBJECT(unfull_button), "clicked",
G_CALLBACK(unfull_button_handler), toolbar);
/*g_signal_connect(G_OBJECT (prev_button), "key-press-event",
G_CALLBACK(panel_button_key_press), toolbar);
g_signal_connect(G_OBJECT (play_button), "key-press-event",
G_CALLBACK(panel_button_key_press), toolbar);
g_signal_connect(G_OBJECT (stop_button), "key-press-event",
G_CALLBACK(panel_button_key_press), toolbar);
g_signal_connect(G_OBJECT (next_button), "key-press-event",
G_CALLBACK(panel_button_key_press), toolbar);
g_signal_connect(G_OBJECT (next_button), "key-press-event",
G_CALLBACK(panel_button_key_press), toolbar);
g_signal_connect(G_OBJECT (unfull_button), "key-press-event",
G_CALLBACK(panel_button_key_press), toolbar);
g_signal_connect(G_OBJECT (shuffle_button), "key-press-event",
G_CALLBACK(panel_button_key_press), toolbar);
g_signal_connect(G_OBJECT (repeat_button), "key-press-event",
G_CALLBACK(panel_button_key_press), toolbar);
g_signal_connect(G_OBJECT (vol_button), "key-press-event",
G_CALLBACK(panel_button_key_press), toolbar);*/
g_signal_connect (G_OBJECT (vol_button), "value-changed",
G_CALLBACK (vol_button_value_changed), toolbar);
g_object_bind_property(preferences, "shuffle", shuffle_button, "active", binding_flags);
g_object_bind_property(preferences, "repeat", repeat_button, "active", binding_flags);
/* Fix styling */
#if GTK_CHECK_VERSION (3, 12, 0)
pragha_toolbar_set_style(toolbar,
pragha_preferences_get_gnome_style (preferences));
#endif
gtk_widget_show(GTK_WIDGET(prev_button));
gtk_widget_show(GTK_WIDGET(play_button));
gtk_widget_show(GTK_WIDGET(stop_button));
gtk_widget_show(GTK_WIDGET(next_button));
gtk_widget_show(GTK_WIDGET(shuffle_button));
gtk_widget_show(GTK_WIDGET(repeat_button));
gtk_widget_show(GTK_WIDGET(vol_button));
gtk_widget_hide(GTK_WIDGET(toolbar->unfull_button));
gtk_widget_show(GTK_WIDGET(toolbar));
g_object_unref(preferences);
}
GtkWidget *
gu_playdeck_add(gu_window_t *gw, GtkWidget *parent)
{
GtkToolItem *ti;
GtkWidget *w;
GtkWidget *l;
GtkWidget *vbox;
GtkWidget *playdeck;
playdeck_t *pd = calloc(1, sizeof(playdeck_t));
prop_courier_t *pc = gw->gw_gu->gu_pc;
playdeck = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(parent), playdeck, FALSE, TRUE, 0);
w = gtk_hseparator_new();
gtk_widget_show(w);
gtk_box_pack_start(GTK_BOX(playdeck), w, FALSE, TRUE, 0);
pd->root = gtk_hbox_new(FALSE, 1);
gtk_widget_show(pd->root);
gtk_box_pack_start(GTK_BOX(playdeck), pd->root, FALSE, TRUE, 0);
/* Playdeck album art */
w = gtk_image_new();
gtk_widget_show(w);
gtk_misc_set_alignment(GTK_MISC(w), 0, 1);
gtk_box_pack_start(GTK_BOX(pd->root), w, FALSE, TRUE, 0);
pd->sub_album_art =
prop_subscribe(0,
PROP_TAG_NAME("global", "media", "current",
"metadata", "album_art"),
PROP_TAG_CALLBACK_STRING, pd_set_albumart, w,
PROP_TAG_COURIER, pc,
NULL);
/* Middle vbox */
vbox = gtk_vbox_new(FALSE, 1);
gtk_box_pack_start(GTK_BOX(pd->root), vbox, TRUE, TRUE, 0);
/* Title of current track */
l = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(l), 0, 0);
gtk_box_pack_start(GTK_BOX(vbox), l, TRUE, TRUE, 0);
g_object_set(G_OBJECT(l),
"ellipsize", PANGO_ELLIPSIZE_END, NULL);
pd->sub_title =
prop_subscribe(0,
PROP_TAG_NAME("global", "media", "current",
"metadata", "title"),
PROP_TAG_CALLBACK_STRING, set_current_title, l,
PROP_TAG_COURIER, pc,
NULL);
/* Title of current track */
pd->trackextra = gtk_label_new("");
g_object_set(G_OBJECT(pd->trackextra),
"ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_misc_set_alignment(GTK_MISC(pd->trackextra), 0, 0);
gtk_box_pack_start(GTK_BOX(vbox), pd->trackextra, TRUE, TRUE, 0);
pd->sub_album =
prop_subscribe(0,
PROP_TAG_NAME("global", "media", "current",
"metadata", "album"),
PROP_TAG_CALLBACK_STRING, set_current_album, pd,
PROP_TAG_COURIER, pc,
NULL);
pd->sub_artist =
prop_subscribe(0,
PROP_TAG_NAME("global", "media", "current",
"metadata", "artist"),
PROP_TAG_CALLBACK_STRING, set_current_artist, pd,
PROP_TAG_COURIER, pc,
NULL);
/* The toolbar */
pd->tbar = gtk_toolbar_new();
gtk_toolbar_set_style(GTK_TOOLBAR(pd->tbar), GTK_TOOLBAR_ICONS);
gtk_box_pack_start(GTK_BOX(vbox), pd->tbar, FALSE, TRUE, 0);
/* Prev button */
pd->prev = ti = gtk_tool_button_new_from_stock(GTK_STOCK_MEDIA_PREVIOUS);
gtk_toolbar_insert(GTK_TOOLBAR(pd->tbar), ti, -1);
g_signal_connect(G_OBJECT(ti), "clicked", G_CALLBACK(prev_clicked), pd);
pd->sub_canSkipBackward =
prop_subscribe(0,
PROP_TAG_NAME("global", "media", "current",
"canSkipBackward"),
PROP_TAG_CALLBACK_INT, gu_subscription_set_sensitivity,
pd->prev,
PROP_TAG_COURIER, pc,
NULL);
/* Play / Pause */
pd->playpause = ti = gtk_tool_button_new_from_stock(GTK_STOCK_MEDIA_PLAY);
gtk_toolbar_insert(GTK_TOOLBAR(pd->tbar), ti, -1);
g_signal_connect(G_OBJECT(ti), "clicked", G_CALLBACK(playpause_clicked), pd);
pd->sub_canPause =
prop_subscribe(0,
PROP_TAG_NAME("global", "media", "current",
"canPause"),
PROP_TAG_CALLBACK_INT, gu_subscription_set_sensitivity,
pd->playpause,
PROP_TAG_COURIER, pc,
NULL);
/* Next button */
pd->next = ti = gtk_tool_button_new_from_stock(GTK_STOCK_MEDIA_NEXT);
gtk_toolbar_insert(GTK_TOOLBAR(pd->tbar), ti, -1);
g_signal_connect(G_OBJECT(ti), "clicked", G_CALLBACK(next_clicked), pd);
pd->sub_canSkipForward =
prop_subscribe(0,
PROP_TAG_NAME("global", "media", "current",
"canSkipForward"),
PROP_TAG_CALLBACK_INT, gu_subscription_set_sensitivity,
pd->next,
PROP_TAG_COURIER, pc,
NULL);
/* Separator */
ti = gtk_separator_tool_item_new();
gtk_toolbar_insert(GTK_TOOLBAR(pd->tbar), ti, -1);
/* Subscribe to playstatus */
pd->sub_playstatus =
prop_subscribe(0,
PROP_TAG_NAME("global", "media", "current", "playstatus"),
PROP_TAG_CALLBACK, update_playstatus, pd,
PROP_TAG_COURIER, pc,
NULL);
/**
* Media position
*/
pd->pos_adjust = gtk_adjustment_new(0, 0, 0, 0, 0, 0);
pd->pos_slider = gtk_hscale_new(GTK_ADJUSTMENT(pd->pos_adjust));
gtk_scale_set_value_pos (GTK_SCALE(pd->pos_slider), GTK_POS_LEFT);
g_signal_connect(G_OBJECT(pd->pos_slider), "grab-focus",
G_CALLBACK(slider_grabbed), pd);
g_signal_connect(G_OBJECT(pd->pos_slider), "change-value",
G_CALLBACK(slider_updated), pd);
g_signal_connect(G_OBJECT(pd->pos_slider), "format-value",
G_CALLBACK(slider_value_callback), pd);
ti = gtk_tool_item_new();
gtk_tool_item_set_expand(ti, TRUE);
gtk_container_add(GTK_CONTAINER(ti), pd->pos_slider);
gtk_toolbar_insert(GTK_TOOLBAR(pd->tbar), ti, -1);
/* Subscribe to current track position */
pd->sub_pos =
prop_subscribe(0,
PROP_TAG_NAME("global", "media", "current", "currenttime"),
PROP_TAG_CALLBACK_FLOAT, update_curtime, pd,
PROP_TAG_COURIER, pc,
NULL);
/* Subscribe to current track duration */
pd->sub_duration =
prop_subscribe(0,
PROP_TAG_NAME("global", "media", "current",
"metadata", "duration"),
PROP_TAG_CALLBACK_FLOAT, update_duration, pd,
PROP_TAG_COURIER, pc,
NULL);
/* Separator */
ti = gtk_separator_tool_item_new();
gtk_toolbar_insert(GTK_TOOLBAR(pd->tbar), ti, -1);
gtk_widget_show_all(vbox);
/**
* Volume control
*/
ti = gtk_tool_item_new();
pd->volume = gtk_volume_button_new();
gtk_container_add(GTK_CONTAINER(ti), pd->volume);
gtk_toolbar_insert(GTK_TOOLBAR(pd->tbar), ti, -1);
g_signal_connect(G_OBJECT(pd->volume), "value-changed",
G_CALLBACK(read_mastervol), pd);
pd->sub_volume =
prop_subscribe(0,
PROP_TAG_NAME("global", "audio", "mastervolume"),
PROP_TAG_CALLBACK_FLOAT, update_mastervol, pd,
PROP_TAG_COURIER, pc,
NULL);
gtk_widget_show_all(GTK_WIDGET(ti));
g_signal_connect(playdeck, "destroy", G_CALLBACK(playdeck_dtor), pd);
return playdeck;
}
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 void
brasero_song_control_init (BraseroSongControl *object)
{
BraseroSongControlPrivate *priv;
GtkWidget *alignment;
GtkWidget *volume;
gint volume_value;
GtkWidget *image;
GtkWidget *vbox;
GtkWidget *hbox;
gpointer value;
GstBus *bus;
priv = BRASERO_SONG_CONTROL_PRIVATE (object);
/* Pipeline */
priv->pipe = gst_element_factory_make ("playbin2", NULL);
if (priv->pipe) {
GstElement *audio_sink;
audio_sink = gst_element_factory_make ("gconfaudiosink", NULL);
if (audio_sink)
g_object_set (G_OBJECT (priv->pipe),
"audio-sink", audio_sink,
NULL);
}
else
g_warning ("Pipe creation error : can't create pipe.\n");
bus = gst_pipeline_get_bus (GST_PIPELINE (priv->pipe));
gst_bus_add_watch (bus,
(GstBusFunc) brasero_song_control_bus_messages,
object);
gst_object_unref (bus);
/* Widget itself */
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_show (vbox);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 0);
gtk_container_add (GTK_CONTAINER (object), vbox);
/* first line title */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_widget_show (hbox);
gtk_box_pack_start (GTK_BOX (vbox),
hbox,
FALSE,
FALSE,
0);
priv->header = gtk_label_new (_("No file"));
gtk_widget_show (priv->header);
gtk_label_set_use_markup (GTK_LABEL (priv->header), TRUE);
gtk_label_set_justify (GTK_LABEL (priv->header), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (priv->header), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (hbox),
priv->header,
TRUE,
TRUE,
0);
priv->size = gtk_label_new (NULL);
gtk_widget_show (priv->size);
gtk_label_set_justify (GTK_LABEL (priv->size), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (priv->size), 0.0, 0.0);
gtk_box_pack_end (GTK_BOX (hbox),
priv->size,
FALSE,
FALSE,
0);
/* second line : play, progress, volume button */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_widget_show (hbox);
gtk_box_pack_start (GTK_BOX (vbox),
hbox,
FALSE,
FALSE,
0);
alignment = gtk_alignment_new (0.0, 0.0, 0.0, 0.0);
gtk_widget_show (alignment);
priv->button = gtk_toggle_button_new ();
gtk_widget_show (priv->button);
gtk_widget_set_tooltip_text (priv->button, _("Start and stop playing"));
gtk_container_add (GTK_CONTAINER (alignment), priv->button);
gtk_box_pack_start (GTK_BOX (hbox),
alignment,
FALSE,
FALSE,
0);
image = gtk_image_new_from_stock (GTK_STOCK_MEDIA_PLAY, GTK_ICON_SIZE_BUTTON);
gtk_widget_show (image);
gtk_container_add (GTK_CONTAINER (priv->button), image);
g_signal_connect (G_OBJECT (priv->button), "clicked",
G_CALLBACK (brasero_song_control_button_clicked_cb),
object);
priv->progress = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 1, 500000000);
gtk_widget_show (priv->progress);
gtk_scale_set_digits (GTK_SCALE (priv->progress), 0);
gtk_scale_set_draw_value (GTK_SCALE (priv->progress), FALSE);
gtk_widget_set_size_request (priv->progress, 80, -1);
gtk_box_pack_start (GTK_BOX (hbox),
priv->progress,
TRUE,
TRUE,
0);
g_signal_connect (G_OBJECT (priv->progress),
"button-press-event",
G_CALLBACK (brasero_song_control_range_button_pressed_cb), object);
g_signal_connect (G_OBJECT (priv->progress),
"button-release-event",
G_CALLBACK (brasero_song_control_range_button_released_cb), object);
g_signal_connect (G_OBJECT (priv->progress),
"value-changed",
G_CALLBACK (brasero_song_control_range_value_changed),
object);
/* Set saved volume */
brasero_setting_get_value (brasero_setting_get_default (),
BRASERO_SETTING_PLAYER_VOLUME,
&value);
volume_value = GPOINTER_TO_INT (value);
volume_value = CLAMP (volume_value, 0, 100);
g_object_set (priv->pipe,
"volume", (gdouble) volume_value / 100.0,
NULL);
volume = gtk_volume_button_new ();
gtk_widget_show (volume);
gtk_box_pack_start (GTK_BOX (hbox),
volume,
FALSE,
FALSE,
0);
gtk_scale_button_set_value (GTK_SCALE_BUTTON (volume), (gdouble) volume_value / 100.0);
g_signal_connect (volume,
"value-changed",
G_CALLBACK (brasero_song_control_volume_changed_cb),
object);
gtk_alignment_set_padding (GTK_ALIGNMENT (object), 12, 0, 0, 0);
}
int music_build_element_widgets () {
int i = 0;
for (i = 0; i < 9; i++) {
label_music_info[i] = gtk_label_new(NULL);
gtk_label_set_width_chars(GTK_LABEL(label_music_info[i]), 15);
gtk_label_set_max_width_chars(GTK_LABEL(label_music_info[i]), 150);
gtk_label_set_line_wrap(GTK_LABEL(label_music_info[i]), TRUE);
}
separator_music_info = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
for (i = 0; i < 9; i++) {
label_music_lyric[i] = gtk_label_new(NULL);
gtk_label_set_max_width_chars(GTK_LABEL(label_music_lyric[i]), 305);
// gtk_label_set_line_wrap(GTK_LABEL(label_music_lyric[i]), TRUE);
}
gtk_label_set_selectable(GTK_LABEL(label_music_lyric[4]), TRUE);
gtk_label_set_use_underline (GTK_LABEL(label_music_lyric[4]), TRUE);
gtk_label_set_use_markup (GTK_LABEL(label_music_lyric[4]), TRUE);
gtk_label_set_pattern (GTK_LABEL(label_music_lyric[4]), "________");
separator_music_lyric1 = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
separator_music_lyric2 = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
button_music_start_server = gtk_button_new_with_label("启动服务器");
// set_button_music_start_server(button_music_start_server);
button_music_exit_server = gtk_button_new_with_label("关闭服务器");
// set_button_music_exit_server(button_music_exit_server);
button_music_play = gtk_button_new();
// box_music_play = button_with_image("/usr/share/raspi_remote_control/ui_images/ui_images_music/play.png");
// box_music_pause = button_with_image("/usr/share/raspi_remote_control/ui_images/ui_images_music/pause.png");
image_music_play = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/play.png");
image_music_play_light = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/play_light.png");
image_music_pause = gtk_image_new_from_file ("/usr/share/raspi_remote_control/ui_images/ui_images_music/pause.png");
image_music_pause_light = gtk_image_new_from_file ("/usr/share/raspi_remote_control/ui_images/ui_images_music/pause_light.png");
gtk_button_set_relief(GTK_BUTTON(button_music_play), GTK_RELIEF_NONE);
set_button_music_play(button_music_play);
button_music_pause = gtk_button_new_with_label("暂停");
// set_button_music_pause(button_music_pause);
button_music_unpause = gtk_button_new_with_label("取消暂停");
// set_button_music_unpause(button_music_unpause);
// button_music_stop = gtk_button_new_with_label("停止");
button_music_stop = gtk_button_new();
image_music_stop = gtk_image_new_from_file ("/usr/share/raspi_remote_control/ui_images/ui_images_music/stop.png");
image_music_stop_light = gtk_image_new_from_file ("/usr/share/raspi_remote_control/ui_images/ui_images_music/stop_light.png");
gtk_button_set_image(GTK_BUTTON(button_music_stop), image_music_stop);
gtk_button_set_relief(GTK_BUTTON(button_music_stop), GTK_RELIEF_NONE);
set_button_music_stop(button_music_stop);
// button_music_next = gtk_button_new_with_label("下一首");
button_music_next = gtk_button_new();
image_music_next = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/next.png");
image_music_next_light = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/next_light.png");
gtk_button_set_image(GTK_BUTTON(button_music_next), image_music_next);
gtk_button_set_relief(GTK_BUTTON(button_music_next), GTK_RELIEF_NONE);
set_button_music_next(button_music_next);
// button_music_pre = gtk_button_new_with_label("上一首");
button_music_pre = gtk_button_new();
image_music_pre = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/pre.png");
image_music_pre_light = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/pre_light.png");
gtk_button_set_image (GTK_BUTTON(button_music_pre), image_music_pre);
gtk_button_set_relief(GTK_BUTTON(button_music_pre), GTK_RELIEF_NONE);
set_button_music_pre(button_music_pre);
// button_music_volume_up = gtk_button_new_with_label("音量+");
// set_button_music_volume_up(button_music_volume_up);
// button_music_volume_silence = gtk_button_new_with_label("静音");
button_music_silence = gtk_button_new();
image_music_silence = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/silence.png");
image_music_silence_light = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/silence_light.png");
image_music_unsilence = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/unsilence.png");
image_music_unsilence_light = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/unsilence_light.png");
gtk_button_set_image (GTK_BUTTON(button_music_silence), image_music_silence);
gtk_button_set_relief(GTK_BUTTON(button_music_silence), GTK_RELIEF_NONE);
set_button_music_silence(button_music_silence);
button_music_volume = gtk_volume_button_new();
set_button_music_volume( button_music_volume);
button_music_reset_list = gtk_button_new_with_label("重设列表");
set_button_music_reset_list(button_music_reset_list);
// button_music_choose_path = gtk_button_new_with_label("添加路径");
// set_button_music_choose_path(button_music_choose_path);
// music_path_dialog = gtk_file_chooser_widget_new(GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
music_path_dialog = gtk_file_chooser_dialog_new ("test_title", NULL, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, "test_button_text", NULL);
button_music_choose_path = gtk_file_chooser_button_new_with_dialog (music_path_dialog);
gtk_file_chooser_button_set_title (GTK_FILE_CHOOSER_BUTTON(button_music_choose_path), "添加路径");
// gtk_file_chooser_set_select_multiple (music_path_dialog, TRUE);
button_music_delete_path = gtk_button_new_with_label("删除当前路径");
set_button_music_delete_path(button_music_delete_path);
scale_music_process = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 100, 1);
set_scale_music_process(scale_music_process);
label_music_cur_time = gtk_label_new ("--:--:--");
label_music_total_time = gtk_label_new ("--:--:--");
switch_music_autonext = gtk_switch_new ();
set_switch_music_autonext ();
label_music_autonext = gtk_label_new ("AutoNext: ");
switch_music_repeat = gtk_switch_new ();
set_switch_music_repeat ();
label_music_repeat = gtk_label_new ("Repeat: ");
switch_music_shuffle = gtk_switch_new ();
set_switch_music_shuffle ();
label_music_shuffle = gtk_label_new ("Shuffle: ");
radio_button_music_mode_shuffle = gtk_radio_button_new (NULL);
label_music_mode_shuffle = gtk_label_new ("随机:");
radio_button_music_mode_loop_list = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON (radio_button_music_mode_shuffle));
label_music_mode_loop_list = gtk_label_new ("列表循环:");
radio_button_music_mode_play_list = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON (radio_button_music_mode_shuffle));
label_music_mode_play_list = gtk_label_new ("播放列表:");
radio_button_music_mode_loop_one = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON (radio_button_music_mode_shuffle));
label_music_mode_loop_one = gtk_label_new ("单曲:");
spinner_music_mode_changing = gtk_spinner_new ();
set_radio_button_music_mode ();
store_music_dir_list = gtk_tree_store_new(dir_n_columns, G_TYPE_STRING);
tree_view_music_dir_list = gtk_tree_view_new_with_model (GTK_TREE_MODEL(store_music_dir_list));
text_renderer_music_dir_list = gtk_cell_renderer_text_new ();
column_music_dir_list = gtk_tree_view_column_new_with_attributes (NULL, text_renderer_music_dir_list, "text", dir_name, NULL);
gtk_tree_view_column_set_fixed_width(column_music_dir_list, 100);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view_music_dir_list), column_music_dir_list);
music_dir_list_sw_adj_h = gtk_adjustment_new(100, 0, 100, 1, 1, 50);
music_dir_list_sw = gtk_scrolled_window_new(NULL, music_dir_list_sw_adj_h);
gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(music_dir_list_sw), 330);
gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(music_dir_list_sw), 100);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(music_dir_list_sw), GTK_SHADOW_NONE);
// gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(music_dir_list_sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(music_dir_list_sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(music_dir_list_sw), tree_view_music_dir_list);
selection_music_dir_list = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view_music_dir_list));
set_tree_view_music_dir_list ();
store_music_list = gtk_tree_store_new(list_n_columns, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
// char file_index[BUFSIZ];
// printf("music_list_num is: %s\n", music_list_num);
// while (i < music_list_num) {
// // printf("%d: %s\n", i, music_list[i]);
// sprintf(file_index, "%d", i + 1);
// gtk_tree_store_append(store_music_list, &iter_music_list, NULL);
// gtk_tree_store_set (store_music_list, &iter_music_list, list_index, file_index, list_title, music_list[i], list_total_sec, "03:00", -1);
// i++;
// }
//
tree_view_music_list = gtk_tree_view_new_with_model (GTK_TREE_MODEL(store_music_list));
text_renderer_music_list = gtk_cell_renderer_text_new ();
column_music_list = gtk_tree_view_column_new_with_attributes (NULL, text_renderer_music_list, "text", list_index, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view_music_list), column_music_list);
gtk_tree_view_column_set_title(column_music_list, "序号");
text_renderer_music_list = gtk_cell_renderer_text_new ();
column_music_list = gtk_tree_view_column_new_with_attributes (NULL, text_renderer_music_list, "text", list_title, NULL);
gtk_tree_view_column_set_fixed_width(column_music_list, 100);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view_music_list), column_music_list);
// text_renderer_music_list = gtk_cell_renderer_text_new ();
// column_music_list = gtk_tree_view_column_new_with_attributes (NULL, text_renderer_music_list, "text", list_total_sec, NULL);
// gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view_music_list), column_music_list);
music_list_sw_adj_h = gtk_adjustment_new(100, 0, 100, 1, 1, 50);
music_list_sw = gtk_scrolled_window_new(NULL, music_list_sw_adj_h);
gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(music_list_sw), 370);
gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(music_list_sw), 200);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(music_list_sw), GTK_SHADOW_NONE);
// gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(music_list_sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(music_list_sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(music_list_sw), tree_view_music_list);
selection_music_list = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view_music_list));
set_tree_view_music_list ();
return 1;
}
static GtkWidget *
pidgin_media_add_audio_widget(PidginMedia *gtkmedia,
PurpleMediaSessionType type)
{
GtkWidget *volume_widget, *progress_parent, *volume, *progress;
double value;
if (type & PURPLE_MEDIA_SEND_AUDIO) {
value = purple_prefs_get_int(
"/purple/media/audio/volume/input");
} else if (type & PURPLE_MEDIA_RECV_AUDIO) {
value = purple_prefs_get_int(
"/purple/media/audio/volume/output");
} else
g_return_val_if_reached(NULL);
#if GTK_CHECK_VERSION(2,12,0)
/* Setup widget structure */
volume_widget = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
progress_parent = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(volume_widget),
progress_parent, TRUE, TRUE, 0);
/* Volume button */
volume = gtk_volume_button_new();
gtk_scale_button_set_value(GTK_SCALE_BUTTON(volume), value/100.0);
gtk_box_pack_end(GTK_BOX(volume_widget),
volume, FALSE, FALSE, 0);
#else
/* Setup widget structure */
volume_widget = gtk_vbox_new(FALSE, 0);
progress_parent = volume_widget;
/* Volume slider */
volume = gtk_hscale_new_with_range(0.0, 100.0, 5.0);
gtk_range_set_increments(GTK_RANGE(volume), 5.0, 25.0);
gtk_range_set_value(GTK_RANGE(volume), value);
gtk_scale_set_draw_value(GTK_SCALE(volume), FALSE);
gtk_box_pack_end(GTK_BOX(volume_widget),
volume, TRUE, FALSE, 0);
#endif
/* Volume level indicator */
progress = gtk_progress_bar_new();
gtk_widget_set_size_request(progress, 250, 10);
gtk_box_pack_end(GTK_BOX(progress_parent), progress, TRUE, FALSE, 0);
if (type & PURPLE_MEDIA_SEND_AUDIO) {
g_signal_connect (G_OBJECT(volume), "value-changed",
G_CALLBACK(pidgin_media_input_volume_changed),
gtkmedia->priv->media);
gtkmedia->priv->send_progress = progress;
} else if (type & PURPLE_MEDIA_RECV_AUDIO) {
g_signal_connect (G_OBJECT(volume), "value-changed",
G_CALLBACK(pidgin_media_output_volume_changed),
gtkmedia->priv->media);
gtkmedia->priv->recv_progress = progress;
}
gtk_widget_show_all(volume_widget);
return volume_widget;
}
/**
* Constructor
*/
GtkWidget *create_control_window(GtkWidget *parent)
{
GtkWidget *pp_button, *next_button, *prev_button, *ff_button;
GtkWidget *vol, *progress, *hbox, *play_image;
int new_volume;
/* Create window */
GtkWidget *base = gtk_event_box_new();
GtkWidget *ali = gtk_alignment_new(0.5,0,0.6,1);
g_signal_connect(G_OBJECT(base), "enter-notify-event" ,
G_CALLBACK(control_window_enter_notify_event), NULL);
g_signal_connect(G_OBJECT(base), "leave-notify-event" ,
G_CALLBACK(control_window_leave_notify_event), NULL);
/* Overwrite background drawing */
gtk_widget_set_app_paintable(base, TRUE);
g_signal_connect(G_OBJECT(base), "draw",
G_CALLBACK(expose_window), NULL);
hbox = gtk_hbox_new(FALSE, 6);
g_object_set_data(G_OBJECT(base), "hbox" , hbox);
gtk_container_add(GTK_CONTAINER(base), ali);
gtk_container_add(GTK_CONTAINER(ali), hbox);
gtk_container_set_border_width(GTK_CONTAINER(ali), 1);
/* Previous button */
ff_button = gtk_button_new();
gtk_container_add(GTK_CONTAINER(ff_button),
gtk_image_new_from_stock(GTK_STOCK_LEAVE_FULLSCREEN,
GTK_ICON_SIZE_BUTTON));
gtk_button_set_relief(GTK_BUTTON(ff_button), GTK_RELIEF_NONE);
gtk_box_pack_start(GTK_BOX(hbox), ff_button, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(ff_button), "clicked",
G_CALLBACK(control_window_leave_fullscreen), parent);
/* Volume button */
vol = (GtkWidget *)gtk_volume_button_new();
gtk_box_pack_end(GTK_BOX(hbox), vol, FALSE, FALSE, 0);
new_volume = mpd_status_get_volume(connection);
gtk_scale_button_set_value(GTK_SCALE_BUTTON(vol), new_volume/100.0);
g_object_set_data(G_OBJECT(base), "vol", vol);
g_signal_connect(G_OBJECT(vol), "value_changed",
G_CALLBACK(playlist_player_volume_changed), NULL);
/* Progress */
progress = (GtkWidget *)gmpc_progress_new();
gmpc_progress_set_hide_text(GMPC_PROGRESS(progress), FALSE);
gtk_box_pack_start(GTK_BOX(hbox), progress, TRUE, TRUE, 0);
g_object_set_data(G_OBJECT(base), "progress", progress);
g_signal_connect(G_OBJECT(progress), "seek-event", G_CALLBACK(pl3_pb_seek_event),
NULL);
/* Previous button */
prev_button = gtk_button_new();
gtk_container_add(GTK_CONTAINER(prev_button),
gtk_image_new_from_stock("gtk-media-previous", GTK_ICON_SIZE_BUTTON));
gtk_activatable_set_related_action(GTK_ACTIVATABLE(prev_button),
GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDPrevious")));
gtk_button_set_relief(GTK_BUTTON(prev_button), GTK_RELIEF_NONE);
gtk_box_pack_start(GTK_BOX(hbox), prev_button, FALSE, FALSE, 0);
/* Play button */
pp_button = gtk_button_new();
if(mpd_player_get_state(connection) == MPD_PLAYER_PLAY)
{
play_image = gtk_image_new_from_stock("gtk-media-pause", GTK_ICON_SIZE_BUTTON);
}
else
{
play_image = gtk_image_new_from_stock("gtk-media-play", GTK_ICON_SIZE_BUTTON);
}
gtk_container_add(GTK_CONTAINER(pp_button), play_image);
g_object_set_data(G_OBJECT(base), "play_image", play_image);
gtk_activatable_set_related_action(GTK_ACTIVATABLE(pp_button),
GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDPlayPause")));
gtk_button_set_relief(GTK_BUTTON(pp_button), GTK_RELIEF_NONE);
gtk_box_pack_start(GTK_BOX(hbox), pp_button, FALSE, FALSE, 0);
/* Next */
next_button = gtk_button_new();
gtk_container_add(GTK_CONTAINER(next_button),
gtk_image_new_from_stock("gtk-media-next", GTK_ICON_SIZE_BUTTON));
gtk_activatable_set_related_action(GTK_ACTIVATABLE(next_button),
GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDNext")));
gtk_button_set_relief(GTK_BUTTON(next_button), GTK_RELIEF_NONE);
gtk_box_pack_start(GTK_BOX(hbox), next_button, FALSE, FALSE, 0);
/* Change colors */
control_window_modify_colors(base);
gtk_widget_show_all(base);
timeout = g_timeout_add_seconds(5, (GSourceFunc) gtk_widget_hide, hbox);
return base;
}
