static void
selection_changed (GtkTreeSelection *selection, NetConnectionEditor *editor)
{
GtkWidget *widget;
GtkTreeModel *model;
GtkTreeIter iter;
gint page;
if (!gtk_tree_selection_get_selected (selection, &model, &iter))
return;
gtk_tree_model_get (model, &iter, 1, &page, -1);
widget = GTK_WIDGET (gtk_builder_get_object (editor->builder,
"details_notebook"));
gtk_notebook_set_current_page (GTK_NOTEBOOK (widget), page);
}
void
girara_tab_current_set(girara_session_t* session, girara_tab_t* tab)
{
if (session == NULL || session->gtk.tabs == NULL
|| tab == NULL || tab->widget == NULL) {
return;
}
int index = gtk_notebook_page_num(session->gtk.tabs, tab->widget);
if (index != -1) {
gtk_notebook_set_current_page(session->gtk.tabs, index);
}
girara_tab_update(session);
}
void
anjuta_msgman_set_current_view (AnjutaMsgman * msgman, MessageView * mv)
{
g_return_if_fail (msgman != NULL);
AnjutaMsgmanPage *page;
gint page_num;
if (mv)
{
page = anjuta_msgman_page_from_widget (msgman, mv);
page_num =
gtk_notebook_page_num (GTK_NOTEBOOK (msgman),
GTK_WIDGET (mv));
gtk_notebook_set_current_page (GTK_NOTEBOOK (msgman), page_num);
}
}
G_MODULE_EXPORT void
cb_run_clicked(GtkButton *button) {
char *source = CLE_get_sourcecode();;
/* Switch the notebook to the first page (which is #0), where the student code runs */
gtk_notebook_set_current_page(global_data->world_views,0);
// BEGINKILL
exercise_run(global_data->lesson->e_curr,source);
// REPLACE
///* Display what should be complied. You should replace this with your own code */
//CLE_log_append(strdup("Run clicked. We should compile that code:\n"));
//CLE_log_append(strdup(source));
// ENDKILL
free(source);
}
static void
cb_dialog_pref_selection_changed (GtkTreeSelection *selection,
PrefState *state)
{
GtkTreeIter iter;
int page;
if (gtk_tree_selection_get_selected (selection, NULL, &iter)) {
gtk_tree_model_get (GTK_TREE_MODEL (state->store), &iter,
PAGE_NUMBER, &page,
-1);
gtk_notebook_set_current_page (state->notebook, page);
} else {
dialog_pref_select_page (state, 0);
}
}
void
um_editable_button_set_editable (UmEditableButton *button,
gboolean editable)
{
UmEditableButtonPrivate *priv;
priv = button->priv;
if (priv->editable != editable) {
priv->editable = editable;
gtk_notebook_set_current_page (priv->notebook, editable ? 1 : 0);
g_object_notify (G_OBJECT (button), "editable");
}
}
static void
pgd_demo_changed (GtkTreeSelection *selection,
GtkNotebook *notebook)
{
GtkTreeModel *model;
GtkTreeIter iter;
if (gtk_tree_selection_get_selected (selection, &model, &iter)) {
gint n_page;
gtk_tree_model_get (model, &iter,
PGD_NPAGE_COLUMN, &n_page,
-1);
gtk_notebook_set_current_page (notebook, n_page);
}
}
static void
action_changed_cb (GtkWidget *action_combo,
gpointer data)
{
Dialog *dialog = data;
gchar *dir;
ECalComponentAlarmAction action;
gint page = 0, i;
action = e_dialog_combo_box_get (dialog->action_combo, action_map);
for (i = 0; action_map[i] != -1; i++) {
if (action == action_map[i]) {
page = i;
break;
}
}
gtk_notebook_set_current_page (
GTK_NOTEBOOK (dialog->option_notebook), page);
switch (action) {
case E_CAL_COMPONENT_ALARM_AUDIO:
dir = calendar_config_get_dir_path ();
if (dir && *dir)
gtk_file_chooser_set_current_folder (
GTK_FILE_CHOOSER (dialog->aalarm_file_chooser),
dir);
g_free (dir);
check_custom_sound (dialog);
break;
case E_CAL_COMPONENT_ALARM_DISPLAY:
check_custom_message (dialog);
break;
case E_CAL_COMPONENT_ALARM_EMAIL:
check_custom_email (dialog);
break;
case E_CAL_COMPONENT_ALARM_PROCEDURE:
check_custom_program (dialog);
break;
default:
g_return_if_reached ();
return;
}
}
/**
*
*
* \param
* \param
*
* \return
*/
gboolean utils_ui_left_panel_tree_view_selection_changed ( GtkTreeSelection *selection,
GtkWidget *notebook )
{
GtkTreeModel *model;
GtkTreeIter iter;
gint selected;
if (! gtk_tree_selection_get_selected ( selection, &model, &iter ) )
return(FALSE);
gtk_tree_model_get ( model, &iter, 1, &selected, -1 );
gtk_notebook_set_current_page ( GTK_NOTEBOOK ( notebook ), selected );
/* return */
return FALSE;
}
void vcal_view_set_summary_page(GtkWidget *to_remove, guint selsig)
{
SummaryView *summaryview = NULL;
if (mainwindow_get_mainwindow()) {
summaryview = mainwindow_get_mainwindow()->summaryview;
if (selsig)
g_signal_handler_disconnect(G_OBJECT(summaryview->ctree), selsig);
gtk_container_remove(GTK_CONTAINER(summaryview->mainwidget_book),
to_remove);
gtk_notebook_set_current_page(GTK_NOTEBOOK(summaryview->mainwidget_book),
gtk_notebook_page_num(GTK_NOTEBOOK(summaryview->mainwidget_book),
summaryview->scrolledwin));
main_window_set_menu_sensitive(mainwindow_get_mainwindow());
toolbar_main_set_sensitive(mainwindow_get_mainwindow());
}
}
static void
action_tab_change_action_activate_callback (GtkAction *action,
gpointer user_data)
{
NemoWindowPane *pane;
NemoWindow *window = user_data;
GtkNotebook *notebook;
int num;
pane = nemo_window_get_active_pane (window);
notebook = GTK_NOTEBOOK (pane->notebook);
num = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (action), "num"));
if (num < gtk_notebook_get_n_pages (notebook)) {
gtk_notebook_set_current_page (notebook, num);
}
}
void gui_set_bible_comm_layout(void)
{
gtk_paned_set_position(GTK_PANED(widgets.hpaned),
settings.biblepane_width);
gtk_paned_set_position(GTK_PANED(widgets.vpaned),
settings.biblepane_height);
gtk_paned_set_position(GTK_PANED(widgets.vpaned2),
settings.commpane_height);
if ((settings.showcomms == TRUE) || (settings.showdicts == TRUE)) {
gtk_widget_show(widgets.vpaned2);
}
gtk_paned_set_position(GTK_PANED(widgets.hpaned),
(settings.showtexts
? settings.biblepane_width
: 0));
gtk_paned_set_position(GTK_PANED(widgets.vpaned2),
(settings.showcomms
? settings.commpane_height
: 0));
gtk_paned_set_position(GTK_PANED(widgets.vpaned2),
(settings.showdicts
? settings.commpane_height
: settings.gs_height));
if ((settings.showcomms == FALSE) && (settings.showdicts == FALSE)) {
gtk_widget_hide(widgets.vpaned2);
gtk_paned_set_position(GTK_PANED(widgets.hpaned),
settings.gs_width);
}
if ((settings.showcomms == TRUE) || (settings.showdicts == TRUE)) {
gtk_paned_set_position(GTK_PANED(widgets.hpaned),
settings.biblepane_width);
}
if (((settings.showcomms == FALSE) && (settings.showtexts == FALSE)) || ((settings.comm_showing == FALSE) && (settings.showtexts == FALSE)))
gtk_widget_hide(nav_toolbar);
else
gtk_widget_show(nav_toolbar);
gtk_notebook_set_current_page(GTK_NOTEBOOK(widgets.notebook_comm_book),
(settings.comm_showing ? 0 : 1));
}
void connect_goto_page(connectScreen_t newpage)
{
GtkNotebook *notebook;
gint curpage, pagecount;
curpage = connect_get_current_page(&pagecount);
if (curpage != newpage)
{
if (newpage >= 0 && newpage < pagecount)
{
CN_LOGPRINTF ("curpage %d-->newpage %d, pagecount %d",
curpage, newpage, pagecount);
notebook = GTK_NOTEBOOK(g_connect_notebook);
gtk_notebook_set_current_page(notebook, newpage);
}
}
}
void gui_undock_parallel_page(void)
{
ApplyChangeBook = FALSE;
parallel_UnDock_Dialog = create_parallel_dialog();
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(widgets.notebook_bible_parallel),
FALSE);
gtk_notebook_set_current_page(GTK_NOTEBOOK(widgets.notebook_bible_parallel),
0);
gtk_widget_show(parallel_UnDock_Dialog);
//main_update_parallel_page_detached();
//g_free(settings.cvparallel);
settings.dockedInt = FALSE;
ApplyChangeBook = TRUE;
sync_with_main();
}
//================================================================
void GUI_notebook_set (MemObj *o_ntb, int pgNr) {
//================================================================
/// activate notebook-page; first=0, next=1 ..
void *wb;
Obj_Unknown *go;
// printf("GUI_notebook_set %d\n",pgNr);
go = GUI_obj_pos (o_ntb);
if(!go) return;
wb = ((Obj_Unknown*)go)->widget;
gtk_notebook_set_current_page (GTK_NOTEBOOK(wb), pgNr);
}
static void on_tab_label_list_sel_changed(GtkTreeSelection* tree_sel, gpointer user_data)
{
GtkTreePath* tp;
GtkTreeIter it;
GtkTreeModel* model;
int page;
if (!gtk_tree_selection_get_selected(tree_sel, &model, &it))
{
g_warning("pref: on_tab_label_list_sel_changed() got no selection");
return;
}
tp = gtk_tree_model_get_path(model, &it);
page = gtk_tree_path_get_indices(tp)[0];
if (gtk_notebook_get_current_page(notebook) != page)
gtk_notebook_set_current_page(notebook, page);
gtk_tree_path_free(tp);
}
void
on_dialog_logon_engine_name_changed (GtkComboBox *combobox,
gpointer user_data)
{
GSQL_TRACE_FUNC;
GtkWidget * vbox = GTK_WIDGET(user_data);
GtkWidget * engine_name;
GtkWidget * notebook;
gint page_num;
engine_name = g_object_get_data (G_OBJECT (vbox), "engine_name");
notebook = g_object_get_data (G_OBJECT (vbox), "notebook");
page_num = gtk_combo_box_get_active (GTK_COMBO_BOX(engine_name));
gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), page_num);
}
/* callback for when tabs switch */
static void tab_switch(gboolean b, struct window *w) {
gint(current) = gtk_notebook_get_current_page(GTK_NOTEBOOK(w->notebook));
if(b) {
if (current == gtk_notebook_get_n_pages(GTK_NOTEBOOK(w->notebook)) -1 ) {
current = 0;
} else {
current = current + 1;
}
} else {
if (current == 0) {
current = gtk_notebook_get_n_pages(GTK_NOTEBOOK(w->notebook)) - 1;
} else {
current = current -1;
}
}
gtk_notebook_set_current_page(GTK_NOTEBOOK(w->notebook), current);
}
void
dialog_tool_preset_to_range (GenericToolState *state)
{
GnmRange const *sel;
GtkWidget *w;
g_return_if_fail (state != NULL);
g_return_if_fail (state->gdao != NULL);
sel = selection_first_range (state->sv, NULL, NULL);
gnm_dao_load_range (GNM_DAO (state->gdao), sel);
gnm_dao_focus_output_range (GNM_DAO (state->gdao));
w = glade_xml_get_widget (state->gui, "notebook1");
g_return_if_fail (w && GTK_IS_NOTEBOOK (w));
gtk_notebook_set_current_page (GTK_NOTEBOOK(w), 0);
}
/* Fills the widgets with default values */
static void
clear_widgets (Dialog *dialog)
{
/* Sane defaults */
e_dialog_option_menu_set (dialog->action, E_CAL_COMPONENT_ALARM_DISPLAY, action_map);
e_dialog_spin_set (dialog->interval_value, 15);
e_dialog_option_menu_set (dialog->value_units, MINUTES, value_map);
e_dialog_option_menu_set (dialog->relative, BEFORE, relative_map);
e_dialog_option_menu_set (dialog->time, E_CAL_COMPONENT_ALARM_TRIGGER_RELATIVE_START, time_map);
gtk_widget_set_sensitive (dialog->repeat_group, FALSE);
gtk_widget_set_sensitive (dialog->dalarm_group, FALSE);
gtk_widget_set_sensitive (dialog->aalarm_group, FALSE);
gtk_widget_set_sensitive (dialog->malarm_group, FALSE);
gtk_notebook_set_current_page (GTK_NOTEBOOK (dialog->option_notebook), 0);
}
static void _tabs_off(void)
{
int page = _is_paratab_showing();
xml_set_value("Xiphos", "tabs", "browsing", "0");
gui_save_tabs(default_tab_filename);
if (settings.showparatab) {
gui_close_passage_tab(gtk_notebook_page_num(GTK_NOTEBOOK(widgets.notebook_main),
widgets.parallel_tab));
settings.showparatab = FALSE;
}
gui_close_all_tabs();
settings.browsing = FALSE;
gui_load_tabs(no_tab_filename);
gtk_widget_hide(widgets.hboxtb);
gtk_notebook_set_current_page(GTK_NOTEBOOK(widgets.notebook_bible_parallel),
page);
}
void
gb_workspace_pane_group_set_page (GbWorkspacePaneGroup *group,
gint page_num)
{
GbWorkspacePaneGroupPrivate *priv;
GtkNotebook *notebook;
g_return_if_fail(GB_IS_WORKSPACE_PANE_GROUP(group));
priv = group->priv;
notebook = GTK_NOTEBOOK(priv->notebook);
if ((page_num >= 0) && (page_num < gtk_notebook_get_n_pages(notebook))) {
gtk_notebook_set_current_page(notebook, page_num);
}
}
void plugin_cleanup(void)
{
if (have_vte)
{
/* move the vte frame back to where it was before */
gtk_widget_reparent(vte_frame, GTK_WIDGET(vte_old_home));
/* put the label back in the old notebook */
gtk_notebook_set_tab_label(vte_old_home, vte_frame, vte_tab_label);
/* we no longer to to hang on to a reference of the label */
g_object_unref(G_OBJECT(vte_tab_label));
/* select the vte tab in the message window */
gtk_notebook_set_current_page(vte_old_home, MSG_VTE);
}
}
void
empathy_chat_window_switch_to_chat (EmpathyChatWindow *window,
EmpathyChat *chat)
{
EmpathyChatWindowPriv *priv;
gint page_num;
g_return_if_fail (window != NULL);
g_return_if_fail (EMPATHY_IS_CHAT (chat));
priv = GET_PRIV (window);
page_num = gtk_notebook_page_num (GTK_NOTEBOOK (priv->notebook),
GTK_WIDGET (chat));
gtk_notebook_set_current_page (GTK_NOTEBOOK (priv->notebook),
page_num);
}
LifereaHtmlView *
browser_tabs_add_new (const gchar *url, const gchar *title, gboolean activate)
{
GtkWidget *close_button, *labelBox;
tabInfo *tab;
int i;
tab = g_new0 (tabInfo, 1);
tab->htmlview = liferea_htmlview_new (TRUE /* internal browsing */);
tab->widget = liferea_htmlview_get_widget (tab->htmlview);
tabs->priv->list = g_slist_append (tabs->priv->list, tab);
g_object_set_data (G_OBJECT (tab->widget), "tabInfo", tab);
g_signal_connect (tab->htmlview, "title-changed", G_CALLBACK (on_htmlview_title_changed), tab);
g_signal_connect (tab->htmlview, "statusbar-changed", G_CALLBACK (on_htmlview_status_message), NULL);
/* create tab widgets */
tab->label = gtk_label_new (create_label_text (title));
gtk_label_set_ellipsize (GTK_LABEL (tab->label), PANGO_ELLIPSIZE_END);
gtk_label_set_width_chars (GTK_LABEL (tab->label), 17);
labelBox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
gtk_box_pack_start (GTK_BOX (labelBox), tab->label, FALSE, FALSE, 0);
close_button = gedit_close_button_new ();
gtk_box_pack_end (GTK_BOX (labelBox), close_button, FALSE, FALSE, 0);
g_signal_connect ((gpointer)close_button, "clicked", G_CALLBACK (on_htmlview_close_tab), (gpointer)tab);
gtk_widget_show_all (labelBox);
i = gtk_notebook_append_page (tabs->priv->notebook, tab->widget, labelBox);
g_signal_connect (gtk_notebook_get_nth_page (tabs->priv->notebook, i),
"key-press-event", G_CALLBACK (on_tab_key_press), (gpointer)tab);
gtk_notebook_set_show_tabs (tabs->priv->notebook, TRUE);
gtk_notebook_set_tab_reorderable (tabs->priv->notebook, tab->widget, TRUE);
if (activate && (i != -1))
gtk_notebook_set_current_page (tabs->priv->notebook, i);
if (url)
liferea_htmlview_launch_URL_internal (tab->htmlview, (gchar *)url);
return tab->htmlview;
}
void about_widget_constructor(AboutWidget * about_widget, int preselected)
{
char * files[][2] = {
{"Manual", DOC_PATH "doc_manual.srt"},
{"About", DOC_PATH "doc_about.srt"},
{"License", DOC_PATH "doc_gpl.srt"}
};
char * default_texts[] = {
"The manual file could not be found",
"Vexterm. Copyright (C) 2010 Sebastian Kürten\n\n"
"(More information is not available since the about-file could not be found)",
"Vexterm is distributed under the terms of the GNU General Public License (GPL) in version 3"
" or (at your choise) any later version."
};
GtkNotebook * nb = GTK_NOTEBOOK(gtk_notebook_new());
int p;
for (p = 0; p < sizeof(files) / sizeof(char*) / 2; p++){
GtkWidget * view = about_widget_create_view_from_file(files[p][1], default_texts[p]);
GtkWidget * scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_container_add(GTK_CONTAINER(scrolled), GTK_WIDGET(view));
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
GtkWidget * label = gtk_label_new(files[p][0]);
gtk_widget_show_all(scrolled);
gtk_notebook_append_page(nb, scrolled, label);
}
GtkWidget * logo = about_logo_new();
int logo_height;
gtk_widget_get_size_request(logo, NULL, &logo_height);
if (logo_height == 1){
gtk_widget_set_size_request(logo, -1, LOGO_HEIGHT_DEFAULT);
}
gtk_box_pack_start(GTK_BOX(about_widget), GTK_WIDGET(logo), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(about_widget), GTK_WIDGET(nb), TRUE, TRUE, 0);
gtk_notebook_set_current_page(nb, preselected);
}
void recreate_show_rule_page(){
GtkWidget *pVBoxCentral;
GtkWidget *pVBoxSup;
GtkWidget * pButtonRefresh = gtk_button_new_with_label("Refresh");
// data_page_show_rule_p
//on ajoute les entry a la data
dpsr->pButtonRefresh = pButtonRefresh;
GtkWidget *pLabel1 = gtk_label_new(g_strdup_printf("Label Box 1"));
GtkWidget *pTabLabel = gtk_label_new(g_strdup_printf("Voir regles - new"));
pVBoxCentral = gtk_vbox_new(FALSE, 0);
pVBoxSup = gtk_vbox_new(FALSE, 0);
create_vbox_from_rule_tab(pVBoxSup);
gtk_box_pack_start(GTK_BOX(pVBoxCentral), pVBoxSup, FALSE, FALSE, 0);
//on met le bouton refresh dans la partie inferieure
gtk_box_pack_start(GTK_BOX(pVBoxCentral), pButtonRefresh, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(pButtonRefresh),"clicked",G_CALLBACK(OnButtonRefreshPageRule),NULL);
gtk_box_pack_start(GTK_BOX(pVBoxSup), pLabel1, FALSE, FALSE, 0);
gint current_page = gtk_notebook_get_current_page (GTK_NOTEBOOK(dw->pNotebook));
printf("Current page = %d\n", current_page);
// Insertion de la page avec le widget pLabel
gtk_notebook_remove_page(GTK_NOTEBOOK(dw->pNotebook),2);
printf("On enleve une page\n");
gtk_notebook_insert_page(GTK_NOTEBOOK(dw->pNotebook), pVBoxCentral, pTabLabel,2);
printf("On rajoute une page\n");
printf("On va sur la page %d\n",current_page);
gtk_widget_show_all(dw->pWindow);
gtk_notebook_set_current_page (GTK_NOTEBOOK(dw->pNotebook),current_page);
// Insertion de la page avec le widget pVBoxCentral
// gtk_notebook_insert_page(GTK_NOTEBOOK(dw->pNotebook), pVBoxCentral, pTabLabel,2);
}
/**
* selectionne une page
*
* \param
* \param
* \param
*
* \return
*/
gboolean utils_ui_left_panel_tree_view_select_page ( GtkWidget *tree_view,
GtkWidget *notebook,
gint page )
{
GtkTreeModel *model;
GtkTreeIter parent_iter;
model = gtk_tree_view_get_model ( GTK_TREE_VIEW ( tree_view ) );
if ( !gtk_tree_model_get_iter_first ( GTK_TREE_MODEL ( model ), &parent_iter ) )
return FALSE;
do
{
GtkTreeIter iter;
if ( gtk_tree_model_iter_children ( GTK_TREE_MODEL ( model ), &iter, &parent_iter ) )
{
do
{
gint tmp_page;
gtk_tree_model_get (GTK_TREE_MODEL ( model ),
&iter,
LEFT_PANEL_TREE_PAGE_COLUMN, &tmp_page,
-1 );
if ( tmp_page == page )
{
GtkTreeSelection *sel;
sel = gtk_tree_view_get_selection ( GTK_TREE_VIEW ( tree_view ) );
gtk_tree_selection_select_iter ( sel, &iter );
gtk_notebook_set_current_page ( GTK_NOTEBOOK ( notebook ), page );
break;
}
}
while ( gtk_tree_model_iter_next ( GTK_TREE_MODEL ( model ), &iter ) );
}
}
while ( gtk_tree_model_iter_next ( GTK_TREE_MODEL ( model ), &parent_iter ) );
/* return */
return FALSE;
}
static void
gimp_dynamics_editor_view_changed (GtkComboBox *combo,
GtkWidget *notebook)
{
GtkTreeModel *model = gtk_combo_box_get_model (combo);
GtkTreeIter iter;
gpointer widget;
gint page;
gtk_combo_box_get_active_iter (GTK_COMBO_BOX (combo), &iter);
gtk_tree_model_get (model, &iter,
GIMP_INT_STORE_USER_DATA, &widget,
-1);
page = gtk_notebook_page_num (GTK_NOTEBOOK (notebook), widget);
gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), page);
}
/**
* @brief Called when a user clicks "Connect" in wdw_connect.
* @param object A GtkObject
* @param user_data Data passed in
*/
void main_connection_connect (GtkObject *object, gpointer user_data)
{
BrokeUIMain *main_window;
GnomeDbLogin *login;
GtkNotebook *notebook;
GdaConnection *connection;
main_window = BROKE_UI_MAIN;
login = main_window->login;
notebook = main_window->notebook;
connection = broke_connection_gnomedblogin (login);
if (connection != NULL) {
gtk_notebook_set_current_page (notebook, MAIN_PAGE_UI);
}
return;
}
