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; }