static void volume_control_button_update_value(GtkWidget *widget) {
LinphoneCall *call = (LinphoneCall *)g_object_get_data(G_OBJECT(widget), "call");
VolumeControlType type = (VolumeControlType)g_object_get_data(G_OBJECT(widget), "type");
if(type == VOLUME_CTRL_PLAYBACK) {
gtk_scale_button_set_value(GTK_SCALE_BUTTON(widget), linphone_call_get_speaker_volume_gain(call));
} else if(type == VOLUME_CTRL_RECORD) {
gtk_scale_button_set_value(GTK_SCALE_BUTTON(widget), linphone_call_get_microphone_volume_gain(call));
}
}
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);
}
static void bar_pane_gps_view_state_changed_cb(ChamplainView *view,
GParamSpec *gobject,
gpointer data)
{
PaneGPSData *pgd = data;
ChamplainState status;
gint zoom;
GString *message;
g_object_get(G_OBJECT(view), "zoom-level", &zoom, NULL);
message = g_string_new("");
g_string_printf(message, _("Zoom level %i"), zoom);
g_object_get(G_OBJECT(view), "state", &status, NULL);
if (status == CHAMPLAIN_STATE_LOADING)
{
gtk_label_set_text(GTK_LABEL(pgd->state), _("Loading map"));
}
else
{
gtk_label_set_text(GTK_LABEL(pgd->state), message->str);
}
gtk_widget_set_tooltip_text(GTK_WIDGET(pgd->slider), message->str);
gtk_scale_button_set_value(GTK_SCALE_BUTTON(pgd->slider), (gdouble)zoom);
g_string_free(message, TRUE);
}
static gboolean
gtk_scale_button_scroll (GtkWidget *widget,
GdkEventScroll *event)
{
GtkScaleButton *button;
GtkScaleButtonPrivate *priv;
GtkAdjustment *adj;
gdouble d;
button = GTK_SCALE_BUTTON (widget);
priv = button->priv;
adj = priv->adjustment;
if (event->type != GDK_SCROLL)
return FALSE;
d = gtk_scale_button_get_value (button);
if (event->direction == GDK_SCROLL_UP)
{
d += adj->step_increment;
if (d > adj->upper)
d = adj->upper;
}
else
{
d -= adj->step_increment;
if (d < adj->lower)
d = adj->lower;
}
gtk_scale_button_set_value (button, d);
return TRUE;
}
gboolean
headerbarui_volume_changed(gpointer user_data)
{
float volume = deadbeef->volume_get_min_db()-deadbeef->volume_get_db();
g_assert_false((volume>0));
gtk_scale_button_set_value( GTK_SCALE_BUTTON (volbutton), (int)-volume );
return FALSE;
}
static void
update_mastervol(void *opaque, float value)
{
playdeck_t *pd = opaque;
value = (value / 75.0) + 1;
gtk_scale_button_set_value(GTK_SCALE_BUTTON(pd->volume), value);
}
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();
}
void FullscreenVideoControllerGtk::muteChanged()
{
if (!m_volumeButton)
return;
g_signal_handler_block(m_volumeButton, m_volumeUpdateId);
gtk_scale_button_set_value(GTK_SCALE_BUTTON(m_volumeButton), m_player->muted() ? 0 : m_player->volume());
g_signal_handler_unblock(m_volumeButton, m_volumeUpdateId);
}
static void
player_av_set_volume (Player *self, gdouble vol)
{
PlayerAVPrivate *priv = PLAYER_AV (self)->priv;
if (priv->volume != vol) {
if (vol > 1.0) vol = 1.0;
if (vol < 0.0) vol = 0.0;
priv->volume = vol;
gtk_scale_button_set_value (GTK_SCALE_BUTTON (priv->fs_vol), priv->volume);
// g_signal_emit (self, signal_volume, 0, vol);
_player_emit_volume_changed (PLAYER (self), priv->volume);
}
}
static gboolean ui_volume_slider_update(gpointer data)
{
gint volume;
if (volume_slider_is_moving || data == NULL)
return TRUE;
aud_drct_get_volume_main(&volume);
if (volume == (gint) gtk_scale_button_get_value(GTK_SCALE_BUTTON(data)))
return TRUE;
g_signal_handler_block(data, volume_change_handler_id);
gtk_scale_button_set_value(GTK_SCALE_BUTTON(data), volume);
g_signal_handler_unblock(data, volume_change_handler_id);
return TRUE;
}
static gboolean
gail_scale_button_set_current_value (AtkValue *obj,
const GValue *value)
{
GtkWidget *gtk_widget;
g_return_val_if_fail (GAIL_IS_SCALE_BUTTON (obj), FALSE);
gtk_widget = GTK_ACCESSIBLE (obj)->widget;
if (gtk_widget == NULL)
return FALSE;
if (G_VALUE_HOLDS_DOUBLE (value))
{
gtk_scale_button_set_value (GTK_SCALE_BUTTON (gtk_widget), g_value_get_double (value));
return TRUE;
}
return FALSE;
}
static gboolean
cb_button_timeout (gpointer user_data)
{
GtkScaleButton *button;
GtkScaleButtonPrivate *priv;
GtkAdjustment *adj;
gdouble val;
gboolean res = TRUE;
button = GTK_SCALE_BUTTON (user_data);
priv = button->priv;
if (priv->click_id == 0)
return FALSE;
adj = priv->adjustment;
val = gtk_scale_button_get_value (button);
val += priv->direction;
if (val <= adj->lower)
{
res = FALSE;
val = adj->lower;
}
else if (val > adj->upper)
{
res = FALSE;
val = adj->upper;
}
gtk_scale_button_set_value (button, val);
if (!res)
{
g_source_remove (priv->click_id);
priv->click_id = 0;
}
return res;
}
static void
gtk_scale_button_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GtkScaleButton *button = GTK_SCALE_BUTTON (object);
switch (prop_id)
{
case PROP_ORIENTATION:
gtk_scale_button_set_orientation (button, g_value_get_enum (value));
break;
case PROP_VALUE:
gtk_scale_button_set_value (button, g_value_get_double (value));
break;
case PROP_SIZE:
{
GtkIconSize size;
size = g_value_get_enum (value);
if (button->priv->size != size)
{
button->priv->size = size;
gtk_scale_button_update_icon (button);
}
}
break;
case PROP_ADJUSTMENT:
gtk_scale_button_set_adjustment (button, g_value_get_object (value));
break;
case PROP_ICONS:
gtk_scale_button_set_icons (button,
(const gchar **)g_value_get_boxed (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
pragha_toolbar_set_volume (PraghaToolbar *toolbar, gdouble volume)
{
gtk_scale_button_set_value (GTK_SCALE_BUTTON(toolbar->vol_button), volume);
}
void
ghb_update_widget(GtkWidget *widget, const GValue *value)
{
GType type;
gchar *str;
gint ival;
gdouble dval;
g_debug("ghb_update_widget");
type = G_VALUE_TYPE(value);
if (type == ghb_array_get_type() || type == ghb_dict_get_type())
return;
if (value == NULL) return;
str = ghb_value_string(value);
ival = ghb_value_int(value);
dval = ghb_value_double(value);
type = G_OBJECT_TYPE(widget);
if (type == GTK_TYPE_ENTRY)
{
g_debug("entry");
gtk_entry_set_text((GtkEntry*)widget, str);
}
else if (type == GTK_TYPE_RADIO_BUTTON)
{
g_debug("radio button");
if (ival)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), !!ival);
}
else if (type == GTK_TYPE_CHECK_BUTTON)
{
g_debug("check button");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), ival);
}
else if (type == GTK_TYPE_TOGGLE_TOOL_BUTTON)
{
g_debug("toggle button");
gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(widget), ival);
}
else if (type == GTK_TYPE_TOGGLE_BUTTON)
{
g_debug("toggle button");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), ival);
}
else if (type == GTK_TYPE_CHECK_MENU_ITEM)
{
g_debug("check menu item");
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(widget), ival);
}
else if (type == GTK_TYPE_COMBO_BOX)
{
GtkTreeModel *store;
GtkTreeIter iter;
gchar *shortOpt;
gdouble ivalue;
gboolean foundit = FALSE;
g_debug("combo (%s)", str);
store = gtk_combo_box_get_model(GTK_COMBO_BOX(widget));
if (gtk_tree_model_get_iter_first (store, &iter))
{
do
{
gtk_tree_model_get(store, &iter, 2, &shortOpt, -1);
if (strcasecmp(shortOpt, str) == 0)
{
gtk_combo_box_set_active_iter (
GTK_COMBO_BOX(widget), &iter);
g_free(shortOpt);
foundit = TRUE;
break;
}
g_free(shortOpt);
} while (gtk_tree_model_iter_next (store, &iter));
}
if (!foundit && gtk_tree_model_get_iter_first (store, &iter))
{
do
{
gtk_tree_model_get(store, &iter, 3, &ivalue, -1);
if ((gint)ivalue == ival || ivalue == dval)
{
gtk_combo_box_set_active_iter (
GTK_COMBO_BOX(widget), &iter);
foundit = TRUE;
break;
}
} while (gtk_tree_model_iter_next (store, &iter));
}
if (!foundit)
{
if (gtk_combo_box_get_has_entry(GTK_COMBO_BOX(widget)))
{
GtkEntry *entry = GTK_ENTRY(gtk_bin_get_child(GTK_BIN(widget)));
if (entry)
{
gtk_entry_set_text (entry, str);
}
else
{
gtk_combo_box_set_active (GTK_COMBO_BOX(widget), 0);
}
}
else
{
gtk_combo_box_set_active (GTK_COMBO_BOX(widget), 0);
}
}
}
else if (type == GTK_TYPE_SPIN_BUTTON)
{
g_debug("spin (%s)", str);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget), dval);
}
else if (type == GTK_TYPE_SCALE)
{
g_debug("hscale");
gtk_range_set_value(GTK_RANGE(widget), dval);
}
else if (type == GTK_TYPE_SCALE_BUTTON)
{
g_debug("scale_button");
gtk_scale_button_set_value(GTK_SCALE_BUTTON(widget), dval);
}
else if (type == GTK_TYPE_TEXT_VIEW)
{
g_debug("textview (%s)", str);
GtkTextBuffer *buffer = gtk_text_view_get_buffer(
GTK_TEXT_VIEW(widget));
gtk_text_buffer_set_text (buffer, str, -1);
}
else if (type == GTK_TYPE_LABEL)
{
gtk_label_set_markup (GTK_LABEL(widget), str);
}
else if (type == GTK_TYPE_FILE_CHOOSER_BUTTON)
{
GtkFileChooserAction act;
act = gtk_file_chooser_get_action(GTK_FILE_CHOOSER(widget));
if (str[0] == 0)
{
// Do nothing
;
}
else if (act == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER ||
act == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
{
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER(widget), str);
}
else if (act == GTK_FILE_CHOOSER_ACTION_SAVE)
{
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER(widget), str);
}
else
{
if (g_file_test(str, G_FILE_TEST_IS_DIR))
{
gtk_file_chooser_set_current_folder(
GTK_FILE_CHOOSER(widget), str);
}
else if (g_file_test(str, G_FILE_TEST_EXISTS))
{
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER(widget), str);
}
else
{
gchar *dirname;
dirname = g_path_get_dirname(str);
gtk_file_chooser_set_current_folder(
GTK_FILE_CHOOSER(widget), dirname);
g_free(dirname);
}
}
}
else
{
g_debug("Attempt to set unknown widget type");
}
g_free(str);
}
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;
}
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;
}
GtkWidget *bar_pane_gps_new(const gchar *id, const gchar *title, const gchar *map_id,
const gint zoom, const gdouble latitude, const gdouble longitude,
gboolean expanded, gint height)
{
PaneGPSData *pgd;
GtkWidget *vbox, *frame;
GtkWidget *gpswidget, *viewport;
GtkWidget *status, *state, *progress, *slider;
ChamplainLayer *layer;
ChamplainView *view;
const gchar *slider_list[] = {GTK_STOCK_ZOOM_IN, GTK_STOCK_ZOOM_OUT, NULL};
const gchar **slider_icons = slider_list;
pgd = g_new0(PaneGPSData, 1);
pgd->pane.pane_set_fd = bar_pane_gps_set_fd;
pgd->pane.pane_notify_selection = bar_pane_gps_notify_selection;
pgd->pane.pane_event = bar_pane_gps_event;
pgd->pane.pane_write_config = bar_pane_gps_write_config;
pgd->pane.title = bar_pane_expander_title(title);
pgd->pane.id = g_strdup(id);
pgd->pane.type = PANE_GPS;
pgd->pane.expanded = expanded;
pgd->height = height;
frame = gtk_frame_new(NULL);
vbox = gtk_vbox_new(FALSE, 0);
gpswidget = gtk_champlain_embed_new();
view = gtk_champlain_embed_get_view(GTK_CHAMPLAIN_EMBED(gpswidget));
gtk_box_pack_start(GTK_BOX(vbox), gpswidget, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(frame), vbox);
status = gtk_hbox_new(FALSE,0);
slider = gtk_scale_button_new(GTK_ICON_SIZE_SMALL_TOOLBAR, 1, 17, 1, slider_icons);
gtk_widget_set_tooltip_text(slider, "Zoom");
gtk_scale_button_set_value(GTK_SCALE_BUTTON(slider), (gdouble)zoom);
progress = gtk_progress_bar_new();
state = gtk_label_new("");
gtk_label_set_justify(GTK_LABEL(state), GTK_JUSTIFY_CENTER);
gtk_box_pack_start(GTK_BOX(status), GTK_WIDGET(slider), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(status), GTK_WIDGET(state), FALSE, FALSE, 5);
gtk_box_pack_end(GTK_BOX(status), GTK_WIDGET(progress), FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(vbox),GTK_WIDGET(status), FALSE, FALSE, 0);
layer = champlain_layer_new();
champlain_view_add_layer(view, layer);
pgd->icon_layer = layer;
pgd->gps_view = CLUTTER_ACTOR(view);
pgd->widget = frame;
pgd->progress = progress;
pgd->slider = slider;
pgd->state = state;
bar_pane_gps_set_map_source(pgd, map_id);
g_object_set(G_OBJECT(view), "scroll-mode", CHAMPLAIN_SCROLL_MODE_KINETIC,
"zoom-level", zoom,
"keep-center-on-resize", TRUE,
/* This seems to be broken, https://bugzilla.gnome.org/show_bug.cgi?id=596419
"decel-rate", 1.0,
*/
"show-license", TRUE,
"zoom-on-double-click", FALSE,
"max-zoom-level", 17,
"min-zoom-level", 1,
NULL);
champlain_view_center_on(view, latitude, longitude);
pgd->centre_map_checked = TRUE;
g_object_set_data(G_OBJECT(pgd->widget), "pane_data", pgd);
g_signal_connect(G_OBJECT(pgd->widget), "destroy", G_CALLBACK(bar_pane_gps_destroy), pgd);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
gtk_widget_set_size_request(pgd->widget, -1, height);
clutter_set_motion_events_enabled(TRUE);
g_signal_connect(G_OBJECT(gpswidget), "button_press_event", G_CALLBACK(bar_pane_gps_map_keypress_cb), pgd);
g_signal_connect(pgd->gps_view, "notify::state", G_CALLBACK(bar_pane_gps_view_state_changed_cb), pgd);
g_signal_connect(pgd->gps_view, "notify::zoom-level", G_CALLBACK(bar_pane_gps_view_state_changed_cb), pgd);
g_signal_connect(G_OBJECT(slider), "value-changed", G_CALLBACK(bar_pane_gps_slider_changed_cb), pgd);
file_data_register_notify_func(bar_pane_gps_notify_cb, pgd, NOTIFY_PRIORITY_LOW);
pgd->create_markers_id = 0;
pgd->enable_markers_checked = TRUE;
pgd->centre_map_checked = TRUE;
return pgd->widget;
}
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);
}
void
gst_play_main() {
GstPad *audiopad, *videopad;
//Stop before playing
if (pipeline) {
gst_element_set_state(pipeline, GST_STATE_NULL);
gst_object_unref(GST_OBJECT(pipeline));
pipeline = NULL;
}
{
mutex = 0;
/* setup */
pipeline = gst_pipeline_new("pipeline");
bus = gst_pipeline_get_bus(GST_PIPELINE(pipeline));
gst_bus_add_signal_watch(bus);
g_signal_connect (G_OBJECT (bus), "message::state-changed", (GCallback)state_changed_cb, NULL);
g_signal_connect (G_OBJECT (bus), "message::eos", (GCallback)eos_cb, NULL);
gst_object_unref(bus);
src = gst_element_factory_make("filesrc", "source");
g_object_set(G_OBJECT(src), "location", filename, NULL);
typefind = gst_element_factory_make("typefind", "typefinder");
//g_signal_connect(typefind,"have-type",G_CALLBACK(typefound_cb),loop);
dec = gst_element_factory_make("decodebin", "decoder");
g_signal_connect(dec, "new-decoded-pad", G_CALLBACK(cb_newpad), NULL);
//myplugin = gst_element_factory_make("myplugin","MyPlugin");
audioqueue = gst_element_factory_make("queue", "audioqueue");
videoqueue = gst_element_factory_make("queue", "videoqueue");
gst_bin_add_many(GST_BIN(pipeline), src, typefind, dec, NULL);
gst_element_link_many(src, typefind, dec, NULL);
/* create audio output */
audio = gst_bin_new("audiobin");
conv = gst_element_factory_make("audioconvert", "aconv");
typefind2 = gst_element_factory_make("typefind", "typefinder2");
volume = gst_element_factory_make("volume","volume");
level = gst_element_factory_make("level","level");
//g_signal_connect(typefind2,"have-type",G_CALLBACK(typefound_cb),loop);
audiopad = gst_element_get_static_pad(audioqueue, "sink");
sink = gst_element_factory_make("alsasink", "sink");
gst_bin_add_many(GST_BIN(audio), audioqueue, conv, typefind2,volume,level, sink, NULL);
gst_element_link_many(audioqueue, conv, typefind2,volume, level,sink, NULL);
gst_element_add_pad(audio,
gst_ghost_pad_new("sink", audiopad));
gst_object_unref(audiopad);
gst_bin_add(GST_BIN(pipeline), audio);
/* create video output */
video = gst_bin_new("videobin");
caps2 =gst_caps_from_string("video/x-raw-yuv,framerate=25/1");
caps =gst_caps_from_string("video/x-raw-yuv,width=1024,height=768");
videoRate = gst_element_factory_make("videorate", "Video Rate");
capsFilter1 = gst_element_factory_make("capsfilter", "Caps Filter");
g_object_set(G_OBJECT(capsFilter1), "caps", caps2, NULL);
videoScale = gst_element_factory_make("videoscale", "Video Scale");
//g_object_set(G_OBJECT(videoScale),"add-borders","true",NULL);
capsFilter2 = gst_element_factory_make("capsfilter", "Caps Filter2");
g_object_set(G_OBJECT(capsFilter2), "caps", caps, NULL);
convVid = gst_element_factory_make("ffmpegcolorspace", "converter");
videopad = gst_element_get_static_pad(videoqueue, "sink");
videosink = gst_element_factory_make("xvimagesink", "videosink");
g_object_set(G_OBJECT(videosink),"pixel-aspect-ratio","3/4",NULL);
g_object_set(G_OBJECT(videosink),"force-aspect-ratio",TRUE,NULL);
gst_bin_add_many(GST_BIN(video), videoqueue,videoScale,capsFilter2 ,videoRate, capsFilter1, convVid, videosink, NULL);
gst_element_link_many(videoqueue, videoScale,capsFilter2 ,videoRate, capsFilter1, convVid, videosink, NULL);
gst_element_add_pad(video, gst_ghost_pad_new("sink", videopad));
gst_object_unref(videopad);
gst_bin_add(GST_BIN(pipeline), video);
/* run */
//gst_element_set_state (pipeline, GST_STATE_PLAYING);
g_print("Now playing: %s\n", filename);
if (GST_IS_X_OVERLAY (videosink))
{
gst_x_overlay_set_window_handle(GST_X_OVERLAY(videosink), GPOINTER_TO_UINT(GINT_TO_POINTER(GDK_WINDOW_XWINDOW(video_output->window))));
/* if(gst_x_overlay_set_render_rectangle(GST_X_OVERLAY(videosink),0,0,800,600))
{
gst_x_overlay_expose(GST_X_OVERLAY(videosink));
g_print("Redraw");
}*/
}
gst_element_set_state(pipeline, GST_STATE_PLAYING);
gdouble curr_vol;
g_object_get(volume,"volume",&curr_vol,NULL);
gtk_scale_button_set_value(GTK_SCALE_BUTTON(volumeButton),(curr_vol)*10);
g_timeout_add(1, refresh_ui, NULL);
}
}
int main(int argc, char *argv[])
{
struct stat buf = { 0 };
struct mntent *mnt = NULL;
FILE *fp = NULL;
gchar *uri;
gint fileindex = 1;
GError *error = NULL;
GOptionContext *context;
gint i;
gdouble volume = 100.0;
gchar *accelerator_keys;
gchar **parse;
#ifdef GTK3_ENABLED
GtkSettings *gtk_settings;
#endif
int stat_result;
#ifndef OS_WIN32
struct sigaction sa;
#endif
gboolean playiter = FALSE;
#ifdef GIO_ENABLED
GFile *file;
#endif
#ifdef ENABLE_NLS
bindtextdomain(GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
textdomain(GETTEXT_PACKAGE);
#endif
playlist = 0;
embed_window = 0;
control_id = 0;
window_x = 0;
window_y = 0;
last_window_width = 0;
last_window_height = 0;
showcontrols = 1;
showsubtitles = TRUE;
autostart = 1;
videopresent = 0;
disable_context_menu = FALSE;
dontplaynext = FALSE;
idledata = (IdleData *) g_new0(IdleData, 1);
idledata->videopresent = FALSE;
idledata->length = 0.0;
idledata->device = NULL;
idledata->cachepercent = -1.0;
selection = NULL;
path = NULL;
js_state = STATE_UNDEFINED;
control_instance = TRUE;
playlistname = NULL;
rpconsole = NULL;
subtitle = NULL;
tv_device = NULL;
tv_driver = NULL;
tv_width = 0;
tv_height = 0;
tv_fps = 0;
ok_to_play = TRUE;
alang = NULL;
slang = NULL;
metadata_codepage = NULL;
playlistname = NULL;
window_width = -1;
window_height = -1;
stored_window_width = -1;
stored_window_height = -1;
cache_size = 0;
forcecache = FALSE;
use_volume_option = FALSE;
vertical_layout = FALSE;
playlist_visible = FALSE;
disable_fullscreen = FALSE;
disable_framedrop = FALSE;
softvol = FALSE;
remember_softvol = FALSE;
volume_softvol = -1;
volume_gain = 0;
subtitlefont = NULL;
subtitle_codepage = NULL;
subtitle_color = NULL;
subtitle_outline = FALSE;
subtitle_shadow = FALSE;
subtitle_fuzziness = 0;
disable_embeddedfonts = FALSE;
quit_on_complete = FALSE;
verbose = 0;
reallyverbose = 0;
embedding_disabled = FALSE;
disable_pause_on_click = FALSE;
disable_animation = FALSE;
auto_hide_timeout = 3;
mouse_over_controls = FALSE;
use_mediakeys = TRUE;
use_defaultpl = FALSE;
mplayer_bin = NULL;
mplayer_dvd_device = NULL;
single_instance = FALSE;
disable_deinterlace = TRUE;
details_visible = FALSE;
replace_and_play = FALSE;
bring_to_front = FALSE;
keep_on_top = FALSE;
resize_on_new_media = FALSE;
use_pausing_keep_force = FALSE;
show_notification = TRUE;
show_status_icon = TRUE;
lang_group = NULL;
audio_group = NULL;
gpod_mount_point = NULL;
load_tracks_from_gpod = FALSE;
disable_cover_art_fetch = FALSE;
fullscreen = 0;
vo = NULL;
data = NULL;
max_data = NULL;
details_table = NULL;
large_buttons = FALSE;
button_size = GTK_ICON_SIZE_BUTTON;
lastguistate = -1;
non_fs_height = 0;
non_fs_width = 0;
use_hw_audio = FALSE;
start_second = 0;
play_length = 0;
save_loc = TRUE;
use_xscrnsaver = FALSE;
screensaver_disabled = FALSE;
update_control_flag = FALSE;
gchar *filename;
skip_fixed_allocation_on_show = FALSE;
skip_fixed_allocation_on_hide = FALSE;
pref_volume = -1;
use_mplayer2 = FALSE;
enable_global_menu = FALSE;
#ifndef OS_WIN32
sa.sa_handler = hup_handler;
sigemptyset(&sa.sa_mask);
#ifdef SA_RESTART
sa.sa_flags = SA_RESTART; /* Restart functions if
interrupted by handler */
#endif
#ifdef SIGINT
if (sigaction(SIGINT, &sa, NULL) == -1)
printf("SIGINT signal handler not installed\n");
#endif
#ifdef SIGHUP
if (sigaction(SIGHUP, &sa, NULL) == -1)
printf("SIGHUP signal handler not installed\n");
#endif
#ifdef SIGTERM
if (sigaction(SIGTERM, &sa, NULL) == -1)
printf("SIGTERM signal handler not installed\n");
#endif
#endif
// call g_type_init or otherwise we can crash
gtk_init(&argc, &argv);
if (!g_thread_supported())
g_thread_init(NULL);
uri = g_strdup_printf("%s/gnome-mplayer/cover_art", g_get_user_config_dir());
if (!g_file_test(uri, G_FILE_TEST_IS_DIR)) {
g_mkdir_with_parents(uri, 0775);
}
g_free(uri);
uri = g_strdup_printf("%s/gnome-mplayer/plugin", g_get_user_config_dir());
if (!g_file_test(uri, G_FILE_TEST_IS_DIR)) {
g_mkdir_with_parents(uri, 0775);
}
g_free(uri);
uri = NULL;
default_playlist = g_strdup_printf("file://%s/gnome-mplayer/default.pls", g_get_user_config_dir());
safe_to_save_default_playlist = TRUE;
gm_store = gm_pref_store_new("gnome-mplayer");
gmp_store = gm_pref_store_new("gecko-mediaplayer");
vo = gm_pref_store_get_string(gm_store, VO);
audio_device.alsa_mixer = gm_pref_store_get_string(gm_store, ALSA_MIXER);
use_hardware_codecs = gm_pref_store_get_boolean(gm_store, USE_HARDWARE_CODECS);
use_crystalhd_codecs = gm_pref_store_get_boolean(gm_store, USE_CRYSTALHD_CODECS);
osdlevel = gm_pref_store_get_int(gm_store, OSDLEVEL);
pplevel = gm_pref_store_get_int(gm_store, PPLEVEL);
#ifndef HAVE_ASOUNDLIB
volume = gm_pref_store_get_int(gm_store, VOLUME);
#endif
audio_channels = gm_pref_store_get_int(gm_store, AUDIO_CHANNELS);
use_hw_audio = gm_pref_store_get_boolean(gm_store, USE_HW_AUDIO);
fullscreen = gm_pref_store_get_boolean(gm_store, FULLSCREEN);
softvol = gm_pref_store_get_boolean(gm_store, SOFTVOL);
remember_softvol = gm_pref_store_get_boolean(gm_store, REMEMBER_SOFTVOL);
volume_softvol = gm_pref_store_get_float(gm_store, VOLUME_SOFTVOL);
volume_gain = gm_pref_store_get_int(gm_store, VOLUME_GAIN);
forcecache = gm_pref_store_get_boolean(gm_store, FORCECACHE);
vertical_layout = gm_pref_store_get_boolean(gm_store, VERTICAL);
playlist_visible = gm_pref_store_get_boolean(gm_store, SHOWPLAYLIST);
details_visible = gm_pref_store_get_boolean(gm_store, SHOWDETAILS);
show_notification = gm_pref_store_get_boolean(gm_store, SHOW_NOTIFICATION);
show_status_icon = gm_pref_store_get_boolean(gm_store, SHOW_STATUS_ICON);
showcontrols = gm_pref_store_get_boolean_with_default(gm_store, SHOW_CONTROLS, showcontrols);
restore_controls = showcontrols;
disable_deinterlace = gm_pref_store_get_boolean(gm_store, DISABLEDEINTERLACE);
disable_framedrop = gm_pref_store_get_boolean(gm_store, DISABLEFRAMEDROP);
disable_fullscreen = gm_pref_store_get_boolean(gm_store, DISABLEFULLSCREEN);
disable_context_menu = gm_pref_store_get_boolean(gm_store, DISABLECONTEXTMENU);
disable_ass = gm_pref_store_get_boolean(gm_store, DISABLEASS);
disable_embeddedfonts = gm_pref_store_get_boolean(gm_store, DISABLEEMBEDDEDFONTS);
disable_pause_on_click = gm_pref_store_get_boolean(gm_store, DISABLEPAUSEONCLICK);
disable_animation = gm_pref_store_get_boolean(gm_store, DISABLEANIMATION);
auto_hide_timeout = gm_pref_store_get_int_with_default(gm_store, AUTOHIDETIMEOUT, auto_hide_timeout);
disable_cover_art_fetch = gm_pref_store_get_boolean(gm_store, DISABLE_COVER_ART_FETCH);
use_mediakeys = gm_pref_store_get_boolean_with_default(gm_store, USE_MEDIAKEYS, use_mediakeys);
use_defaultpl = gm_pref_store_get_boolean_with_default(gm_store, USE_DEFAULTPL, use_defaultpl);
metadata_codepage = gm_pref_store_get_string(gm_store, METADATACODEPAGE);
alang = gm_pref_store_get_string(gm_store, AUDIO_LANG);
slang = gm_pref_store_get_string(gm_store, SUBTITLE_LANG);
subtitlefont = gm_pref_store_get_string(gm_store, SUBTITLEFONT);
subtitle_scale = gm_pref_store_get_float(gm_store, SUBTITLESCALE);
if (subtitle_scale < 0.25) {
subtitle_scale = 1.0;
}
subtitle_codepage = gm_pref_store_get_string(gm_store, SUBTITLECODEPAGE);
subtitle_color = gm_pref_store_get_string(gm_store, SUBTITLECOLOR);
subtitle_outline = gm_pref_store_get_boolean(gm_store, SUBTITLEOUTLINE);
subtitle_shadow = gm_pref_store_get_boolean(gm_store, SUBTITLESHADOW);
subtitle_margin = gm_pref_store_get_int(gm_store, SUBTITLE_MARGIN);
subtitle_fuzziness = gm_pref_store_get_int(gm_store, SUBTITLE_FUZZINESS);
showsubtitles = gm_pref_store_get_boolean_with_default(gm_store, SHOW_SUBTITLES, TRUE);
qt_disabled = gm_pref_store_get_boolean(gmp_store, DISABLE_QT);
real_disabled = gm_pref_store_get_boolean(gmp_store, DISABLE_REAL);
wmp_disabled = gm_pref_store_get_boolean(gmp_store, DISABLE_WMP);
dvx_disabled = gm_pref_store_get_boolean(gmp_store, DISABLE_DVX);
midi_disabled = gm_pref_store_get_boolean(gmp_store, DISABLE_MIDI);
embedding_disabled = gm_pref_store_get_boolean(gmp_store, DISABLE_EMBEDDING);
disable_embedded_scaling = gm_pref_store_get_boolean(gmp_store, DISABLE_EMBEDDED_SCALING);
if (embed_window == 0) {
single_instance = gm_pref_store_get_boolean(gm_store, SINGLE_INSTANCE);
if (single_instance) {
replace_and_play = gm_pref_store_get_boolean(gm_store, REPLACE_AND_PLAY);
bring_to_front = gm_pref_store_get_boolean(gm_store, BRING_TO_FRONT);
}
}
enable_global_menu = gm_pref_store_get_boolean(gm_store, ENABLE_GLOBAL_MENU);
if (!enable_global_menu) {
enable_global_menu = (g_getenv("UBUNTU_MENUPROXY") == NULL ? FALSE : TRUE);
}
enable_nautilus_plugin = gm_pref_store_get_boolean_with_default(gm_store, ENABLE_NAUTILUS_PLUGIN, TRUE);
mplayer_bin = gm_pref_store_get_string(gm_store, MPLAYER_BIN);
if (mplayer_bin != NULL && !g_file_test(mplayer_bin, G_FILE_TEST_EXISTS)) {
g_free(mplayer_bin);
mplayer_bin = NULL;
}
mplayer_dvd_device = gm_pref_store_get_string(gm_store, MPLAYER_DVD_DEVICE);
extraopts = gm_pref_store_get_string(gm_store, EXTRAOPTS);
use_xscrnsaver = gm_pref_store_get_boolean_with_default(gm_store, USE_XSCRNSAVER, use_xscrnsaver);
accelerator_keys = gm_pref_store_get_string(gm_store, ACCELERATOR_KEYS);
accel_keys = g_strv_new(KEY_COUNT);
accel_keys_description = g_strv_new(KEY_COUNT);
if (accelerator_keys != NULL) {
parse = g_strsplit(accelerator_keys, " ", KEY_COUNT);
for (i = 0; i < g_strv_length(parse); i++) {
accel_keys[i] = g_strdup(parse[i]);
}
g_free(accelerator_keys);
g_strfreev(parse);
}
assign_default_keys();
accel_keys_description[FILE_OPEN_LOCATION] = g_strdup(_("Open Location"));
accel_keys_description[EDIT_SCREENSHOT] = g_strdup(_("Take Screenshot"));
accel_keys_description[EDIT_PREFERENCES] = g_strdup(_("Preferences"));
accel_keys_description[VIEW_PLAYLIST] = g_strdup(_("Playlist"));
accel_keys_description[VIEW_INFO] = g_strdup(_("Media Info"));
accel_keys_description[VIEW_DETAILS] = g_strdup(_("Details"));
accel_keys_description[VIEW_METER] = g_strdup(_("Audio Meter"));
accel_keys_description[VIEW_FULLSCREEN] = g_strdup(_("Full Screen"));
accel_keys_description[VIEW_ASPECT] = g_strdup(_("Aspect"));
accel_keys_description[VIEW_SUBTITLES] = g_strdup(_("Subtitles"));
accel_keys_description[VIEW_DECREASE_SIZE] = g_strdup(_("Decrease Subtitle Size"));
accel_keys_description[VIEW_INCREASE_SIZE] = g_strdup(_("Increase Subtitle Size"));
accel_keys_description[VIEW_ANGLE] = g_strdup(_("Switch Angle"));
accel_keys_description[VIEW_CONTROLS] = g_strdup(_("Controls"));
remember_loc = gm_pref_store_get_boolean(gm_store, REMEMBER_LOC);
loc_window_x = gm_pref_store_get_int(gm_store, WINDOW_X);
loc_window_y = gm_pref_store_get_int(gm_store, WINDOW_Y);
loc_window_height = gm_pref_store_get_int(gm_store, WINDOW_HEIGHT);
loc_window_width = gm_pref_store_get_int(gm_store, WINDOW_WIDTH);
loc_panel_position = gm_pref_store_get_int(gm_store, PANEL_POSITION);
keep_on_top = gm_pref_store_get_boolean(gm_store, KEEP_ON_TOP);
resize_on_new_media = gm_pref_store_get_boolean(gm_store, RESIZE_ON_NEW_MEDIA);
mouse_wheel_changes_volume = gm_pref_store_get_boolean_with_default(gm_store, MOUSE_WHEEL_CHANGES_VOLUME, FALSE);
audio_device_name = gm_pref_store_get_string(gm_store, AUDIO_DEVICE_NAME);
audio_device.description = g_strdup(audio_device_name);
context = g_option_context_new(_("[FILES...] - GNOME Media player based on MPlayer"));
#ifdef GTK2_12_ENABLED
g_option_context_set_translation_domain(context, "UTF-8");
g_option_context_set_translate_func(context, (GTranslateFunc) gettext, NULL, NULL);
#endif
g_option_context_add_main_entries(context, entries, GETTEXT_PACKAGE);
g_option_context_add_group(context, gtk_get_option_group(TRUE));
g_option_context_parse(context, &argc, &argv, &error);
g_option_context_free(context);
if (new_instance)
single_instance = FALSE;
if (verbose == 0)
verbose = gm_pref_store_get_int(gm_store, VERBOSE);
if (reallyverbose)
verbose = 2;
if (verbose) {
printf(_("GNOME MPlayer v%s\n"), VERSION);
printf(_("gmtk v%s\n"), gmtk_version());
}
if (cache_size == 0)
cache_size = gm_pref_store_get_int(gm_store, CACHE_SIZE);
if (cache_size == 0)
cache_size = 2000;
plugin_audio_cache_size = gm_pref_store_get_int(gm_store, PLUGIN_AUDIO_CACHE_SIZE);
if (plugin_audio_cache_size == 0)
plugin_audio_cache_size = 2000;
plugin_video_cache_size = gm_pref_store_get_int(gm_store, PLUGIN_VIDEO_CACHE_SIZE);
if (plugin_video_cache_size == 0)
plugin_video_cache_size = 2000;
if (control_id != 0)
cache_size = plugin_video_cache_size;
gm_pref_store_free(gm_store);
gm_pref_store_free(gmp_store);
if (verbose && embed_window) {
printf("embedded in window id 0x%x\n", embed_window);
}
if (verbose && single_instance) {
printf("Running in single instance mode\n");
}
#ifdef GIO_ENABLED
if (verbose) {
printf("Running with GIO support\n");
}
#endif
#ifdef ENABLE_PANSCAN
if (verbose) {
printf("Running with panscan enabled (mplayer svn r29565 or higher required)\n");
}
#endif
if (verbose) {
printf("Using audio device: %s\n", audio_device_name);
}
if (softvol) {
if (verbose)
printf("Using MPlayer Software Volume control\n");
if (remember_softvol && volume_softvol != -1) {
if (verbose)
printf("Using last volume of %f%%\n", volume_softvol * 100.0);
volume = (gdouble) volume_softvol *100.0;
} else {
volume = 100.0;
}
}
if (large_buttons)
button_size = GTK_ICON_SIZE_DIALOG;
if (playlist_visible && control_id != 0)
playlist_visible = FALSE;
if (error != NULL) {
printf("%s\n", error->message);
printf(_("Run 'gnome-mplayer --help' to see a full list of available command line options.\n"));
return 1;
}
// if (verbose)
// printf("Threading support enabled = %i\n",g_thread_supported());
if (rpconsole == NULL)
rpconsole = g_strdup("NONE");
// setup playliststore
playliststore =
gtk_list_store_new(N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_FLOAT, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT,
G_TYPE_FLOAT, G_TYPE_FLOAT, G_TYPE_BOOLEAN);
// only use dark theme if not embedded, otherwise use the default theme
#ifdef GTK3_ENABLED
if (embed_window <= 0) {
gtk_settings = gtk_settings_get_default();
g_object_set(G_OBJECT(gtk_settings), "gtk-application-prefer-dark-theme", TRUE, NULL);
}
#endif
create_window(embed_window);
autopause = FALSE;
#ifdef GIO_ENABLED
idledata->caching = g_mutex_new();
idledata->caching_complete = g_cond_new();
#endif
retrieve_metadata_pool = g_thread_pool_new(retrieve_metadata, NULL, 10, TRUE, NULL);
if (argv[fileindex] != NULL) {
#ifdef GIO_ENABLED
file = g_file_new_for_commandline_arg(argv[fileindex]);
stat_result = -1;
if (file != NULL) {
GError *error = NULL;
GFileInfo *file_info = g_file_query_info(file, G_FILE_ATTRIBUTE_UNIX_MODE, 0, NULL, &error);
if (file_info != NULL) {
buf.st_mode = g_file_info_get_attribute_uint32(file_info, G_FILE_ATTRIBUTE_UNIX_MODE);
stat_result = 0;
g_object_unref(file_info);
}
if (error != NULL) {
if (verbose)
printf("failed to get mode: %s\n", error->message);
g_error_free(error);
}
g_object_unref(file);
}
#else
stat_result = g_stat(argv[fileindex], &buf);
#endif
if (verbose) {
printf("opening %s\n", argv[fileindex]);
printf("stat_result = %i\n", stat_result);
printf("is block %i\n", S_ISBLK(buf.st_mode));
printf("is character %i\n", S_ISCHR(buf.st_mode));
printf("is reg %i\n", S_ISREG(buf.st_mode));
printf("is dir %i\n", S_ISDIR(buf.st_mode));
printf("playlist %i\n", playlist);
printf("embedded in window id 0x%x\n", embed_window);
}
if (stat_result == 0 && S_ISBLK(buf.st_mode)) {
// might have a block device, so could be a DVD
#ifdef HAVE_SYS_MOUNT_H
fp = setmntent("/etc/mtab", "r");
do {
mnt = getmntent(fp);
if (mnt)
printf("%s is at %s\n", mnt->mnt_fsname, mnt->mnt_dir);
if (argv[fileindex] != NULL && mnt && mnt->mnt_fsname != NULL) {
if (strcmp(argv[fileindex], mnt->mnt_fsname) == 0)
break;
}
}
while (mnt);
endmntent(fp);
#endif
if (mnt && mnt->mnt_dir) {
printf("%s is mounted on %s\n", argv[fileindex], mnt->mnt_dir);
uri = g_strdup_printf("%s/VIDEO_TS", mnt->mnt_dir);
stat(uri, &buf);
g_free(uri);
if (S_ISDIR(buf.st_mode)) {
add_item_to_playlist("dvdnav://", 0);
gtk_tree_model_get_iter_first(GTK_TREE_MODEL(playliststore), &iter);
gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_DVD);
//play_iter(&iter, 0);
playiter = TRUE;
} else {
uri = g_strdup_printf("file://%s", mnt->mnt_dir);
create_folder_progress_window();
add_folder_to_playlist_callback(uri, NULL);
g_free(uri);
destroy_folder_progress_window();
if (random_order) {
gtk_tree_model_get_iter_first(GTK_TREE_MODEL(playliststore), &iter);
randomize_playlist(playliststore);
}
if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(playliststore), &iter)) {
// play_iter(&iter, 0);
playiter = TRUE;
}
}
} else {
parse_cdda("cdda://");
if (random_order) {
gtk_tree_model_get_iter_first(GTK_TREE_MODEL(playliststore), &iter);
randomize_playlist(playliststore);
}
//play_file("cdda://", playlist);
if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(playliststore), &iter)) {
// play_iter(&iter, 0);
playiter = TRUE;
}
}
} else if (stat_result == 0 && S_ISDIR(buf.st_mode)) {
uri = g_strdup_printf("%s/VIDEO_TS", argv[fileindex]);
stat_result = g_stat(uri, &buf);
g_free(uri);
if (stat_result == 0 && S_ISDIR(buf.st_mode)) {
add_item_to_playlist("dvdnav://", 0);
gtk_tree_model_get_iter_first(GTK_TREE_MODEL(playliststore), &iter);
gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_DVD);
//play_iter(&iter, 0);
playiter = TRUE;
} else {
create_folder_progress_window();
uri = NULL;
#ifdef GIO_ENABLED
file = g_file_new_for_commandline_arg(argv[fileindex]);
if (file != NULL) {
uri = g_file_get_uri(file);
g_object_unref(file);
}
#else
uri = g_filename_to_uri(argv[fileindex], NULL, NULL);
#endif
add_folder_to_playlist_callback(uri, NULL);
g_free(uri);
destroy_folder_progress_window();
if (random_order) {
gtk_tree_model_get_iter_first(GTK_TREE_MODEL(playliststore), &iter);
randomize_playlist(playliststore);
}
if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(playliststore), &iter)) {
//play_iter(&iter, 0);
playiter = TRUE;
}
}
} else {
// local file
// detect if playlist here, so even if not specified it can be picked up
i = fileindex;
while (argv[i] != NULL) {
if (verbose > 1)
printf("Argument %i is %s\n", i, argv[i]);
#ifdef GIO_ENABLED
if (!device_name(argv[i])) {
file = g_file_new_for_commandline_arg(argv[i]);
if (file != NULL) {
uri = g_file_get_uri(file);
g_object_unref(file);
} else {
uri = g_strdup(argv[i]);
}
} else {
uri = g_strdup(argv[i]);
}
#else
uri = g_filename_to_uri(argv[i], NULL, NULL);
#endif
if (uri != NULL) {
if (playlist == 0)
playlist = detect_playlist(uri);
if (!playlist) {
add_item_to_playlist(uri, playlist);
} else {
if (!parse_playlist(uri)) {
add_item_to_playlist(uri, playlist);
}
}
g_free(uri);
}
i++;
}
if (random_order) {
gtk_tree_model_get_iter_first(GTK_TREE_MODEL(playliststore), &iter);
randomize_playlist(playliststore);
}
if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(playliststore), &iter)) {
// play_iter(&iter, 0);
playiter = TRUE;
}
}
}
#ifdef HAVE_GPOD
if (load_tracks_from_gpod) {
gpod_mount_point = find_gpod_mount_point();
printf("mount point is %s\n", gpod_mount_point);
if (gpod_mount_point != NULL) {
gpod_load_tracks(gpod_mount_point);
} else {
printf("Unable to find gpod mount point\n");
}
}
#endif
gm_audio_update_device(&audio_device);
gm_audio_get_volume(&audio_device);
gm_audio_set_server_volume_update_callback(&audio_device, set_volume);
set_media_player_attributes(media);
if (!softvol) {
if (pref_volume != -1) {
audio_device.volume = (gdouble) pref_volume / 100.0;
}
if (verbose)
printf("The volume on '%s' is %f\n", audio_device.description, audio_device.volume);
volume = audio_device.volume * 100;
} else {
audio_device.volume = volume / 100.0;
}
#ifdef GTK2_12_ENABLED
gtk_scale_button_set_value(GTK_SCALE_BUTTON(vol_slider), audio_device.volume);
#else
gtk_range_set_value(GTK_RANGE(vol_slider), audio_device.volume);
#endif
use_volume_option = detect_volume_option();
dbus_hookup(embed_window, control_id);
show_window(embed_window);
if (playiter)
play_iter(&iter, 0);
if (argv[fileindex] == NULL && embed_window == 0) {
// When running as apple.com external player, don't load the default playlist
if (control_id == 0) {
use_remember_loc = remember_loc;
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem_view_playlist), playlist_visible);
} else {
remember_loc = FALSE;
use_remember_loc = FALSE;
// prevents saving of a playlist with one item on it
use_defaultpl = FALSE;
// don't save the loc when launched with a single file
save_loc = FALSE;
}
} else {
// prevents saving of a playlist with one item on it
use_defaultpl = FALSE;
// don't save the loc when launched with a single file
save_loc = FALSE;
}
if (single_instance && embed_window == 0) {
if (control_id == 0) {
use_remember_loc = remember_loc;
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem_view_playlist), playlist_visible);
}
}
if (embed_window == 0) {
if (remember_loc) {
gtk_window_move(GTK_WINDOW(window), loc_window_x, loc_window_y);
g_idle_add(set_pane_position, NULL);
}
}
safe_to_save_default_playlist = FALSE;
if (use_defaultpl) {
create_folder_progress_window();
parse_playlist(default_playlist);
destroy_folder_progress_window();
}
safe_to_save_default_playlist = TRUE;
gtk_main();
return 0;
}
void control_window_status_update(MpdObj * mi, ChangedStatusType what, GtkWidget *base)
{
GtkWidget *volume_button, *progress, *play_image;
/* Bail out of base == NULL */
if(base == NULL) return;
/* Get the different subwidgets from the parent */
volume_button = g_object_get_data(G_OBJECT(base), "vol");
progress = g_object_get_data(G_OBJECT(base), "progress");
play_image = g_object_get_data(G_OBJECT(base), "play_image");
if (what & MPD_CST_STATE)
{
int state = mpd_player_get_state(mi);
switch (state)
{
case MPD_PLAYER_PLAY:
gtk_image_set_from_stock(GTK_IMAGE(play_image),
"gtk-media-pause", GTK_ICON_SIZE_BUTTON);
break;
case MPD_PLAYER_PAUSE:
gtk_image_set_from_stock(GTK_IMAGE(play_image),
"gtk-media-play", GTK_ICON_SIZE_BUTTON);
break;
default:
gtk_image_set_from_stock(GTK_IMAGE(play_image),
"gtk-media-play", GTK_ICON_SIZE_BUTTON);
/* Make sure it's reset correctly */
gmpc_progress_set_time(GMPC_PROGRESS(progress), 0, 0);
}
}
if (what & MPD_CST_ELAPSED_TIME)
{
if (mpd_check_connected(connection))
{
int totalTime = mpd_status_get_total_song_time(connection);
int elapsedTime = mpd_status_get_elapsed_song_time(connection);
gmpc_progress_set_time(GMPC_PROGRESS(progress), totalTime, elapsedTime);
} else
{
gmpc_progress_set_time(GMPC_PROGRESS(progress), 0, 0);
}
}
if (what & MPD_CST_VOLUME)
{
int volume = gtk_scale_button_get_value(GTK_SCALE_BUTTON(volume_button))*100;
int new_volume = mpd_status_get_volume(connection);
if (new_volume >= 0 &&
mpd_server_check_command_allowed(connection, "setvol") ==
MPD_SERVER_COMMAND_ALLOWED
)
{
gtk_widget_set_sensitive(volume_button, TRUE);
/* don't do anything if nothing is changed */
if (new_volume != volume)
{
gtk_scale_button_set_value(GTK_SCALE_BUTTON(volume_button), new_volume/100.0);
}
} else
{
gtk_widget_set_sensitive(volume_button, FALSE);
}
}
}
Player*
player_av_new (Shell *shell)
{
PlayerAV *self = g_object_new (PLAYER_AV_TYPE, NULL);
self->priv->shell = g_object_ref (shell);
self->priv->em_da = gtk_drawing_area_new ();
GtkBuilder *builder = shell_get_builder (self->priv->shell);
GError *err = NULL;
gtk_builder_add_from_file (builder, SHARE_DIR "/ui/player.ui", &err);
if (err) {
g_print ("ERROR ADDING: %s", err->message);
g_error_free (err);
}
// Get objects from gtkbuilder
self->priv->fs_win = GTK_WIDGET (gtk_builder_get_object (builder, "player_win"));
self->priv->fs_da = GTK_WIDGET (gtk_builder_get_object (builder, "player_da"));
self->priv->fs_title = GTK_WIDGET (gtk_builder_get_object (builder, "player_title"));
self->priv->fs_scale = GTK_WIDGET (gtk_builder_get_object (builder, "player_scale"));
self->priv->fs_vol = GTK_WIDGET (gtk_builder_get_object (builder, "player_vol"));
self->priv->fs_time = GTK_WIDGET (gtk_builder_get_object (builder, "player_time"));
self->priv->fs_prev = GTK_WIDGET (gtk_builder_get_object (builder, "player_prev"));
self->priv->fs_play = GTK_WIDGET (gtk_builder_get_object (builder, "player_play"));
self->priv->fs_pause = GTK_WIDGET (gtk_builder_get_object (builder, "player_pause"));
self->priv->fs_next = GTK_WIDGET (gtk_builder_get_object (builder, "player_next"));
self->priv->fs_vbox = GTK_WIDGET (gtk_builder_get_object (builder, "player_vbox"));
self->priv->fs_hbox = GTK_WIDGET (gtk_builder_get_object (builder, "player_hbox"));
// Set initial state
gtk_scale_button_set_value (GTK_SCALE_BUTTON (self->priv->fs_vol), self->priv->volume);
gtk_widget_add_events (self->priv->em_da, GDK_BUTTON_PRESS_MASK);
gtk_widget_add_events (self->priv->fs_da, GDK_BUTTON_PRESS_MASK);
g_signal_connect (self->priv->em_da, "button-press-event",
G_CALLBACK (player_av_button_press), self);
g_signal_connect (self->priv->fs_da, "button-press-event",
G_CALLBACK (player_av_button_press), self);
g_signal_connect (self->priv->em_da, "size-allocate", G_CALLBACK (on_alloc_event), self);
g_signal_connect (self->priv->fs_da, "size-allocate", G_CALLBACK (on_alloc_event), self);
g_signal_connect (self->priv->em_da, "expose-event", G_CALLBACK (handle_expose_cb), self);
g_signal_connect (self->priv->fs_da, "expose-event", G_CALLBACK (handle_expose_cb), self);
g_signal_connect (self->priv->fs_prev, "clicked", G_CALLBACK (on_control_prev), self);
g_signal_connect (self->priv->fs_play, "clicked", G_CALLBACK (on_control_play), self);
g_signal_connect (self->priv->fs_pause, "clicked", G_CALLBACK (on_control_pause), self);
g_signal_connect (self->priv->fs_next, "clicked", G_CALLBACK (on_control_next), self);
g_signal_connect (self->priv->fs_vol, "value-changed", G_CALLBACK (on_vol_changed), self);
g_signal_connect (self->priv->fs_scale, "change-value", G_CALLBACK (on_pos_change_value), self);
shell_add_widget (self->priv->shell, self->priv->em_da, "Now Playing", NULL);
gtk_widget_show_all (self->priv->em_da);
return PLAYER (self);
}
int main(int argc, char *argv[])
{
printf("%s \nPlease report any bug to %s\n", PACKAGE_STRING, PACKAGE_BUGREPORT);
//printf("number of arg = %d, argv = %s\n", argc, argv[1]);
/*printf("argc = %d\n", argc);
if (argv[1] != NULL) {
if (strstr (argv[1],"debug") != NULL) {
debug = TRUE;
printf("debug = TRUE\n");
}
}
DEBUG("debug is true\n");*/
gchar *filename;
int i = 0;
gint initialWindowHeight = 170;
guint timeoutEvent, intervalDisplaySpectro;
GtkWidget *pVBox[4], *pHBox[13], *menuBar, *menu, *submenu, *menuItem, *submenuItem, *button, *frame, *image, *label, *widget;
GdkColor color;
Spectrum3dGui spectrum3dGui;
GSList *radio_menu_group;
GError **error;
#if defined (GTKGLEXT3) || defined (GTKGLEXT1)
GdkGLConfig *glconfig;
#endif
gst_init (NULL, NULL);
gtk_init (&argc, &argv);
get_saved_values();
intervalDisplaySpectro = (guint)spectrum3d.interval_display;
#if defined (GTKGLEXT3) || defined (GTKGLEXT1)
gtk_gl_init(NULL, NULL);
glconfig = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGB |
GDK_GL_MODE_DEPTH |
GDK_GL_MODE_DOUBLE);
if (glconfig == NULL)
{
g_print ("\n*** Cannot find the double-buffered visual.\n");
g_print ("\n*** Trying single-buffered visual.\n");
/* Try single-buffered visual */
glconfig = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGB |
GDK_GL_MODE_DEPTH);
if (glconfig == NULL)
{
g_print ("*** No appropriate OpenGL-capable visual found.\n");
exit (1);
}
}
#endif
initGstreamer();
init_audio_values();
init_display_values(&spectrum3dGui);
spectrum3dGui.mainWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request (spectrum3dGui.mainWindow, 700, initialWindowHeight);
gtk_widget_realize(spectrum3dGui.mainWindow);
gtk_window_set_title(GTK_WINDOW(spectrum3dGui.mainWindow), PACKAGE_NAME);
filename = g_build_filename (G_DIR_SEPARATOR_S, DATADIR, "icons", "spectrum3d.png", NULL);
gtk_window_set_icon(GTK_WINDOW(spectrum3dGui.mainWindow), gdk_pixbuf_new_from_file (filename, error));
g_signal_connect (G_OBJECT (spectrum3dGui.mainWindow), "destroy", G_CALLBACK (quit_spectrum3d), NULL);
#ifdef GTK3
gtk_container_set_reallocate_redraws (GTK_CONTAINER (spectrum3dGui.mainWindow), TRUE);
#endif
#ifdef GTK3
for (i = 0; i < 4; i++) {
pVBox[i] = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
}
pHBox[0] = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
for (i = 1; i < 12; i++) {
pHBox[i] = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
}
pHBox[12] = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
#elif defined GTK2
for (i = 0; i < 4; i++) {
pVBox[i] = gtk_vbox_new(FALSE, 0);
}
pHBox[0] = gtk_hbox_new(TRUE, 0);
for (i = 1; i < 12; i++) {
pHBox[i] = gtk_hbox_new(FALSE, 0);
}
pHBox[12] = gtk_hbox_new(TRUE, 0);
#endif
gtk_container_add(GTK_CONTAINER(spectrum3dGui.mainWindow), pVBox[1]);
gtk_box_pack_start(GTK_BOX(pVBox[1]), pHBox[0], FALSE, FALSE, 0);
/* Menu */
menuBar = gtk_menu_bar_new();
menu = gtk_menu_new(); // 'Quit' submenu
menuItem = gtk_menu_item_new_with_label("Quit");
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem);
g_signal_connect(G_OBJECT(menuItem), "activate", G_CALLBACK(gtk_main_quit), NULL);
menuItem = gtk_menu_item_new_with_label("Quit");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuItem), menu);
gtk_menu_shell_append(GTK_MENU_SHELL(menuBar), menuItem);
menu = gtk_menu_new(); // 'Edit' submenu
menuItem = gtk_menu_item_new_with_label("Preferences");
g_signal_connect(G_OBJECT(menuItem), "activate", G_CALLBACK(onPreferences), &spectrum3dGui);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem);
menuItem = gtk_menu_item_new_with_label("Edit");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuItem), menu);
gtk_menu_shell_append(GTK_MENU_SHELL(menuBar), menuItem);
menu = gtk_menu_new(); // 'Sound' submenu
menuItem = gtk_menu_item_new_with_label("Sound");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuItem), menu);
gtk_menu_shell_append(GTK_MENU_SHELL(menuBar), menuItem);
submenu = gtk_menu_new();// 'Play test sound' sub-submenu
spectrum3dGui.checkMenuTestSound = gtk_check_menu_item_new_with_label("Test Sound");
gtk_menu_shell_append(GTK_MENU_SHELL(menu), spectrum3dGui.checkMenuTestSound);
g_signal_connect(G_OBJECT(spectrum3dGui.checkMenuTestSound), "activate", G_CALLBACK(menu_check_test_sound), &spectrum3dGui);
menu = gtk_menu_new(); // 'View' submenu
menuItem = gtk_menu_item_new_with_label("View");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuItem), menu);
gtk_menu_shell_append(GTK_MENU_SHELL(menuBar), menuItem);
submenu = gtk_menu_new();// 'viewType' sub-submenu
menuItem = gtk_menu_item_new_with_label("Perspective");
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuItem), submenu);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem);
spectrum3dGui.radio3D = gtk_radio_menu_item_new_with_label(NULL, "3D (D)");
radio_menu_group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(spectrum3dGui.radio3D));
g_signal_connect(G_OBJECT(spectrum3dGui.radio3D), "toggled", G_CALLBACK(change_perspective), spectrum3dGui.radio3D);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.radio3D);
spectrum3dGui.radio3Dflat = gtk_radio_menu_item_new_with_label(radio_menu_group, "3D flat (F)");
radio_menu_group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(spectrum3dGui.radio3Dflat));
g_signal_connect(G_OBJECT(spectrum3dGui.radio3Dflat), "toggled", G_CALLBACK(change_perspective), spectrum3dGui.radio3Dflat);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.radio3Dflat);
spectrum3dGui.radio2D = gtk_radio_menu_item_new_with_label(radio_menu_group, "2D (D)");
radio_menu_group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(spectrum3dGui.radio2D));
g_signal_connect(G_OBJECT(spectrum3dGui.radio2D), "toggled", G_CALLBACK(change_perspective), spectrum3dGui.radio2D);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.radio2D);
submenu = gtk_menu_new();// 'Scale' sub-submenu
menuItem = gtk_menu_item_new_with_label("Scale");
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuItem), submenu);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem);
spectrum3dGui.checkMenuText = gtk_check_menu_item_new_with_label("Text (T)");
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(spectrum3dGui.checkMenuText), TRUE);
g_signal_connect(G_OBJECT(spectrum3dGui.checkMenuText), "activate", G_CALLBACK(check_menu_text), &spectrum3dGui);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.checkMenuText);
spectrum3dGui.checkMenuLines = gtk_check_menu_item_new_with_label("Lines (L)");
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(spectrum3dGui.checkMenuLines), TRUE);
g_signal_connect(G_OBJECT(spectrum3dGui.checkMenuLines), "activate", G_CALLBACK(check_menu_lines), &spectrum3dGui);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.checkMenuLines);
spectrum3dGui.checkMenuPointer = gtk_check_menu_item_new_with_label("Pointer (P)");
g_signal_connect(G_OBJECT(spectrum3dGui.checkMenuPointer), "activate", G_CALLBACK(check_menu_pointer), &spectrum3dGui);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.checkMenuPointer);
submenu = gtk_menu_new();// 'Change/reset view' sub-submenu
menuItem = gtk_menu_item_new_with_label("Change/reset view");
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuItem), submenu);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem);
spectrum3dGui.reset = gtk_menu_item_new_with_label("Reset view (R)");
gtk_widget_set_tooltip_text (spectrum3dGui.reset, "Reset the view as if Spectrum3d was just started");
g_signal_connect(G_OBJECT(spectrum3dGui.reset), "activate", G_CALLBACK(reset_view), spectrum3dGui.reset);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.reset);
spectrum3dGui.front = gtk_menu_item_new_with_label("Front view (O)");
gtk_widget_set_tooltip_text (spectrum3dGui.front, "2D view showing frequency versus intensity of the sound; shows a snapshot of the harmonics at a given time");
g_signal_connect(G_OBJECT(spectrum3dGui.front), "activate", G_CALLBACK(front_view), spectrum3dGui.front);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.front);
submenuItem = gtk_menu_item_new_with_label("Preset view");
gtk_widget_set_tooltip_text (submenuItem, "Set the view with the chosen preset values");
g_signal_connect(G_OBJECT(submenuItem), "activate", G_CALLBACK(set_view_from_preset), submenuItem);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), submenuItem);
menu = gtk_menu_new(); // 'Help...' submenu
menuItem = gtk_menu_item_new_with_label("Shortcuts");
g_signal_connect(G_OBJECT(menuItem), "activate", G_CALLBACK(onShortcuts), (GtkWidget*) spectrum3dGui.mainWindow);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem);
#ifdef HAVE_LIBGEIS
menuItem = gtk_menu_item_new_with_label("Gestures Shortcuts");
g_signal_connect(G_OBJECT(menuItem), "activate", G_CALLBACK(onGesturesShortcuts), (GtkWidget*) spectrum3dGui.mainWindow);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem);
#endif
menuItem = gtk_menu_item_new_with_label("About...");
g_signal_connect(G_OBJECT(menuItem), "activate", G_CALLBACK(onAbout), (GtkWidget*) spectrum3dGui.mainWindow);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem);
menuItem = gtk_menu_item_new_with_label("Quick start");
g_signal_connect(G_OBJECT(menuItem), "activate", G_CALLBACK(onQuickStart), (GtkWidget*) spectrum3dGui.mainWindow);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem);
menuItem = gtk_menu_item_new_with_label("Help");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuItem), menu);
gtk_menu_shell_append(GTK_MENU_SHELL(menuBar), menuItem);
gtk_box_pack_start(GTK_BOX(pHBox[0]), menuBar, FALSE, TRUE, 0);
/* SourceButtons to set type of source (none, audio file, microphone) */
spectrum3dGui.stop = gtk_button_new();
filename = g_build_filename (G_DIR_SEPARATOR_S, DATADIR, "icons", "stop.png", NULL);
image = gtk_image_new_from_file(filename);
gtk_button_set_image(GTK_BUTTON(spectrum3dGui.stop),image);
gdk_color_parse ("gold",&color);
gtk_widget_set_name(spectrum3dGui.stop, "stop");
gtk_widget_modify_bg(GTK_WIDGET(spectrum3dGui.stop), GTK_STATE_NORMAL, &color);
gtk_widget_modify_bg(GTK_WIDGET(spectrum3dGui.stop), GTK_STATE_PRELIGHT, &color);
gtk_widget_set_tooltip_text (spectrum3dGui.stop, "Stop playing everything; no source of playing");
gtk_box_pack_start(GTK_BOX(pVBox[1]), pHBox[1], FALSE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(pHBox[1]), spectrum3dGui.stop, FALSE, TRUE, 2);
g_signal_connect(G_OBJECT(spectrum3dGui.stop), "clicked", G_CALLBACK(change_source_button), &spectrum3dGui);
filename = g_build_filename (G_DIR_SEPARATOR_S, DATADIR, "icons", "microphone_grey.png", NULL);
image = gtk_image_new_from_file(filename);
spectrum3dGui.mic = gtk_button_new();
gtk_button_set_image (GTK_BUTTON(spectrum3dGui.mic), image);
gtk_widget_set_name(spectrum3dGui.mic, "mic");
gtk_widget_set_tooltip_text (spectrum3dGui.mic, "Source is microphone; select this to record something and then load it");
gtk_box_pack_start(GTK_BOX(pHBox[1]), spectrum3dGui.mic, FALSE, TRUE, 2);
g_signal_connect(G_OBJECT(spectrum3dGui.mic), "clicked", G_CALLBACK(change_source_button), &spectrum3dGui);
spectrum3dGui.file = gtk_button_new();
filename = g_build_filename (G_DIR_SEPARATOR_S, DATADIR, "icons", "file_grey.png", NULL);
image = gtk_image_new_from_file(filename);
gtk_button_set_image(GTK_BUTTON(spectrum3dGui.file),image);
gtk_widget_set_name(spectrum3dGui.file, "file");
gtk_widget_set_tooltip_text (spectrum3dGui.file, "Source is an audio file");
gtk_box_pack_start(GTK_BOX(pHBox[1]), spectrum3dGui.file, FALSE, FALSE, 2);
g_signal_connect(G_OBJECT(spectrum3dGui.file), "clicked", G_CALLBACK(change_source_button), &spectrum3dGui);
spectrum3dGui.reload = gtk_button_new();
image = gtk_image_new_from_stock (GTK_STOCK_REFRESH, GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_button_set_image(GTK_BUTTON(spectrum3dGui.reload),image);
gtk_widget_set_sensitive (spectrum3dGui.reload, FALSE);
gtk_widget_set_tooltip_text (spectrum3dGui.reload, "Reload audio file (usefull if some audio parameters like equalizer or filters have been changed)");
gtk_box_pack_start(GTK_BOX(pHBox[1]), spectrum3dGui.reload, FALSE, FALSE, 2);
g_signal_connect(G_OBJECT(spectrum3dGui.reload), "clicked", G_CALLBACK(load_audio_file), NULL);
widget = gtk_check_button_new_with_label("Analyse in\nrealtime");
gtk_widget_set_tooltip_text (GTK_WIDGET(widget), "If checked, harmonics will be analysed and displayed at the same time; if unchecked, harmonics will be analysed first, then displayed for the whole audio file, then it can be played afterwards");
gtk_box_pack_start(GTK_BOX(pHBox[1]), widget, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(widget), TRUE);
g_signal_connect(G_OBJECT(widget), "toggled", G_CALLBACK(set_analyse_in_rt), &spectrum3dGui);
/* separator */
#ifdef GTK3
widget = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
#elif defined GTK2
widget = gtk_vseparator_new();
#endif
gtk_box_pack_start(GTK_BOX(pHBox[1]), widget, FALSE, FALSE, 5);
/* "Play/Pause" button */
playButton = gtk_button_new();
gtk_widget_set_tooltip_text (playButton, "Play/Pause the audio stream");
setPlayButtonIcon();
gtk_widget_set_size_request (playButton, 50, 20);
gtk_box_pack_start(GTK_BOX(pHBox[1]), playButton, FALSE, FALSE, 2);
g_signal_connect(G_OBJECT(playButton), "clicked", G_CALLBACK(playFromSource), "NO_MESSAGE");
/* "Stop" button */
button = gtk_button_new();
gtk_widget_set_tooltip_text (button, "Stop playing audio stream");
image = gtk_image_new_from_stock (GTK_STOCK_MEDIA_STOP, GTK_ICON_SIZE_SMALL_TOOLBAR);
gtk_button_set_image(GTK_BUTTON(button),image);
gtk_box_pack_start(GTK_BOX(pHBox[1]), button, FALSE, FALSE, 2);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(on_stop), NULL);
/* "Record" button */
spectrum3dGui.record = gtk_button_new();
gtk_widget_set_tooltip_text (spectrum3dGui.record, "Record from microphone");
image = gtk_image_new_from_stock (GTK_STOCK_MEDIA_RECORD, GTK_ICON_SIZE_SMALL_TOOLBAR);
gtk_button_set_image(GTK_BUTTON(spectrum3dGui.record),image);
gtk_widget_set_sensitive (spectrum3dGui.record, FALSE);
gtk_box_pack_start(GTK_BOX(pHBox[1]), spectrum3dGui.record, FALSE, FALSE, 2);
g_signal_connect(G_OBJECT(spectrum3dGui.record), "clicked", G_CALLBACK(record_window), NULL);
/* separator */
#ifdef GTK3
widget = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
#elif defined GTK2
widget = gtk_vseparator_new();
#endif
gtk_box_pack_start(GTK_BOX(pHBox[1]), widget, FALSE, FALSE, 5);
/* JACK check button */
filename = g_build_filename (G_DIR_SEPARATOR_S, DATADIR, "icons", "qjackctl.png", NULL);
image = gtk_image_new_from_file(filename);
widget = gtk_check_button_new ();
gtk_button_set_image (GTK_BUTTON(widget), image);
gtk_widget_set_tooltip_text (widget, "Use Jack-Audio-Connection-Kit (JACK)");
gtk_box_pack_start(GTK_BOX(pHBox[1]), widget, FALSE, FALSE, 2);
g_signal_connect(G_OBJECT(widget), "toggled", G_CALLBACK(use_jack), &spectrum3dGui);
/* separator */
#ifdef GTK3
widget = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
#elif defined GTK2
widget = gtk_vseparator_new();
#endif
gtk_box_pack_start(GTK_BOX(pHBox[1]), widget, FALSE, FALSE, 5);
/* Button to open the Filter and Equalizer window */
// create effectsWindow first without showing it
effects_window(&spectrum3dGui);
// then create a button that will call its display when clicked
filename = g_build_filename (G_DIR_SEPARATOR_S, DATADIR, "icons", "equalizer.png", NULL);
image = gtk_image_new_from_file(filename);
widget = gtk_button_new();
gtk_button_set_image (GTK_BUTTON(widget), image);
gtk_widget_set_tooltip_text (widget, "Show/Hide the filter and equalizer window");
gtk_box_pack_start(GTK_BOX(pHBox[1]), widget, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(show_effects_window), &spectrum3dGui);
/* Time label */
label=gtk_label_new("Time : ");
gtk_box_pack_start(GTK_BOX(pHBox[5]), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(pVBox[1]), pHBox[5], FALSE, FALSE, 2);
/* Progress & seek scale */
#ifdef GTK3
scaleSeek = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0.0, 100.0, 1);
#elif defined GTK2
scaleSeek = gtk_hscale_new_with_range (0.0, 100.0, 1);
#endif
gtk_scale_set_draw_value (GTK_SCALE (scaleSeek), FALSE);
//gtk_scale_set_value_pos (GTK_SCALE (pScaleSeek), GTK_POS_TOP);
gtk_range_set_value (GTK_RANGE (scaleSeek), 0);
gtk_widget_set_size_request (scaleSeek, 500, 20);
gtk_box_pack_start(GTK_BOX(pHBox[5]), scaleSeek, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(scaleSeek), "value-changed", G_CALLBACK(on_seek), NULL);
timeLabel=gtk_label_new(" 0:00 / 0:00 ");
gtk_box_pack_start(GTK_BOX(pHBox[5]), timeLabel, FALSE, FALSE, 0);
/* Create drawing area */
if (externalWindow == FALSE){
/* Resize spectrum3dGui.mainWindow to contain drawing_area; using gtk_window_set_defaut() allows to shrink the window (gtk_widget_set_size_request() does not allow to shrink the window below the requested size); */
gtk_window_set_default_size (GTK_WINDOW(spectrum3dGui.mainWindow), (gint)spectrum3d.width, initialWindowHeight + (gint)spectrum3d.height);
//gtk_widget_realize(spectrum3dGui.mainWindow);
spectrum3dGui.drawing_area = gtk_drawing_area_new ();
#if defined (GTKGLEXT3) || defined (GTKGLEXT1)
/* Set OpenGL-capability to the widget */
gtk_widget_set_gl_capability (spectrum3dGui.drawing_area,
glconfig,
NULL,
TRUE,
GDK_GL_RGBA_TYPE);
#endif
/* drawing_area has to be put in vBox AFTER the call to gtk_widget_set_gl_capability() (if GtkGlExt is used) and BEFORE the call to the sdl-gtk hack (if sdl is used)*/
gtk_box_pack_start (GTK_BOX (pVBox[1]), spectrum3dGui.drawing_area, TRUE, TRUE, 0);
#ifdef HAVE_LIBSDL
/* Hack to get SDL to use GTK window */
{ char SDL_windowhack[32];
sprintf(SDL_windowhack,"SDL_WINDOWID=%ld",
GDK_WINDOW_XID(gtk_widget_get_window(spectrum3dGui.drawing_area)));
// GDK_WINDOW_XID( spectrum3dGui.drawing_area->window))); pour GTK2??
putenv(SDL_windowhack);
printf("%s\n", SDL_windowhack);
}
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
fprintf(stderr, "Unable to init SDL: %s\n", SDL_GetError());
exit(1);
}
#endif
g_signal_connect (spectrum3dGui.mainWindow, "key-press-event", G_CALLBACK (on_key_press), &spectrum3dGui);
g_signal_connect (spectrum3dGui.mainWindow, "key-release-event", G_CALLBACK (on_key_release), &spectrum3dGui);
g_signal_connect (spectrum3dGui.mainWindow, "motion-notify-event", G_CALLBACK (on_mouse_motion), NULL);
g_signal_connect (spectrum3dGui.mainWindow, "scroll-event", G_CALLBACK (on_mouse_scroll), NULL);
g_signal_connect (G_OBJECT (spectrum3dGui.drawing_area), "configure_event", G_CALLBACK (configure_event), NULL);
gtk_widget_add_events (spectrum3dGui.mainWindow, gtk_widget_get_events (spectrum3dGui.mainWindow) | GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_SCROLL_MASK);
}
else {
create_external_window_drawing_area(&spectrum3dGui);
}
/* Starting value of the display */
frame = gtk_frame_new("Start value of display (in Hz)");
gtk_widget_set_tooltip_text (frame, "The lower displayed frequency (in herz)");
spectrum3dGui.adjustStart = gtk_adjustment_new(0, 0, 9000, ((gdouble)hzStep * (gdouble)zoomFactor), (((gdouble)hzStep * (gdouble)zoomFactor) * 10), 0);
#ifdef GTK3
pScaleStart = gtk_scale_new(GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT(spectrum3dGui.adjustStart));
#elif defined GTK2
pScaleStart = gtk_hscale_new(GTK_ADJUSTMENT(spectrum3dGui.adjustStart));
#endif
gtk_scale_set_digits (GTK_SCALE(pScaleStart), 0);
gtk_scale_set_value_pos(GTK_SCALE(pScaleStart), GTK_POS_RIGHT);
gtk_box_pack_start(GTK_BOX(pVBox[1]), pHBox[11], FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(pHBox[11]), frame, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(frame), pScaleStart);
g_signal_connect(G_OBJECT(pScaleStart), "value-changed", G_CALLBACK(change_start), &spectrum3dGui);
g_signal_connect(G_OBJECT(pScaleStart), "format-value", G_CALLBACK(format_value_start), NULL);
g_signal_connect(G_OBJECT(pScaleStart), "value-changed", G_CALLBACK(getTextDisplayLabel), &spectrum3dGui);
/* Range of display */
frame = gtk_frame_new("Range of display (in Hz)");
gtk_widget_set_tooltip_text (frame, "The range of the displayed frequency (in herz)");
spectrum3dGui.adjustBands = gtk_adjustment_new(1000, 20, 1000, 10, 50, 0);
#ifdef GTK3
spectrum3dGui.scaleBands = gtk_scale_new(GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT(spectrum3dGui.adjustBands));
#elif defined GTK2
spectrum3dGui.scaleBands = gtk_hscale_new(GTK_ADJUSTMENT(spectrum3dGui.adjustBands));
#endif
gtk_scale_set_digits (GTK_SCALE(spectrum3dGui.scaleBands), 0);
gtk_scale_set_value_pos(GTK_SCALE(spectrum3dGui.scaleBands), GTK_POS_RIGHT);
gtk_container_add(GTK_CONTAINER(frame), spectrum3dGui.scaleBands);
gtk_box_pack_start(GTK_BOX(pHBox[11]), frame, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(spectrum3dGui.scaleBands), "value-changed", G_CALLBACK(change_bands), &spectrum3dGui);
g_signal_connect(G_OBJECT(spectrum3dGui.scaleBands), "format-value", G_CALLBACK(format_value_bands), NULL);
g_signal_connect(G_OBJECT(spectrum3dGui.scaleBands), "value-changed", G_CALLBACK(getTextDisplayLabel), &spectrum3dGui);
/* "x" label */
label=gtk_label_new("x");
gtk_container_add(GTK_CONTAINER(pHBox[11]), label);
/* Factor that multiplies the range of display */
frame = gtk_frame_new("");
gtk_widget_set_tooltip_text (frame, "Factor that multiplies the frequency range, to make it larger");
spectrum3dGui.cbRange = gtk_combo_box_text_new();
gtk_container_add(GTK_CONTAINER(frame), spectrum3dGui.cbRange);
gtk_box_pack_start(GTK_BOX(pHBox[11]), frame, FALSE, FALSE, 0);
for (i = 1; i <= 20; i++){
gchar text[4];
sprintf(text, "%d", i);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(spectrum3dGui.cbRange), text);
}
gtk_combo_box_set_active(GTK_COMBO_BOX(spectrum3dGui.cbRange), 0);
g_signal_connect( G_OBJECT(spectrum3dGui.cbRange), "changed", G_CALLBACK( cb_range_changed ), &spectrum3dGui );
g_signal_connect( G_OBJECT(spectrum3dGui.cbRange), "changed", G_CALLBACK(getTextDisplayLabel), &spectrum3dGui );
/* Label that shows starting value, ending value and range of display */
frame = gtk_frame_new("Values displayed");
gtk_widget_set_tooltip_text (frame, "The lower and the highest displayed value (in herz), and their range");
displayLabel=gtk_label_new("");
gtk_container_add(GTK_CONTAINER(frame), displayLabel);
getTextDisplayLabel(NULL, &spectrum3dGui);
gtk_box_pack_start(GTK_BOX(pHBox[11]), frame, FALSE, FALSE, 0);
/* 'Gain' Gtk Scale */
frame = gtk_frame_new("Display Gain");
gtk_box_pack_start(GTK_BOX(pHBox[11]), frame, FALSE, FALSE, 10);
filename = g_build_filename (G_DIR_SEPARATOR_S, DATADIR, "icons", "gain.png", NULL);
image = gtk_image_new_from_file(filename);
spectrum3dGui.scaleGain = gtk_scale_button_new (GTK_ICON_SIZE_LARGE_TOOLBAR, 0, 1, 0.01, NULL);
gtk_button_set_image(GTK_BUTTON(spectrum3dGui.scaleGain),image);
//gtk_button_set_label (GTK_BUTTON(spectrum3dGui.scaleGain), "GAIN");
gtk_container_add(GTK_CONTAINER(frame), spectrum3dGui.scaleGain);
//gtk_box_pack_start(GTK_BOX(pHBox[11]), pScaleGain, FALSE, FALSE, 0);
//gtk_widget_set_size_request (pScaleGain, 200, 20);
//gtk_scale_set_value_pos(GTK_SCALE(pScaleGain), GTK_POS_RIGHT);
gtk_widget_set_tooltip_text (spectrum3dGui.scaleGain, "Adjust the displayed level of the intensity of the sound");
gtk_scale_button_set_value(GTK_SCALE_BUTTON(spectrum3dGui.scaleGain), 0.2);
// FIXME error message here with the previous line : gtk_image_set_from_stock: assertion `GTK_IS_IMAGE (image)' failed; it could be a bug in Gtk
//g_object_set (pScaleGain, "update-policy", GTK_UPDATE_DISCONTINUOUS, NULL);
g_signal_connect(G_OBJECT(spectrum3dGui.scaleGain), "value-changed", G_CALLBACK(change_gain), NULL);
#ifdef HAVE_LIBGEIS
setupGeis();
#endif
gtk_widget_show_all (spectrum3dGui.mainWindow);
//timeoutEvent = g_timeout_add (100, (GSourceFunc)sdl_event, &spectrum3dGui);
spectrum3d.timeoutExpose = g_timeout_add (intervalDisplaySpectro, (GSourceFunc)display_spectro, &spectrum3dGui);
printf("Showing Gtk GUI\n");
gtk_main ();
/* Quit everything */
#ifdef HAVE_LIBGEIS
geisQuit();
#endif
on_stop();
g_source_remove(spectrum3d.timeoutExpose);
#ifdef HAVE_LIBSDL
//g_source_remove(timeoutEvent);
SDL_Quit();
#endif
print_rc_file();
printf("Quit everything\nGood Bye!\n");
return 0;
}
/**
* 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;
}
