/** * Callback function to select next page. * \param widget Widget (button). */ static void imp_ldif_next( GtkWidget *widget ) { gint pageNum; pageNum = gtk_notebook_current_page( GTK_NOTEBOOK(impldif_dlg.notebook) ); if( pageNum == PAGE_FILE_INFO ) { /* Goto attributes stuff */ if( imp_ldif_file_move() ) { gtk_notebook_set_page( GTK_NOTEBOOK(impldif_dlg.notebook), PAGE_ATTRIBUTES ); imp_ldif_message(); gtk_widget_set_sensitive( impldif_dlg.btnPrev, TRUE ); } else { gtk_widget_set_sensitive( impldif_dlg.btnPrev, FALSE ); } } else if( pageNum == PAGE_ATTRIBUTES ) { /* Goto finish stuff */ if( imp_ldif_field_move() ) { gtk_notebook_set_page( GTK_NOTEBOOK(impldif_dlg.notebook), PAGE_FINISH ); imp_ldif_finish_show(); } } }
static void set_view_type(ShellViewType viewtype) { gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(shell->info->view), FALSE); if (viewtype == shell->view_type) return; switch (viewtype) { default: case SHELL_VIEW_NORMAL: gtk_widget_hide(shell->notebook); shell->view_type = SHELL_VIEW_NORMAL; break; case SHELL_VIEW_DUAL: gtk_notebook_set_page(GTK_NOTEBOOK(shell->notebook), 0); gtk_widget_show(shell->notebook); shell->view_type = SHELL_VIEW_DUAL; break; case SHELL_VIEW_LOAD_GRAPH: gtk_notebook_set_page(GTK_NOTEBOOK(shell->notebook), 1); gtk_widget_show(shell->notebook); load_graph_clear(shell->loadgraph); gtk_paned_set_position(GTK_PANED(shell->vpaned), shell->hpaned->allocation.height - shell->loadgraph->height - 16); shell->view_type = SHELL_VIEW_LOAD_GRAPH; break; } }
void convert_all(void (*conv_func)(void)) { gint CurrentPage, i; if (!OpenedFilesCnt) return; CurrentPage = gtk_notebook_get_current_page (GTK_NOTEBOOK(MainNotebook)); for (i = 0; i < OpenedFilesCnt; i++) if (!FPROPS(CurrentPage, ReadOnly)) { gtk_notebook_set_page (GTK_NOTEBOOK(MainNotebook), i); conv_func (); } gtk_notebook_set_page (GTK_NOTEBOOK(MainNotebook), CurrentPage); }
/** * Process export address dialog. * \param cache Address book/data source cache. */ void addressbook_exp_html( AddressCache *cache ) { /* Set references to control data */ _addressCache_ = cache; _exportCtl_ = exporthtml_create(); exporthtml_load_settings( _exportCtl_ ); /* Setup GUI */ if( ! exphtml_dlg.window ) export_html_create(); exphtml_dlg.cancelled = FALSE; gtk_widget_show(exphtml_dlg.window); manage_window_set_transient(GTK_WINDOW(exphtml_dlg.window)); gtk_label_set_text( GTK_LABEL(exphtml_dlg.labelBook), cache->name ); gtk_label_set_text( GTK_LABEL(exphtml_dlg.labelOutBook), cache->name ); export_html_fill_fields( _exportCtl_ ); gtk_widget_grab_default(exphtml_dlg.btnNext); gtk_notebook_set_page( GTK_NOTEBOOK(exphtml_dlg.notebook), PAGE_FILE_INFO ); gtk_widget_set_sensitive( exphtml_dlg.btnPrev, FALSE ); gtk_widget_set_sensitive( exphtml_dlg.btnNext, TRUE ); export_html_message(); gtk_widget_grab_focus(exphtml_dlg.entryHtml); gtk_main(); gtk_widget_hide(exphtml_dlg.window); exporthtml_free( _exportCtl_ ); _exportCtl_ = NULL; _addressCache_ = NULL; }
void wxMDIChildFrame::Activate() { wxMDIParentFrame* parent = (wxMDIParentFrame*) GetParent(); GtkNotebook* notebook = GTK_NOTEBOOK(parent->m_widget); gint pageno = gtk_notebook_page_num( notebook, m_widget ); gtk_notebook_set_page( notebook, pageno ); }
/* {EV_NOTEBOOK_IMP}.select_item */ void F1106_14785 (EIF_REFERENCE Current, EIF_REFERENCE arg1) { GTCX EIF_REFERENCE loc1 = (EIF_REFERENCE) 0; EIF_POINTER tp1; EIF_POINTER tp2; EIF_POINTER tp3; EIF_INTEGER_32 ti4_1; RTLD; RTLI(3); RTLR(0,loc1); RTLR(1,arg1); RTLR(2,Current); RTGC; loc1 = *(EIF_REFERENCE *)(RTCV(arg1) + O8345[Dtype(arg1)-929]); loc1 = RTRV(eif_non_attached_type(1095), loc1); RTCT0("an_item_has_implementation", EX_CHECK); if ((EIF_BOOLEAN)(loc1 != NULL)) { RTCK0; } else { RTCF0; } tp1 = F1079_14146(Current); tp2 = F1079_14146(Current); tp3 = *(EIF_POINTER *)(RTCV(loc1) + O10979[Dtype(loc1)-1078]); ti4_1 = (EIF_INTEGER_32) gtk_notebook_page_num((GtkNotebook*) tp2, (GtkWidget*) tp3); gtk_notebook_set_page((GtkNotebook*) tp1, (gint) ti4_1); RTLE; }
int wxNotebook::DoSetSelection( size_t page, int flags ) { wxCHECK_MSG( m_widget != NULL, wxNOT_FOUND, wxT("invalid notebook") ); wxCHECK_MSG( page < m_pagesData.GetCount(), -1, wxT("invalid notebook index") ); int selOld = GetSelection(); if ( !(flags & SetSelection_SendEvent) ) m_skipNextPageChangeEvent = true; // cache the selection m_selection = page; gtk_notebook_set_page( GTK_NOTEBOOK(m_widget), page ); // gtk_notebook_set_current_page is supposed to emit the switch-page signal // which should be caught by our gtk_notebook_page_change_callback which // should have reset the flag to false, check it: wxASSERT_LEVEL_2_MSG( (flags & SetSelection_SendEvent) || !m_skipNextPageChangeEvent, "internal error in selection events generation" ); wxNotebookPage *client = GetPage(page); if ( client ) client->SetFocus(); return selOld; }
int wxNotebook::DoSetSelection( size_t page, int flags ) { wxCHECK_MSG( m_widget != NULL, -1, wxT("invalid notebook") ); wxCHECK_MSG( page < m_pagesData.GetCount(), -1, wxT("invalid notebook index") ); int selOld = GetSelection(); if ( !(flags & SetSelection_SendEvent) ) m_skipNextPageChangeEvent = true; // cache the selection m_selection = page; gtk_notebook_set_page( GTK_NOTEBOOK(m_widget), page ); #ifdef __WXDEBUG__ if ( !(flags & SetSelection_SendEvent) ) { // gtk_notebook_set_current_page will emit the switch-page signal which will be // caught by our gtk_notebook_page_change_callback which should have reset the // flag to false: wxASSERT(!m_skipNextPageChangeEvent); } #endif // __WXDEBUG__ wxNotebookPage *client = GetPage(page); if ( client ) client->SetFocus(); return selOld; }
static void note_change_page(GtkWidget *child, GtkNotebook *notebook) { gint page = gtk_notebook_page_num(notebook, child); gtk_notebook_set_page(notebook, page); }
void wxMDIChildFrame::Activate() { GtkNotebook * const notebook = GTKGetNotebook(); wxCHECK_RET( notebook, "no parent notebook?" ); gint pageno = gtk_notebook_page_num( notebook, m_widget ); gtk_notebook_set_page( notebook, pageno ); }
/** * Callback function to select previous page. * \param widget Widget (button). */ static void export_html_prev( GtkWidget *widget ) { gint pageNum; pageNum = gtk_notebook_current_page( GTK_NOTEBOOK(exphtml_dlg.notebook) ); if( pageNum == PAGE_FORMAT ) { /* Goto file page stuff */ gtk_notebook_set_page( GTK_NOTEBOOK(exphtml_dlg.notebook), PAGE_FILE_INFO ); gtk_widget_set_sensitive( exphtml_dlg.btnPrev, FALSE ); } else if( pageNum == PAGE_FINISH ) { /* Goto format page */ gtk_notebook_set_page( GTK_NOTEBOOK(exphtml_dlg.notebook), PAGE_FORMAT ); gtk_widget_set_sensitive( exphtml_dlg.btnNext, TRUE ); } export_html_message(); }
void onAbout(GtkButton *button, gpointer user_data) { intf_thread_t *p_intf = GtkGetIntf( GTK_WIDGET(button) ); /* Toggle notebook */ if (p_intf->p_sys->p_notebook) { gtk_widget_show( GTK_WIDGET(p_intf->p_sys->p_notebook) ); gtk_notebook_set_page(p_intf->p_sys->p_notebook,6); } }
/** * Callback function to select previous page. * \param widget Widget (button). */ static void imp_ldif_prev( GtkWidget *widget ) { gint pageNum; pageNum = gtk_notebook_current_page( GTK_NOTEBOOK(impldif_dlg.notebook) ); if( pageNum == PAGE_ATTRIBUTES ) { /* Goto file page stuff */ gtk_notebook_set_page( GTK_NOTEBOOK(impldif_dlg.notebook), PAGE_FILE_INFO ); gtk_widget_set_sensitive( impldif_dlg.btnPrev, FALSE ); } imp_ldif_message(); }
/* Switches to the page number page_num. Negative values stand for the * last page; too large values are ignored. */ int clip_GTK_NOTEBOOKSETPAGE(ClipMachine * cm) { C_widget *cntb = _fetch_cw_arg(cm); gint page_num = _clip_parni(cm,2); CHECKCWID(cntb,GTK_IS_NOTEBOOK); CHECKOPT(2,NUMERIC_t); if (_clip_parinfo(cm,2)==UNDEF_t) page_num = 1; gtk_notebook_set_page(GTK_NOTEBOOK(cntb->widget), (page_num>0?page_num-1:page_num)); return 0; err: return 1; }
/** * Callback function to select previous page. * \param widget Widget (button). */ static void export_html_next( GtkWidget *widget ) { gint pageNum; pageNum = gtk_notebook_current_page( GTK_NOTEBOOK(exphtml_dlg.notebook) ); if( pageNum == PAGE_FILE_INFO ) { /* Goto format page */ if( exp_html_move_file() ) { gtk_notebook_set_page( GTK_NOTEBOOK(exphtml_dlg.notebook), PAGE_FORMAT ); gtk_widget_set_sensitive( exphtml_dlg.btnPrev, TRUE ); } export_html_message(); } else if( pageNum == PAGE_FORMAT ) { /* Goto finish page */ if( exp_html_move_format() ) { gtk_notebook_set_page( GTK_NOTEBOOK(exphtml_dlg.notebook), PAGE_FINISH ); exp_html_finish_show(); exporthtml_save_settings( _exportCtl_ ); export_html_message(); } } }
static void mimeview_change_view_type(MimeView *mimeview, MimeViewType type) { TextView *textview = mimeview->textview; if ((mimeview->type != MIMEVIEW_VIEWER) && (mimeview->type == type)) return; switch (type) { case MIMEVIEW_TEXT: gtk_notebook_set_page(GTK_NOTEBOOK(mimeview->mime_notebook), gtk_notebook_page_num(GTK_NOTEBOOK(mimeview->mime_notebook), GTK_WIDGET_PTR(textview))); break; case MIMEVIEW_VIEWER: gtk_notebook_set_page(GTK_NOTEBOOK(mimeview->mime_notebook), gtk_notebook_page_num(GTK_NOTEBOOK(mimeview->mime_notebook), GTK_WIDGET(mimeview->mimeviewer->get_widget(mimeview->mimeviewer)))); break; default: return; } mimeview->type = type; }
void wins_bring_tofront (GtkWidget *widget) { xchatwin *xw; int page; xw = (xchatwin *) gtk_object_get_user_data (GTK_OBJECT (widget)); if (xw->is_toplevel) { gdk_window_show (widget->window); } else { page = gtk_notebook_page_num (GTK_NOTEBOOK (main_book), widget); gtk_notebook_set_page (GTK_NOTEBOOK (main_book), page); } }
/** * Import LDIF file. * \param addrIndex Address index. * \return Address book file of imported data, or <i>NULL</i> if import * was cancelled. */ AddressBookFile *addressbook_imp_ldif( AddressIndex *addrIndex ) { _importedBook_ = NULL; _imp_addressIndex_ = addrIndex; if( ! impldif_dlg.window ) imp_ldif_create(); impldif_dlg.cancelled = FALSE; gtk_widget_show(impldif_dlg.window); manage_window_set_transient(GTK_WINDOW(impldif_dlg.window)); gtk_widget_grab_default(impldif_dlg.btnNext); gtk_entry_set_text( GTK_ENTRY(impldif_dlg.entryName), IMPORTLDIF_GUESS_NAME ); gtk_entry_set_text( GTK_ENTRY(impldif_dlg.entryFile), "" ); gtk_label_set_text( GTK_LABEL(impldif_dlg.entryField), "" ); gtk_entry_set_text( GTK_ENTRY(impldif_dlg.entryAttrib), "" ); gtk_clist_clear( GTK_CLIST(impldif_dlg.clist_field) ); gtk_notebook_set_page( GTK_NOTEBOOK(impldif_dlg.notebook), PAGE_FILE_INFO ); gtk_widget_set_sensitive( impldif_dlg.btnPrev, FALSE ); gtk_widget_set_sensitive( impldif_dlg.btnNext, TRUE ); stock_pixmap_gdk( impldif_dlg.window, STOCK_PIXMAP_MARK, &markxpm, &markxpmmask ); imp_ldif_message(); gtk_widget_grab_focus(impldif_dlg.entryFile); impldif_dlg.rowIndSelect = -1; impldif_dlg.rowCount = 0; g_free( impldif_dlg.nameBook ); g_free( impldif_dlg.fileName ); impldif_dlg.nameBook = NULL; impldif_dlg.fileName = NULL; _ldifFile_ = ldif_create(); gtk_main(); gtk_widget_hide(impldif_dlg.window); ldif_free( _ldifFile_ ); _ldifFile_ = NULL; _imp_addressIndex_ = NULL; g_free( impldif_dlg.nameBook ); g_free( impldif_dlg.fileName ); impldif_dlg.nameBook = NULL; impldif_dlg.fileName = NULL; if( impldif_dlg.cancelled == TRUE ) return NULL; return _importedBook_; }
void ChangeShowPage(const int page_index) { GtkWidget *widget; SpecialInfo* special = NULL; if(g_config_file_data != NULL){ special = g_config_file_data->special_list; } while(special != NULL){ if(0 == special->type){ widget = glade_xml_get_widget(g_cngplp_xml, special->name); if(widget != NULL){ gtk_notebook_set_page(GTK_NOTEBOOK(widget), page_index); } break; } special = special->next; } }
/* {EV_NOTEBOOK_IMP}.replace */ void F1106_14787 (EIF_REFERENCE Current, EIF_REFERENCE arg1) { GTCX EIF_INTEGER_32 loc1 = (EIF_INTEGER_32) 0; EIF_POINTER tp1; EIF_INTEGER_32 ti4_1; RTLD; RTLI(2); RTLR(0,Current); RTLR(1,arg1); RTGC; tp1 = F1079_14146(Current); loc1 = (EIF_INTEGER_32) gtk_notebook_get_current_page((GtkNotebook*) tp1); F1106_14786(Current, *(EIF_INTEGER_32 *)(Current+ _LNGOFF_47_10_10_1_)); ti4_1 = *(EIF_INTEGER_32 *)(Current+ _LNGOFF_47_10_10_1_); F1105_14769(Current, arg1, ti4_1); tp1 = F1079_14146(Current); gtk_notebook_set_page((GtkNotebook*) tp1, (gint) loc1); RTLE; }
int nsComponentsDlg::Show(int aDirection) { int err = OK; int customSTIndex = 0, i; int numRows = 0; int currRow = 0; GtkWidget *hbox = NULL; XI_VERIFY(gCtx); XI_VERIFY(gCtx->notebook); if (mWidgetsInit == FALSE) { customSTIndex = gCtx->sdlg->GetNumSetupTypes(); sCustomST = gCtx->sdlg->GetSetupTypeList(); for (i=1; i<customSTIndex; i++) sCustomST = sCustomST->GetNext(); DUMP(sCustomST->GetDescShort()); // create a new table and add it as a page of the notebook mTable = gtk_table_new(5, 1, FALSE); gtk_notebook_append_page(GTK_NOTEBOOK(gCtx->notebook), mTable, NULL); mPageNum = gtk_notebook_get_current_page(GTK_NOTEBOOK(gCtx->notebook)); gtk_widget_show(mTable); // 1st row: a label (msg0) // insert a static text widget in the first row GtkWidget *msg0 = gtk_label_new(mMsg0); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), msg0, FALSE, FALSE, 0); gtk_widget_show(hbox); gtk_table_attach(GTK_TABLE(mTable), hbox, 0, 1, 1, 2, static_cast<GtkAttachOptions>(GTK_FILL | GTK_EXPAND), GTK_FILL, 20, 20); gtk_widget_show(msg0); // 2nd row: a CList with a check box for each row (short desc) GtkWidget *list = NULL; GtkWidget *scrollwin = NULL; GtkStyle *style = NULL; GdkBitmap *ch_mask = NULL; GdkPixmap *checked = NULL; GdkBitmap *un_mask = NULL; GdkPixmap *unchecked = NULL; gchar *dummy[2] = { " ", " " }; nsComponent *currComp = sCustomST->GetComponents()->GetHead(); GtkWidget *descLongTable = NULL; GtkWidget *frame = NULL; scrollwin = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); list = gtk_clist_new(2); gtk_clist_set_selection_mode(GTK_CLIST(list), GTK_SELECTION_BROWSE); gtk_clist_column_titles_hide(GTK_CLIST(list)); gtk_clist_set_column_auto_resize(GTK_CLIST(list), 0, TRUE); gtk_clist_set_column_auto_resize(GTK_CLIST(list), 1, TRUE); // determine number of rows we'll need numRows = sCustomST->GetComponents()->GetLengthVisible(); for (i = 0; i < numRows; i++) gtk_clist_append(GTK_CLIST(list), dummy); style = gtk_widget_get_style(gCtx->window); checked = gdk_pixmap_create_from_xpm_d(gCtx->window->window, &ch_mask, &style->bg[GTK_STATE_NORMAL], (gchar **)check_on_xpm); unchecked = gdk_pixmap_create_from_xpm_d(gCtx->window->window, &un_mask, &style->bg[GTK_STATE_NORMAL], (gchar **)check_off_xpm); while ((currRow < numRows) && currComp) // paranoia! { if (!currComp->IsInvisible()) { if (currComp->IsSelected()) gtk_clist_set_pixmap(GTK_CLIST(list), currRow, 0, checked, ch_mask); else gtk_clist_set_pixmap(GTK_CLIST(list), currRow, 0, unchecked, un_mask); gtk_clist_set_text(GTK_CLIST(list), currRow, 1, currComp->GetDescShort()); currRow++; } currComp = currComp->GetNext(); } // by default, first row selected upon Show() sCurrRowSelected = 0; gtk_signal_connect(GTK_OBJECT(list), "select_row", GTK_SIGNAL_FUNC(RowSelected), NULL); gtk_signal_connect(GTK_OBJECT(list), "key_press_event", GTK_SIGNAL_FUNC(KeyPressed), NULL); gtk_container_add(GTK_CONTAINER(scrollwin), list); gtk_widget_show(list); gtk_widget_show(scrollwin); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), scrollwin, TRUE, TRUE, 0); gtk_widget_show(hbox); gtk_table_attach(GTK_TABLE(mTable), hbox, 0, 1, 2, 3, static_cast<GtkAttachOptions>(GTK_FILL | GTK_EXPAND), static_cast<GtkAttachOptions>(GTK_EXPAND | GTK_FILL), 20, 0); // XXX 3rd row: labels for ds avail and ds reqd // 4th row: a frame with a label (long desc) descLongTable = gtk_table_new(1, 1, FALSE); gtk_widget_show(descLongTable); gtk_table_attach(GTK_TABLE(mTable), descLongTable, 0, 1, 4, 5, static_cast<GtkAttachOptions>(GTK_EXPAND | GTK_FILL), static_cast<GtkAttachOptions>(GTK_EXPAND | GTK_FILL), 20, 20); frame = gtk_frame_new(gCtx->Res("DESCRIPTION")); gtk_table_attach_defaults(GTK_TABLE(descLongTable), frame, 0, 1, 0, 1); gtk_widget_show(frame); sDescLong = gtk_label_new( sCustomST->GetComponents()->GetFirstVisible()->GetDescLong()); gtk_label_set_line_wrap(GTK_LABEL(sDescLong), TRUE); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), sDescLong, FALSE, FALSE, 20); gtk_widget_show(hbox); gtk_table_attach_defaults(GTK_TABLE(descLongTable), hbox, 0, 1, 0, 1); gtk_widget_show(sDescLong); mWidgetsInit = TRUE; } else { gtk_notebook_set_page(GTK_NOTEBOOK(gCtx->notebook), mPageNum); gtk_widget_show(mTable); } // signal connect the buttons gCtx->backID = gtk_signal_connect(GTK_OBJECT(gCtx->back), "clicked", GTK_SIGNAL_FUNC(nsComponentsDlg::Back), gCtx->cdlg); gCtx->nextID = gtk_signal_connect(GTK_OBJECT(gCtx->next), "clicked", GTK_SIGNAL_FUNC(nsComponentsDlg::Next), gCtx->cdlg); // show back btn again after setup type dlg where we couldn't go back gtk_widget_set_sensitive(gCtx->back, TRUE); if (aDirection == nsXInstallerDlg::BACKWARD_MOVE) // from install dlg gtk_button_set_label(GTK_BUTTON(gCtx->next), GTK_STOCK_GO_FORWARD); return err; }
static void scripts_page_select_callback(GtkItem *item, gpointer d) { unsigned i = GPOINTER_TO_INT(d); gtk_notebook_set_page (GTK_NOTEBOOK (notebook), i); }
GtkWindow* PrefsDlg::BuildDialog() { PreferencesDialog_addInterfacePreferences(FreeCaller1<PreferencesPage&, Interface_constructPreferences>()); Mouse_registerPreferencesPage(); GtkWindow* dialog = create_floating_window("NetRadiant Preferences", m_parent); { GtkWidget* mainvbox = gtk_vbox_new(FALSE, 5); gtk_container_add(GTK_CONTAINER(dialog), mainvbox); gtk_container_set_border_width(GTK_CONTAINER(mainvbox), 5); gtk_widget_show(mainvbox); { GtkWidget* hbox = gtk_hbox_new(FALSE, 5); gtk_widget_show(hbox); gtk_box_pack_end(GTK_BOX(mainvbox), hbox, FALSE, TRUE, 0); { GtkButton* button = create_dialog_button("OK", G_CALLBACK(dialog_button_ok), &m_modal); gtk_box_pack_end(GTK_BOX(hbox), GTK_WIDGET(button), FALSE, FALSE, 0); } { GtkButton* button = create_dialog_button("Cancel", G_CALLBACK(dialog_button_cancel), &m_modal); gtk_box_pack_end(GTK_BOX(hbox), GTK_WIDGET(button), FALSE, FALSE, 0); } { GtkButton* button = create_dialog_button("Clean", G_CALLBACK(OnButtonClean), this); gtk_box_pack_end(GTK_BOX(hbox), GTK_WIDGET(button), FALSE, FALSE, 0); } } { GtkWidget* hbox = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(mainvbox), hbox, TRUE, TRUE, 0); gtk_widget_show(hbox); { GtkWidget* sc_win = gtk_scrolled_window_new(0, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sc_win), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(GTK_BOX(hbox), sc_win, FALSE, FALSE, 0); gtk_widget_show(sc_win); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sc_win), GTK_SHADOW_IN); // prefs pages notebook m_notebook = gtk_notebook_new(); // hide the notebook tabs since its not supposed to look like a notebook gtk_notebook_set_show_tabs(GTK_NOTEBOOK(m_notebook), FALSE); gtk_box_pack_start(GTK_BOX(hbox), m_notebook, TRUE, TRUE, 0); gtk_widget_show(m_notebook); { GtkTreeStore* store = gtk_tree_store_new(2, G_TYPE_STRING, G_TYPE_POINTER); GtkWidget* view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE); { GtkCellRenderer* renderer = gtk_cell_renderer_text_new(); GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes("Preferences", renderer, "text", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(view), column); } { GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view)); g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(treeSelection), this); } gtk_widget_show(view); gtk_container_add(GTK_CONTAINER (sc_win), view); { /********************************************************************/ /* Add preference tree options */ /********************************************************************/ // Front page... //GtkWidget* front = PreferencePages_addPage(m_notebook, "Front Page"); { GtkWidget* global = PreferencePages_addPage(m_notebook, "Global Preferences"); { PreferencesPage preferencesPage(*this, getVBox(global)); Global_constructPreferences(preferencesPage); } GtkTreeIter group = PreferenceTree_appendPage(store, 0, "Global", global); { GtkWidget* game = PreferencePages_addPage(m_notebook, "Game"); PreferencesPage preferencesPage(*this, getVBox(game)); g_GamesDialog.CreateGlobalFrame(preferencesPage); PreferenceTree_appendPage(store, &group, "Game", game); } } { GtkWidget* interfacePage = PreferencePages_addPage(m_notebook, "Interface Preferences"); { PreferencesPage preferencesPage(*this, getVBox(interfacePage)); PreferencesPageCallbacks_constructPage(g_interfacePreferences, preferencesPage); } GtkTreeIter group = PreferenceTree_appendPage(store, 0, "Interface", interfacePage); PreferenceTreeGroup preferenceGroup(*this, m_notebook, store, group); PreferenceGroupCallbacks_constructGroup(g_interfaceCallbacks, preferenceGroup); } { GtkWidget* display = PreferencePages_addPage(m_notebook, "Display Preferences"); { PreferencesPage preferencesPage(*this, getVBox(display)); PreferencesPageCallbacks_constructPage(g_displayPreferences, preferencesPage); } GtkTreeIter group = PreferenceTree_appendPage(store, 0, "Display", display); PreferenceTreeGroup preferenceGroup(*this, m_notebook, store, group); PreferenceGroupCallbacks_constructGroup(g_displayCallbacks, preferenceGroup); } { GtkWidget* settings = PreferencePages_addPage(m_notebook, "General Settings"); { PreferencesPage preferencesPage(*this, getVBox(settings)); PreferencesPageCallbacks_constructPage(g_settingsPreferences, preferencesPage); } GtkTreeIter group = PreferenceTree_appendPage(store, 0, "Settings", settings); PreferenceTreeGroup preferenceGroup(*this, m_notebook, store, group); PreferenceGroupCallbacks_constructGroup(g_settingsCallbacks, preferenceGroup); } } gtk_tree_view_expand_all(GTK_TREE_VIEW(view)); g_object_unref(G_OBJECT(store)); } } } } gtk_notebook_set_page(GTK_NOTEBOOK(m_notebook), 0); return dialog; }
void statistics_dialog (void) { GtkWidget *window; GtkWidget *main_vbox; GtkWidget *page; GtkWidget *hbox; GtkWidget *label; GtkWidget *button; int page_num = 0; server_stats_create (); collect_statistics (); window = dialog_create_modal_transient_window (_("Statistics"), TRUE, TRUE, GTK_SIGNAL_FUNC(statistics_save_geometry)); statistics_restore_geometry(window); main_vbox = gtk_vbox_new (FALSE, 8); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 8); gtk_container_add (GTK_CONTAINER (window), main_vbox); label = gtk_label_new (_("Statistics")); gtk_box_pack_start (GTK_BOX (main_vbox), label, FALSE, FALSE, 8); gtk_widget_show (label); stat_notebook = gtk_notebook_new (); gtk_notebook_set_tab_pos (GTK_NOTEBOOK (stat_notebook), GTK_POS_TOP); gtk_notebook_set_tab_hborder (GTK_NOTEBOOK (stat_notebook), 4); gtk_box_pack_start (GTK_BOX (main_vbox), stat_notebook, TRUE, TRUE, 0); page = server_stats_page (); label = gtk_label_new (_(srv_label)); gtk_widget_show (label); gtk_notebook_append_page (GTK_NOTEBOOK (stat_notebook), page, label); page = archs_stats_page (); label = gtk_label_new (_(arch_label)); gtk_widget_show (label); gtk_notebook_append_page (GTK_NOTEBOOK (stat_notebook), page, label); #ifdef USE_GEOIP page = country_stats_page (); label = gtk_label_new (_(country_label)); gtk_widget_show (label); gtk_notebook_append_page (GTK_NOTEBOOK (stat_notebook), page, label); #endif page_num = config_get_int ("/" CONFIG_FILE "/Statistics/page"); gtk_notebook_set_page (GTK_NOTEBOOK (stat_notebook), page_num); gtk_widget_show (stat_notebook); /* Close Button */ hbox = gtk_hbox_new (FALSE, 8); gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0); button = gtk_button_new_with_label (_("Close")); gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_set_usize (button, 80, -1); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (grab_defaults), NULL); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (gtk_widget_destroy), GTK_OBJECT (window)); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_widget_grab_default (button); gtk_widget_show (button); gtk_widget_show (hbox); gtk_widget_show (main_vbox); gtk_widget_show (window); gtk_main (); unregister_window (window); server_stats_destroy (); }
void wxMDIParentFrame::OnInternalIdle() { /* if a an MDI child window has just been inserted it has to be brought to the top in idle time. we simply set the last notebook page active as new pages can only be appended at the end */ if (m_justInserted) { GtkNotebook *notebook = GTK_NOTEBOOK(m_clientWindow->m_widget); gtk_notebook_set_page( notebook, g_list_length( notebook->children ) - 1 ); /* need to set the menubar of the child */ wxMDIChildFrame *active_child_frame = GetActiveChild(); if (active_child_frame != NULL) { wxMenuBar *menu_bar = active_child_frame->m_menuBar; if (menu_bar) { menu_bar->m_width = m_width; menu_bar->m_height = wxMENU_HEIGHT; gtk_pizza_set_size( GTK_PIZZA(m_mainWidget), menu_bar->m_widget, 0, 0, m_width, wxMENU_HEIGHT ); menu_bar->SetInvokingWindow(active_child_frame); } } m_justInserted = false; return; } wxFrame::OnInternalIdle(); wxMDIChildFrame *active_child_frame = GetActiveChild(); bool visible_child_menu = false; wxWindowList::compatibility_iterator node = m_clientWindow->GetChildren().GetFirst(); while (node) { wxMDIChildFrame *child_frame = wxDynamicCast( node->GetData(), wxMDIChildFrame ); if ( child_frame ) { wxMenuBar *menu_bar = child_frame->m_menuBar; if ( menu_bar ) { if (child_frame == active_child_frame) { if (menu_bar->Show(true)) { menu_bar->m_width = m_width; menu_bar->m_height = wxMENU_HEIGHT; gtk_pizza_set_size( GTK_PIZZA(m_mainWidget), menu_bar->m_widget, 0, 0, m_width, wxMENU_HEIGHT ); menu_bar->SetInvokingWindow( child_frame ); } visible_child_menu = true; } else { if (menu_bar->Show(false)) { menu_bar->UnsetInvokingWindow( child_frame ); } } } } node = node->GetNext(); } /* show/hide parent menu bar as required */ if ((m_frameMenuBar) && (m_frameMenuBar->IsShown() == visible_child_menu)) { if (visible_child_menu) { m_frameMenuBar->Show( false ); m_frameMenuBar->UnsetInvokingWindow( this ); } else { m_frameMenuBar->Show( true ); m_frameMenuBar->SetInvokingWindow( this ); m_frameMenuBar->m_width = m_width; m_frameMenuBar->m_height = wxMENU_HEIGHT; gtk_pizza_set_size( GTK_PIZZA(m_mainWidget), m_frameMenuBar->m_widget, 0, 0, m_width, wxMENU_HEIGHT ); } } }
static void select_country_server_type_callback(GtkWidget *widget, enum server_type type) { gtk_notebook_set_page (GTK_NOTEBOOK (country_notebook), srv_countries[type].notebookpage ); selected_country = type; }
static void select_server_type_callback(GtkWidget *widget, enum server_type type) { gtk_notebook_set_page (GTK_NOTEBOOK (arch_notebook), srv_archs[type].notebookpage ); selected_type = type; }
static gboolean dialog_select_source(int chan_num) { scope_vert_t *vert; scope_chan_t *chan; dialog_generic_t dialog; gchar *title, msg[BUFLEN]; int next, n, initial_page, row, initial_row, max_row; gchar *tab_label_text[3], *name; GtkWidget *hbox, *label, *notebk, *button; GtkAdjustment *adj; hal_pin_t *pin; hal_sig_t *sig; hal_param_t *param; vert = &(ctrl_usr->vert); chan = &(ctrl_usr->chan[chan_num - 1]); title = _("Select Channel Source"); snprintf(msg, BUFLEN - 1, _("Select a pin, signal, or parameter\n" "as the source for channel %d."), chan_num); /* create dialog window, disable resizing */ dialog.retval = 0; dialog.window = gtk_dialog_new(); dialog.app_data = &chan_num; /* set initial height of window */ gtk_widget_set_usize(GTK_WIDGET(dialog.window), -2, 300); /* allow user to grow but not shrink the window */ gtk_window_set_policy(GTK_WINDOW(dialog.window), FALSE, TRUE, FALSE); /* window should appear in center of screen */ gtk_window_set_position(GTK_WINDOW(dialog.window), GTK_WIN_POS_CENTER); /* set title */ gtk_window_set_title(GTK_WINDOW(dialog.window), title); /* display message */ label = gtk_label_new(msg); gtk_misc_set_padding(GTK_MISC(label), 15, 5); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog.window)->vbox), label, FALSE, TRUE, 0); /* a separator */ gtk_hseparator_new_in_box(GTK_DIALOG(dialog.window)->vbox, 0); /* create a notebook to hold pin, signal, and parameter lists */ notebk = gtk_notebook_new(); /* add the notebook to the dialog */ gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog.window)->vbox), notebk, TRUE, TRUE, 0); /* set overall notebook parameters */ gtk_notebook_set_homogeneous_tabs(GTK_NOTEBOOK(notebk), TRUE); gtk_signal_connect(GTK_OBJECT(notebk), "switch-page", GTK_SIGNAL_FUNC(change_page), &dialog); /* text for tab labels */ tab_label_text[0] = _("Pins"); tab_label_text[1] = _("Signals"); tab_label_text[2] = _("Parameters"); /* loop to create three identical tabs */ for (n = 0; n < 3; n++) { /* Create a scrolled window to display the list */ vert->windows[n] = gtk_scrolled_window_new(NULL, NULL); vert->adjs[n] = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(vert->windows[n])); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(vert->windows[n]), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_widget_show(vert->windows[n]); /* create a list to hold the data */ vert->lists[n] = gtk_clist_new(1); /* set up a callback for when the user selects a line */ gtk_signal_connect(GTK_OBJECT(vert->lists[n]), "select_row", GTK_SIGNAL_FUNC(selection_made), &dialog); gtk_signal_connect(GTK_OBJECT(vert->lists[n]), "key-press-event", GTK_SIGNAL_FUNC(search_for_entry), &dialog); /* It isn't necessary to shadow the border, but it looks nice :) */ gtk_clist_set_shadow_type(GTK_CLIST(vert->lists[n]), GTK_SHADOW_OUT); /* set list for single selection only */ gtk_clist_set_selection_mode(GTK_CLIST(vert->lists[n]), GTK_SELECTION_BROWSE); /* put the list into the scrolled window */ gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW (vert->windows[n]), vert->lists[n]); /* another way to do it - not sure which is better gtk_container_add(GTK_CONTAINER(vert->windows[n]), vert->lists[n]); */ gtk_widget_show(vert->lists[n]); /* create a box for the tab label */ hbox = gtk_hbox_new(TRUE, 0); /* create a label for the page */ gtk_label_new_in_box(tab_label_text[n], hbox, TRUE, TRUE, 0); gtk_widget_show(hbox); /* add page to the notebook */ gtk_notebook_append_page(GTK_NOTEBOOK(notebk), vert->windows[n], hbox); /* set tab attributes */ gtk_notebook_set_tab_label_packing(GTK_NOTEBOOK(notebk), hbox, TRUE, TRUE, GTK_PACK_START); } /* determine initial page: pin, signal, or parameter */ if (( chan->data_source_type >= 0 ) && ( chan->data_source_type <= 2 )) { initial_page = chan->data_source_type; gtk_notebook_set_page(GTK_NOTEBOOK(notebk), initial_page); } else { initial_page = -1; gtk_notebook_set_page(GTK_NOTEBOOK(notebk), 0); } gtk_widget_show(notebk); /* populate the pin, signal, and parameter lists */ gtk_clist_clear(GTK_CLIST(vert->lists[0])); gtk_clist_clear(GTK_CLIST(vert->lists[1])); gtk_clist_clear(GTK_CLIST(vert->lists[2])); rtapi_mutex_get(&(hal_data->mutex)); next = hal_data->pin_list_ptr; initial_row = -1; max_row = -1; while (next != 0) { pin = SHMPTR(next); name = pin->name; row = gtk_clist_append(GTK_CLIST(vert->lists[0]), &name); if ( initial_page == 0 ) { if ( strcmp(name, chan->name) == 0 ) { initial_row = row; } max_row = row; } next = pin->next_ptr; } next = hal_data->sig_list_ptr; while (next != 0) { sig = SHMPTR(next); name = sig->name; row = gtk_clist_append(GTK_CLIST(vert->lists[1]), &name); if ( initial_page == 1 ) { if ( strcmp(name, chan->name) == 0 ) { initial_row = row; } max_row = row; } next = sig->next_ptr; } next = hal_data->param_list_ptr; while (next != 0) { param = SHMPTR(next); name = param->name; row = gtk_clist_append(GTK_CLIST(vert->lists[2]), &name); if ( initial_page == 2 ) { if ( strcmp(name, chan->name) == 0 ) { initial_row = row; } max_row = row; } next = param->next_ptr; } rtapi_mutex_give(&(hal_data->mutex)); if ( initial_row >= 0 ) { /* highlight the currently selected name */ gtk_clist_select_row(GTK_CLIST(vert->lists[initial_page]), initial_row, -1); /* set scrolling window to show the highlighted name */ /* FIXME - I can't seem to get this to work */ adj = vert->adjs[initial_page]; adj->value = adj->lower + (adj->upper - adj->lower)*((double)(initial_row)/(double)(max_row+1)); gtk_adjustment_value_changed(vert->adjs[initial_page]); } /* set up a callback function when the window is destroyed */ gtk_signal_connect(GTK_OBJECT(dialog.window), "destroy", GTK_SIGNAL_FUNC(dialog_generic_destroyed), &dialog); /* make Cancel button */ button = gtk_button_new_with_label(_("Cancel")); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog.window)->action_area), button, TRUE, TRUE, 4); gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(dialog_generic_button2), &dialog); /* make window transient and modal */ gtk_window_set_transient_for(GTK_WINDOW(dialog.window), GTK_WINDOW(ctrl_usr->main_win)); gtk_window_set_modal(GTK_WINDOW(dialog.window), TRUE); gtk_widget_show_all(dialog.window); gtk_main(); /* we get here when the user makes a selection, hits Cancel, or closes the window */ vert->lists[0] = NULL; vert->lists[1] = NULL; vert->lists[2] = NULL; if ((dialog.retval == 0) || (dialog.retval == 2)) { /* user either closed dialog, or hit cancel */ return FALSE; } /* user made a selection */ channel_changed(); return TRUE; }
void browser_create (void) { GtkWidget *vbox; GdkPixmap *icon_pix; GdkBitmap *icon_mask; GtkAccelGroup *accel; GtkWidget *menu; GtkWidget *toolbar; GtkWidget *hpaned; GtkWidget *vpaned; GtkWidget *iconw; GtkWidget *hbox; GtkWidget *label; browser = g_new (Browser, 1); browser->current_path = g_string_new (conf.startup_dir); browser->last_path = g_string_new (""); browser->filelist = (FileList *) file_list_init (); browser->window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (browser->window), "PornView"); gtk_widget_realize (browser->window); icon_pix = gdk_pixmap_create_from_xpm_d (G_WINDOW (browser->window), &icon_mask, NULL, pornview_xpm); gdk_window_set_icon (G_WINDOW (browser->window), NULL, icon_pix, icon_mask); gtk_signal_connect (GTK_OBJECT (browser->window), "delete_event", GTK_SIGNAL_FUNC (browser_destroy), NULL); gtk_window_set_default_size (GTK_WINDOW (browser->window), conf.window_width, conf.window_height); vbox = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox); gtk_container_add (GTK_CONTAINER (browser->window), vbox); /* * main menu */ accel = gtk_accel_group_new (); browser->menu = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<browser_menu>", accel); #ifdef ENABLE_NLS gtk_item_factory_set_translate_func (browser->menu, (GtkTranslateFunc) menu_translate, NULL, NULL); #endif gtk_item_factory_create_items (browser->menu, browser_menu_factory_count, browser_menu_factory, NULL); menu = gtk_item_factory_get_widget (browser->menu, "<browser_menu>"); gtk_box_pack_start (GTK_BOX (vbox), menu, FALSE, FALSE, 0); gtk_widget_show (menu); #ifndef USE_GTK2 gtk_accel_group_attach (accel, GTK_OBJECT (browser->window)); #endif /* * toolbar */ #ifdef USE_GTK2 toolbar = gtk_toolbar_new (); #else toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_ICONS); #endif gtk_box_pack_start (GTK_BOX (vbox), toolbar, FALSE, TRUE, 0); gtk_widget_show (toolbar); iconw = pixbuf_create_pixmap_from_xpm_data (exit_xpm); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), NULL, _("Exit"), NULL, iconw, (GtkSignalFunc) browser_destroy, NULL); #ifndef USE_GTK2 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar)); #endif gtk_toolbar_append_space (GTK_TOOLBAR (toolbar)); iconw = pixbuf_create_pixmap_from_xpm_data (options_xpm); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), NULL, _("Preference"), NULL, iconw, (GtkSignalFunc) browser_prefs, NULL); hpaned = gedo_hpaned_new (); gtk_container_add (GTK_CONTAINER (vbox), hpaned); gtk_widget_show (hpaned); vpaned = gedo_vpaned_new (); gtk_widget_show (vpaned); gedo_paned_add1 (GEDO_PANED (hpaned), vpaned); /* * dirtree */ dirview_create (conf.startup_dir, browser->window); gedo_paned_add1 (GEDO_PANED (vpaned), DIRVIEW_CONTAINER); commentview = comment_view_create (); browser->notebook = commentview->notebook; /* * videoplay */ #ifdef ENABLE_MOVIE videoplay_create (); label = gtk_label_new (_(" Preview ")); gtk_notebook_prepend_page (GTK_NOTEBOOK (browser->notebook), VIDEOPLAY_CONTAINER, label); gtk_notebook_set_page (GTK_NOTEBOOK (browser->notebook), 0); #endif /* * imageview */ imageview_create (); label = gtk_label_new (_(" Preview ")); gtk_notebook_prepend_page (GTK_NOTEBOOK (browser->notebook), IMAGEVIEW_CONTAINER, label); #ifndef ENABLE_MOVIE gtk_notebook_set_page (GTK_NOTEBOOK (browser->notebook), 0); #endif gedo_paned_add2 (GEDO_PANED (hpaned), commentview->main_vbox); /* * thumbview */ thumbview_create (browser->window); gedo_paned_add2 (GEDO_PANED (vpaned), THUMBVIEW_CONTAINER); /* * statusbar */ hbox = gtk_hbox_new (FALSE, 0); gtk_widget_set_name (hbox, "StatusBarContainer"); gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); browser->status_dir = gtk_statusbar_new (); gtk_widget_set_name (browser->status_dir, "StatusBar1"); gtk_container_border_width (GTK_CONTAINER (browser->status_dir), 1); gtk_widget_set_usize (browser->status_dir, 80, 15); gtk_box_pack_start (GTK_BOX (hbox), browser->status_dir, FALSE, FALSE, 0); gtk_widget_show (browser->status_dir); browser->status_name = gtk_statusbar_new (); gtk_widget_set_name (browser->status_name, "StatusBar2"); gtk_container_border_width (GTK_CONTAINER (browser->status_name), 1); gtk_widget_set_usize (browser->status_name, 150, -1); gtk_box_pack_start (GTK_BOX (hbox), browser->status_name, TRUE, TRUE, 0); gtk_widget_show (browser->status_name); browser->status_image = gtk_statusbar_new (); gtk_widget_set_name (browser->status_image, "StatusBar3"); gtk_container_border_width (GTK_CONTAINER (browser->status_image), 1); gtk_widget_set_usize (browser->status_image, 150, -1); gtk_box_pack_start (GTK_BOX (hbox), browser->status_image, TRUE, TRUE, 0); gtk_widget_show (browser->status_image); browser->progress = gtk_progress_bar_new (); gtk_widget_set_name (browser->progress, "ProgressBar"); gtk_box_pack_end (GTK_BOX (hbox), browser->progress, FALSE, FALSE, 0); gtk_widget_show (browser->progress); gtk_widget_show (browser->window); #ifdef ENABLE_MOVIE gtk_widget_hide (gtk_notebook_get_nth_page (GTK_NOTEBOOK (browser->notebook), 1)); gtk_notebook_set_page (GTK_NOTEBOOK (browser->notebook), 0); #endif dirview_scroll_center (); timer_id = gtk_timeout_add (100, cb_browser_select_dir, conf.startup_dir); }
int nsSetupTypeDlg::Show(int aDirection) { int err = OK; int numSetupTypes = 0; GtkWidget *radbtn; nsSetupType *currST = NULL; GtkWidget *frame = NULL; XI_VERIFY(gCtx); XI_VERIFY(gCtx->notebook); if (mWidgetsInit == FALSE) { // add a vbox as a page of the notebook mBox = gtk_vbox_new(FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(mBox), 12); gtk_notebook_append_page(GTK_NOTEBOOK(gCtx->notebook), mBox, NULL); mPageNum = gtk_notebook_get_current_page(GTK_NOTEBOOK(gCtx->notebook)); // add the top text label GtkWidget *msg0 = gtk_label_new(mMsg0); gtk_misc_set_alignment(GTK_MISC(msg0), 0.0, 0.5); gtk_box_pack_start(GTK_BOX(mBox), msg0, FALSE, FALSE, 12); // for each setup type, pack into the vbox: // an hbox containing: (this is to pad the radio button on the right) // the radio button with short description // a label with the long description numSetupTypes = GetNumSetupTypes(); currST = GetSetupTypeList(); for (int i = 0; i < numSetupTypes; ++i, currST = currST->GetNext()) { if (i == 0) { radbtn = gtk_radio_button_new_with_mnemonic(NULL, currST->GetDescShort()); mRadioGroup = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radbtn)); } else { radbtn = gtk_radio_button_new_with_mnemonic(mRadioGroup, currST->GetDescShort()); } GtkWidget *hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), radbtn, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(mBox), hbox, FALSE, FALSE, 6); GtkWidget *desc = gtk_label_new(currST->GetDescLong()); gtk_label_set_line_wrap(GTK_LABEL(desc), TRUE); gtk_misc_set_alignment(GTK_MISC(desc), 0.0, 0.5); // Pad the labels so that they line up with the radio button text gint ind_size, ind_spacing; gtk_widget_style_get(radbtn, "indicator_size", &ind_size, "indicator_spacing", &ind_spacing, NULL); gtk_misc_set_padding(GTK_MISC(desc), ind_size + ind_spacing * 3, 0); gtk_box_pack_start(GTK_BOX(mBox), desc, FALSE, FALSE, 6); } frame = gtk_frame_new(gCtx->Res("DEST_DIR")); gtk_box_pack_start(GTK_BOX(mBox), frame, FALSE, FALSE, 12); GtkWidget *frame_hbox = gtk_hbox_new(FALSE, 6); gtk_container_set_border_width(GTK_CONTAINER(frame_hbox), 6); gtk_container_add(GTK_CONTAINER(frame), frame_hbox); if (!gCtx->opt->mDestination) { gCtx->opt->mDestination = (char*)malloc(MAXPATHLEN * sizeof(char)); getcwd(gCtx->opt->mDestination, MAXPATHLEN); } sFolder = gtk_label_new(gCtx->opt->mDestination); gtk_label_set_line_wrap(GTK_LABEL(sFolder), TRUE); gtk_misc_set_alignment(GTK_MISC(sFolder), 0.0, 0.5); gtk_box_pack_start(GTK_BOX(frame_hbox), sFolder, TRUE, TRUE, 0); sBrowseBtn = gtk_button_new_with_label(gCtx->Res("BROWSE")); gtk_box_pack_start(GTK_BOX(frame_hbox), sBrowseBtn, FALSE, FALSE, 0); mWidgetsInit = TRUE; } else { gtk_notebook_set_page(GTK_NOTEBOOK(gCtx->notebook), mPageNum); } // <b>title</b>\0 char *titleBuf = new char[strlen(mTitle) + 9]; sprintf(titleBuf, "<b>%s</b>", mTitle); gtk_label_set_markup(GTK_LABEL(gCtx->header_title), titleBuf); gtk_label_set_text(GTK_LABEL(gCtx->header_subtitle), mSubTitle); delete[] titleBuf; gtk_widget_show_all(mBox); // signal connect the buttons // NOTE: back button disfunctional in this dlg since user accepted license gCtx->backID = gtk_signal_connect(GTK_OBJECT(gCtx->back), "clicked", GTK_SIGNAL_FUNC(nsSetupTypeDlg::Back), gCtx->sdlg); gCtx->nextID = gtk_signal_connect(GTK_OBJECT(gCtx->next), "clicked", GTK_SIGNAL_FUNC(nsSetupTypeDlg::Next), gCtx->sdlg); sBrowseBtnID = gtk_signal_connect(GTK_OBJECT(sBrowseBtn), "clicked", GTK_SIGNAL_FUNC(nsSetupTypeDlg::SelectFolder), NULL); if (aDirection == nsXInstallerDlg::FORWARD_MOVE) { // change the button titles back to Back/Next gtk_button_set_label(GTK_BUTTON(gCtx->next), GTK_STOCK_GO_FORWARD); gtk_button_set_label(GTK_BUTTON(gCtx->back), GTK_STOCK_GO_BACK); } // from install dlg if (aDirection == nsXInstallerDlg::BACKWARD_MOVE && // not custom setup type gCtx->opt->mSetupType != (gCtx->sdlg->GetNumSetupTypes() - 1)) { DUMP("Back from Install to Setup Type"); gtk_button_set_label(GTK_BUTTON(gCtx->next), GTK_STOCK_GO_FORWARD); } gtk_widget_set_sensitive(gCtx->back, FALSE); return err; }