static GtkWidget *get_results_window(struct gui_entry *ge) { GtkWidget *win, *notebook, *vbox; if (ge->results_window) return ge->results_notebook; win = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(win), "Results"); gtk_window_set_default_size(GTK_WINDOW(win), 1024, 768); g_signal_connect(win, "delete-event", G_CALLBACK(results_window_delete), ge); g_signal_connect(win, "destroy", G_CALLBACK(results_window_delete), ge); vbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(win), vbox); ge->results_menu = get_results_menubar(win, ge); gtk_box_pack_start(GTK_BOX(vbox), ge->results_menu, FALSE, FALSE, 0); notebook = gtk_notebook_new(); gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook), 1); gtk_notebook_popup_enable(GTK_NOTEBOOK(notebook)); gtk_container_add(GTK_CONTAINER(vbox), notebook); ge->results_window = win; ge->results_notebook = notebook; return ge->results_notebook; }
bool wxMDIClientWindow::CreateClient( wxMDIParentFrame *parent, long style ) { m_needParent = true; m_insertCallback = (wxInsertChildFunction)wxInsertChildInMDI; if (!PreCreation( parent, wxDefaultPosition, wxDefaultSize ) || !CreateBase( parent, -1, wxDefaultPosition, wxDefaultSize, style, wxDefaultValidator, wxT("wxMDIClientWindow") )) { wxFAIL_MSG( wxT("wxMDIClientWindow creation failed") ); return false; } m_widget = gtk_notebook_new(); gtk_signal_connect( GTK_OBJECT(m_widget), "switch_page", GTK_SIGNAL_FUNC(gtk_mdi_page_change_callback), (gpointer)parent ); gtk_notebook_set_scrollable( GTK_NOTEBOOK(m_widget), 1 ); m_parent->DoAddChild( this ); PostCreation(); Show( true ); return true; }
/** * Gets called when the Application is started, creates the main window. */ void activate(GtkApplication *app, gpointer user_data) { GtkWidget *window; window = gtk_application_window_new(app); gtk_window_set_title(GTK_WINDOW(window), "PSV Kanu EFB"); gtk_window_set_default_size(GTK_WINDOW(window), 600, 300); g_signal_connect(G_OBJECT(window), "key-press-event", G_CALLBACK(on_key_pressed), NULL); GtkWidget *box_main; box_main = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); gtk_container_add(GTK_CONTAINER(window), box_main); GtkWidget *notebook_main; notebook_main = gtk_notebook_new(); gtk_box_pack_start(GTK_BOX(box_main), notebook_main, TRUE, TRUE, 0); gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook_main), TRUE); gtk_notebook_popup_enable(GTK_NOTEBOOK(notebook_main)); //KALENDER gtk_notebook_append_page(GTK_NOTEBOOK(notebook_main), calendar_get_instance(), gtk_label_new("Kalender")); gtk_notebook_set_tab_reorderable(GTK_NOTEBOOK(notebook_main), calendar_get_instance(), TRUE); //FAHRTENBUCH gtk_notebook_append_page(GTK_NOTEBOOK(notebook_main), efb_get_instance(), gtk_label_new("Fahrtenbuch")); gtk_notebook_set_tab_reorderable(GTK_NOTEBOOK(notebook_main), efb_get_instance(), TRUE); gtk_widget_show_all(window); }
accxq_t * accxq_new () { accxq_t *xq; xq = calloc (1, sizeof (accxq_t)); if (xq == NULL) { acc_err (_("Memory error\n")); return NULL; } ecco_init (); xq->widget = gtk_hbox_new (FALSE, 2); xq->pantab = gtk_notebook_new (); gtk_notebook_set_show_tabs (GTK_NOTEBOOK (xq->pantab), TRUE); gtk_notebook_set_scrollable (GTK_NOTEBOOK (xq->pantab), TRUE); gtk_notebook_set_show_border (GTK_NOTEBOOK (xq->pantab), TRUE); gtk_box_pack_start (GTK_BOX (xq->widget), xq->pantab, TRUE, TRUE, 2); accxq_onload (xq); if (g_xq == NULL) { g_xq = xq; } return xq; }
static void cedit_notebook_init (CeditNotebook *notebook) { notebook->priv = CEDIT_NOTEBOOK_GET_PRIVATE (notebook); notebook->priv->close_buttons_sensitive = TRUE; notebook->priv->tab_drag_and_drop_enabled = TRUE; gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE); gtk_notebook_set_show_border (GTK_NOTEBOOK (notebook), FALSE); gtk_notebook_set_show_tabs (GTK_NOTEBOOK (notebook), FALSE); notebook->priv->always_show_tabs = TRUE; g_signal_connect (notebook, "button-press-event", (GCallback)button_press_cb, NULL); g_signal_connect (notebook, "button-release-event", (GCallback)button_release_cb, NULL); gtk_widget_add_events (GTK_WIDGET (notebook), GDK_BUTTON1_MOTION_MASK); g_signal_connect_after (G_OBJECT (notebook), "switch_page", G_CALLBACK (cedit_notebook_switch_page_cb), NULL); }
widget_t * widget_notebook(widget_t *w) { w->index = luaH_notebook_index; w->newindex = luaH_notebook_newindex; w->destructor = notebook_destructor; /* create and setup notebook widget */ w->widget = gtk_notebook_new(); g_object_set_data(G_OBJECT(w->widget), "widget", (gpointer) w); gtk_notebook_set_show_border(GTK_NOTEBOOK(w->widget), FALSE); gtk_notebook_set_scrollable(GTK_NOTEBOOK(w->widget), TRUE); g_object_connect((GObject*)w->widget, "signal::focus-in-event", (GCallback)focus_cb, w, "signal::focus-out-event", (GCallback)focus_cb, w, "signal::key-press-event", (GCallback)key_press_cb, w, "signal::page-added", (GCallback)page_added_cb, w, "signal::page-removed", (GCallback)page_removed_cb, w, "signal::switch-page", (GCallback)switch_cb, w, "signal::parent-set", (GCallback)parent_set_cb, w, NULL); gtk_widget_show(w->widget); return w; }
static GtkWidget * notebook_new(GladeXML *xml, GladeWidgetInfo *info) { GtkWidget *notebook = gtk_notebook_new(); GList *tmp; for (tmp = info->attributes; tmp; tmp = tmp->next) { GladeAttribute *attr = tmp->data; if (!strcmp(attr->name, "popup_enable")) { if (attr->value[0] == 'T') gtk_notebook_popup_enable(GTK_NOTEBOOK(notebook)); else gtk_notebook_popup_disable(GTK_NOTEBOOK(notebook)); } else if (!strcmp(attr->name, "scrollable")) gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook), attr->value[0] == 'T'); else if (!strcmp(attr->name, "show_border")) gtk_notebook_set_show_border(GTK_NOTEBOOK(notebook), attr->value[0] == 'T'); else if (!strcmp(attr->name, "show_tabs")) gtk_notebook_set_show_tabs(GTK_NOTEBOOK(notebook), attr->value[0] == 'T'); else if (!strcmp(attr->name, "tab_pos")) gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook), glade_enum_from_string(GTK_TYPE_POSITION_TYPE, attr->value)); } return notebook; }
void Notebook::create(Window *wnd,uint32_t st) { if(style&NOTEBOOK_HIDE_TABS) { style &= ~NOTEBOOK_CLOSE_BUTTON; type = WIDGET_CONTAINER; } #ifdef USE_GTK component = gtk_notebook_new(); if(style&NOTEBOOK_HIDE_TABS) { gtk_notebook_set_show_tabs(GTK_NOTEBOOK(component),FALSE); } else { gtk_notebook_set_show_border(GTK_NOTEBOOK(component),FALSE); gtk_notebook_set_scrollable(GTK_NOTEBOOK(component),TRUE); gtk_notebook_set_tab_border(GTK_NOTEBOOK(component),3); gtk_notebook_set_tab_pos(GTK_NOTEBOOK(component),GTK_POS_TOP); g_signal_connect(G_OBJECT(component),"switch-page",G_CALLBACK(switch_page_event_callback),&selected); } #endif debug_output("Notebook::create()\n"); Widget::create(wnd,0); #ifdef USE_WIN32 captureEvents(); #endif }
static void caja_notebook_init (CajaNotebook *notebook) { #if GTK_CHECK_VERSION (3, 0, 0) GtkStyleContext *context; context = gtk_widget_get_style_context (GTK_WIDGET (notebook)); gtk_style_context_add_class (context, "caja-notebook"); #endif gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE); gtk_notebook_set_show_border (GTK_NOTEBOOK (notebook), FALSE); gtk_notebook_set_show_tabs (GTK_NOTEBOOK (notebook), FALSE); g_signal_connect (notebook, "button-press-event", (GCallback)button_press_cb, NULL); /* Set up drag-and-drop target */ /* TODO this would be used for opening a new tab. * It will only work properly as soon as GtkNotebook * supports to find out whether a particular point * is on a tab button or not. */ #if 0 gtk_drag_dest_set (GTK_WIDGET (notebook), 0, url_drag_types, G_N_ELEMENTS (url_drag_types), GDK_ACTION_LINK); gtk_drag_dest_set_track_motion (GTK_WIDGET (notebook), TRUE); #endif }
/* multiple plugin configure dialog * current_plugin can be NULL */ static void configure_plugins(Plugin *current_plugin) { GtkWidget *dialog, *vbox, *nb; GList *node; gint cur_page = -1; dialog = gtk_dialog_new_with_buttons(_("Configure Plugins"), GTK_WINDOW(main_widgets.window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_APPLY, GTK_RESPONSE_APPLY, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_widget_set_name(dialog, "GeanyDialog"); vbox = ui_dialog_vbox_new(GTK_DIALOG(dialog)); nb = gtk_notebook_new(); gtk_notebook_set_scrollable(GTK_NOTEBOOK(nb), TRUE); gtk_container_add(GTK_CONTAINER(vbox), nb); foreach_list(node, active_plugin_list) { Plugin *p = node->data; GtkWidget *page = create_pref_page(p, dialog); if (page) { GtkWidget *label = gtk_label_new(p->info.name); gint n = gtk_notebook_append_page(GTK_NOTEBOOK(nb), page, label); if (p == current_plugin) cur_page = n; } }
static void gam_app_init (GamApp *gam_app) { GamAppPrivate *priv; g_return_if_fail (GAM_IS_APP (gam_app)); priv = GAM_APP_GET_PRIVATE (gam_app); priv->gconf_client = gconf_client_get_default (); /*gconf_client_add_dir (priv->gconf_client, "/apps/PAW/PAWed/preferences", GCONF_CLIENT_PRELOAD_NONE, NULL);*/ priv->ui_manager = gtk_ui_manager_new (); priv->ui_accel_group = gtk_ui_manager_get_accel_group (priv->ui_manager); priv->main_action_group = gtk_action_group_new ("MainActions"); #ifdef ENABLE_NLS gtk_action_group_set_translation_domain (priv->main_action_group, GETTEXT_PACKAGE); #endif priv->status_bar = gtk_statusbar_new (); priv->tip_message_cid = gtk_statusbar_get_context_id (GTK_STATUSBAR (priv->status_bar), "GamAppToolTips"); priv->notebook = gtk_notebook_new (); gtk_notebook_set_scrollable (GTK_NOTEBOOK (priv->notebook), TRUE); gtk_notebook_set_tab_pos (GTK_NOTEBOOK (priv->notebook), GTK_POS_TOP); priv->view_mixers_cb_active=TRUE; }
/* setup the main window */ static void new_window() { window *w = g_new0(window, 1); term_data_id = g_quark_from_static_string("svte"); w->notebook = gtk_notebook_new(); gtk_notebook_set_show_border(GTK_NOTEBOOK(w->notebook), FALSE); gtk_notebook_set_scrollable(GTK_NOTEBOOK(w->notebook), TRUE); w->win = gtk_window_new(GTK_WINDOW_TOPLEVEL); if (config->fullscreen) { gtk_window_fullscreen(GTK_WINDOW(w->win)); } gtk_window_set_default_size(GTK_WINDOW(w->win), config->window_width, config->window_height); gtk_container_add(GTK_CONTAINER(w->win), w->notebook); tab_new(w); gtk_widget_show_all(w->win); /* add the callback signals */ g_signal_connect(G_OBJECT(w->win), "key-press-event", G_CALLBACK(event_key), w); g_signal_connect(G_OBJECT(w->notebook), "switch-page", G_CALLBACK(tab_focus), w); g_signal_connect(G_OBJECT(w->win), "destroy", G_CALLBACK(window_destroy), w); set_window_title(get_current_term(w)); }
bool wxMDIClientWindow::CreateClient(wxMDIParentFrame *parent, long style) { if ( !PreCreation( parent, wxDefaultPosition, wxDefaultSize ) || !CreateBase( parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, style, wxDefaultValidator, "wxMDIClientWindow" )) { wxFAIL_MSG( "wxMDIClientWindow creation failed" ); return false; } m_widget = gtk_notebook_new(); g_object_ref(m_widget); g_signal_connect(m_widget, "switch_page", G_CALLBACK(switch_page), parent); gtk_notebook_set_scrollable( GTK_NOTEBOOK(m_widget), 1 ); m_parent->DoAddChild( this ); PostCreation(); Show( true ); return true; }
static tabwin_t *make_tabbed_viewer (int role) { tabwin_t *tabwin; GtkWidget *vbox; tabwin = mymalloc(sizeof *tabwin); if (tabwin == NULL) { return NULL; } tabwin->role = role; tabwin->dialog = NULL; tabwin->dlg_owner = NULL; /* top-level window */ tabwin->main = gtk_window_new(GTK_WINDOW_TOPLEVEL); if (role == EDIT_SCRIPT) { gtk_window_set_title(GTK_WINDOW(tabwin->main), _("gretl: script editor")); g_signal_connect(G_OBJECT(tabwin->main), "delete-event", G_CALLBACK(tabedit_quit_check), tabwin); } else { gtk_window_set_title(GTK_WINDOW(tabwin->main), _("gretl: models")); } g_signal_connect(G_OBJECT(tabwin->main), "destroy", G_CALLBACK(tabwin_destroy), tabwin); g_object_set_data(G_OBJECT(tabwin->main), "tabwin", tabwin); /* vertically oriented container */ vbox = gtk_vbox_new(FALSE, 1); gtk_box_set_spacing(GTK_BOX(vbox), 0); gtk_container_set_border_width(GTK_CONTAINER(vbox), 0); gtk_container_add(GTK_CONTAINER(tabwin->main), vbox); /* box to hold menu bar */ tabwin->hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), tabwin->hbox, FALSE, FALSE, 0); tabwin->mbar = NULL; /* notebook with its signal handlers */ tabwin->tabs = gtk_notebook_new(); gtk_notebook_set_scrollable(GTK_NOTEBOOK(tabwin->tabs), TRUE); g_signal_connect(G_OBJECT(tabwin->tabs), "switch-page", G_CALLBACK(switch_page_callback), tabwin); g_signal_connect(G_OBJECT(tabwin->tabs), "create-window", G_CALLBACK(detach_tab_callback), tabwin); g_signal_connect(G_OBJECT(tabwin->tabs), "page-added", G_CALLBACK(page_added_callback), tabwin); g_signal_connect(G_OBJECT(tabwin->tabs), "page-removed", G_CALLBACK(page_removed_callback), tabwin); gtk_container_add(GTK_CONTAINER(vbox), tabwin->tabs); #ifndef G_OS_WIN32 set_wm_icon(tabwin->main); #endif return tabwin; }
static void gnm_notebook_init (GnmNotebook *notebook) { gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE); gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_BOTTOM); gtk_notebook_set_show_border (GTK_NOTEBOOK (notebook), FALSE); gtk_notebook_set_group_name (GTK_NOTEBOOK (notebook), "Gnumeric"); }
int main (int argc, char **argv) { GtkWidget *window; GtkWidget *hbox; GtkWidget *tree; /* Most code in gtk-demo is intended to be exemplary, but not * these few lines, which are just a hack so gtk-demo will work * in the GTK tree without installing it. */ if (g_file_test ("../../modules/input/immodules.cache", G_FILE_TEST_EXISTS)) { g_setenv ("GTK_IM_MODULE_FILE", "../../modules/input/immodules.cache", TRUE); } /* -- End of hack -- */ gtk_init (&argc, &argv); setup_default_icon (); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "GTK+ Code Demos"); g_signal_connect_after (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_container_add (GTK_CONTAINER (window), hbox); tree = create_tree (); gtk_box_pack_start (GTK_BOX (hbox), tree, FALSE, FALSE, 0); notebook = gtk_notebook_new (); gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE); gtk_box_pack_start (GTK_BOX (hbox), notebook, TRUE, TRUE, 0); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), create_text (&info_view, FALSE), gtk_label_new_with_mnemonic ("_Info")); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), create_text (&source_view, TRUE), gtk_label_new_with_mnemonic ("_Source")); gtk_window_set_default_size (GTK_WINDOW (window), 600, 400); gtk_widget_show_all (window); load_file (gtk_demos[0].name, gtk_demos[0].filename); gtk_main (); return 0; }
gint main (gint argc, gchar **argv) { GtkWidget *window; GtkWidget *widget; gtk_init (&argc, &argv); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "Toplevel widget embedding example"); g_signal_connect (window, "destroy", gtk_main_quit, NULL); notebook = gtk_notebook_new (); gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE); gtk_container_add (GTK_CONTAINER (window), notebook); gtk_widget_realize (notebook); widget = gtk_about_dialog_new (); toplevel_delete_event (widget, NULL, NULL); g_signal_connect (widget, "delete-event", G_CALLBACK (toplevel_delete_event), NULL); widget = gtk_file_chooser_dialog_new ("the chooser", NULL, GTK_FILE_CHOOSER_ACTION_OPEN, NULL, NULL); toplevel_delete_event (widget, NULL, NULL); g_signal_connect (widget, "delete-event", G_CALLBACK (toplevel_delete_event), NULL); widget = gtk_color_chooser_dialog_new ("the colorsel", NULL); toplevel_delete_event (widget, NULL, NULL); g_signal_connect (widget, "delete-event", G_CALLBACK (toplevel_delete_event), NULL); widget = gtk_font_chooser_dialog_new ("the fontsel", NULL); toplevel_delete_event (widget, NULL, NULL); g_signal_connect (widget, "delete-event", G_CALLBACK (toplevel_delete_event), NULL); widget = gtk_recent_chooser_dialog_new ("the recent chooser", NULL, "_Cancel", GTK_RESPONSE_CANCEL, "_Open", GTK_RESPONSE_ACCEPT, NULL); toplevel_delete_event (widget, NULL, NULL); g_signal_connect (widget, "delete-event", G_CALLBACK (toplevel_delete_event), NULL); widget = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, "Do you have any questions ?"); toplevel_delete_event (widget, NULL, NULL); g_signal_connect (widget, "delete-event", G_CALLBACK (toplevel_delete_event), NULL); gtk_widget_show_all (window); gtk_main (); return 0; }
/* Sets whether the bookmarks area may be scrollable or not if there are * too many bookmarks to fit in the allocated area. */ int clip_GTK_NOTEBOOKSETSCROLLABLE(ClipMachine * cm) { C_widget *cntb = _fetch_cw_arg(cm); gboolean scrollable = _clip_parl(cm,2); CHECKCWID(cntb,GTK_IS_NOTEBOOK); CHECKOPT(2,LOGICAL_t); if (_clip_parinfo(cm,2)==UNDEF_t) scrollable = TRUE; gtk_notebook_set_scrollable(GTK_NOTEBOOK(cntb->widget), scrollable); return 0; err: return 1; }
void interface (gint argc, gchar *argv[]) { GtkWidget *MenuBar; GtkWidget *VBox; GtkWidget *HandleBox; gtk_set_locale(); gtk_init (&argc, &argv); Settings = init_settings (); MainWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW(MainWindow), g_strconcat (WELCOME_MSG, " ", APP_NAME, " ", VERSION_NUMBER, NULL)); gtk_window_set_policy (GTK_WINDOW(MainWindow), TRUE, TRUE, FALSE); gtk_widget_set_usize (MainWindow, MAIN_WINDOW_WIDTH, MAIN_WINDOW_HEIGHT); gtk_signal_connect (GTK_OBJECT(MainWindow), "delete_event", (GtkSignalFunc) quit, NULL); gtk_signal_connect (GTK_OBJECT(MainWindow), "destroy", (GtkSignalFunc) quit, NULL); FileProperties = g_array_new (TRUE, FALSE, sizeof(t_fprops)); VBox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER(MainWindow), VBox); HandleBox = gtk_handle_box_new(); gtk_container_set_border_width (GTK_CONTAINER(HandleBox), 2); gtk_box_pack_start (GTK_BOX(VBox), HandleBox, FALSE, FALSE, 0); init_toolbar (GTK_BOX(VBox)); MainNotebook = gtk_notebook_new (); read_uedit_wordfile (WORDFILE); editor_init(); MenuBar = menubar_new (MainWindow); gtk_container_add (GTK_CONTAINER(HandleBox), MenuBar); gtk_notebook_popup_enable (GTK_NOTEBOOK(MainNotebook)); gtk_notebook_set_homogeneous_tabs (GTK_NOTEBOOK(MainNotebook), TRUE); gtk_notebook_set_scrollable (GTK_NOTEBOOK(MainNotebook), TRUE); gtk_box_pack_start (GTK_BOX(VBox), MainNotebook, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT(MainNotebook), "switch_page", (GtkSignalFunc) set_title, NULL); init_msgbar (GTK_BOX(VBox)); print_msg ("You're the welcome..."); command_line (argc, argv); autosave (AUTOSAVE_DELAY); gtk_widget_show_all (MainWindow); if (!MSGBAR_DISPLAY) hide_msgbar (); if (!TOOLBAR_DISPLAY) hide_toolbar (); gtk_timeout_add (80, (GtkFunction)display_line_column, NULL); gtk_main (); set_preferences_to_disk (&Settings, NULL); gtk_item_factory_dump_rc (g_strconcat (g_get_home_dir (), PATH_SEP_STRING, CONF_DIR, PATH_SEP_STRING, "AccelRC", NULL), NULL, FALSE); }
static void notebook_init(Notebook *notebook) { notebook -> tabs_showed = TRUE; GtkWidget *nb = GTK_WIDGET(notebook); gtk_notebook_set_group_name(GTK_NOTEBOOK(nb), "main_tabs"); gtk_notebook_set_scrollable(GTK_NOTEBOOK(nb), TRUE); gtk_widget_set_can_focus(nb, FALSE); //gtk_widget_set_size_request(nb, 200, 200); //gtk_window_resize(GTK_NOTEBOOK(nb), 600, 450); }
static void create_sheets(GtkWidget *parent) { GtkWidget *notebook; GtkWidget *separator; GSList *list; Sheet *sheet; GtkWidget *child; GtkWidget *label; GtkWidget *menu_label; separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (parent), separator, FALSE, TRUE, 3); gtk_widget_show(separator); notebook = gtk_notebook_new (); /* gtk_signal_connect (GTK_OBJECT (notebook), "switch_page", GTK_SIGNAL_FUNC (page_switch), NULL); */ gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP); gtk_notebook_set_show_tabs (GTK_NOTEBOOK (notebook), TRUE); gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE); gtk_notebook_popup_enable (GTK_NOTEBOOK (notebook)); gtk_container_set_border_width (GTK_CONTAINER (notebook), 1); gtk_box_pack_start (GTK_BOX (parent), notebook, TRUE, TRUE, 0); list = get_sheets_list(); while (list != NULL) { sheet = (Sheet *) list->data; label = gtk_label_new(gettext(sheet->name)); menu_label = gtk_label_new(gettext(sheet->name)); gtk_misc_set_alignment(GTK_MISC(menu_label), 0.0, 0.5); child = create_sheet_page(notebook, sheet); gtk_widget_show(label); gtk_widget_show(menu_label); gtk_widget_show_all(child); gtk_notebook_append_page_menu (GTK_NOTEBOOK (notebook), child, label, menu_label); list = g_slist_next(list); } gtk_widget_show(notebook); }
static void anjuta_msgman_instance_init (AnjutaMsgman * msgman) { gtk_notebook_set_scrollable (GTK_NOTEBOOK (msgman), TRUE); msgman->priv = g_new0(AnjutaMsgmanPriv, 1); msgman->priv->views = NULL; msgman->priv->tab_popup = create_tab_popup_menu(msgman); msgman->priv->tabber = anjuta_tabber_new (GTK_NOTEBOOK (msgman)); msgman->priv->button_group = NULL; g_signal_connect(msgman, "popup-menu", G_CALLBACK(on_msgman_popup_menu), msgman); g_signal_connect(msgman, "button-press-event", G_CALLBACK(on_tab_button_press_event), msgman); }
bool wxNotebook::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style, const wxString& name ) { m_needParent = true; m_acceptsFocus = true; m_insertCallback = (wxInsertChildFunction)wxInsertChildInNotebook; if ( (style & wxBK_ALIGN_MASK) == wxBK_DEFAULT ) style |= wxBK_TOP; if (!PreCreation( parent, pos, size ) || !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name )) { wxFAIL_MSG( wxT("wxNoteBook creation failed") ); return false; } m_widget = gtk_notebook_new(); gtk_notebook_set_scrollable( GTK_NOTEBOOK(m_widget), 1 ); g_signal_connect (m_widget, "switch_page", G_CALLBACK (gtk_notebook_page_changing_callback), this); g_signal_connect_after (m_widget, "switch_page", G_CALLBACK (gtk_notebook_page_changed_callback), this); m_parent->DoAddChild( this ); if (m_windowStyle & wxBK_RIGHT) gtk_notebook_set_tab_pos( GTK_NOTEBOOK(m_widget), GTK_POS_RIGHT ); if (m_windowStyle & wxBK_LEFT) gtk_notebook_set_tab_pos( GTK_NOTEBOOK(m_widget), GTK_POS_LEFT ); if (m_windowStyle & wxBK_BOTTOM) gtk_notebook_set_tab_pos( GTK_NOTEBOOK(m_widget), GTK_POS_BOTTOM ); g_signal_connect (m_widget, "key_press_event", G_CALLBACK (gtk_notebook_key_press_callback), this); PostCreation(size); g_signal_connect (m_widget, "realize", G_CALLBACK (gtk_notebook_realized_callback), this); return true; }
static GtkWidget* create_notebook_non_dragable_content (gchar **labels, const gchar *group, GtkPositionType pos) { GtkWidget *notebook, *title, *page, *action_widget; notebook = gtk_notebook_new (); gtk_widget_set_vexpand (notebook, TRUE); gtk_widget_set_hexpand (notebook, TRUE); action_widget = gtk_button_new_from_icon_name ("list-add-symbolic", GTK_ICON_SIZE_BUTTON); g_signal_connect (action_widget, "clicked", G_CALLBACK (action_clicked_cb), notebook); gtk_widget_show (action_widget); gtk_notebook_set_action_widget (GTK_NOTEBOOK (notebook), action_widget, GTK_PACK_END); g_signal_connect (notebook, "create-window", G_CALLBACK (window_creation_function), NULL); gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), pos); gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE); gtk_container_set_border_width (GTK_CONTAINER (notebook), 6); gtk_notebook_set_group_name (GTK_NOTEBOOK (notebook), group); while (*labels) { GtkWidget *button; button = gtk_button_new_with_label (*labels); /* Use GtkListBox since it bubbles up motion notify event, which can * experience more issues than GtkBox. */ page = gtk_list_box_new (); gtk_container_add (GTK_CONTAINER (page), button); title = gtk_label_new (*labels); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), page, title); gtk_notebook_set_tab_reorderable (GTK_NOTEBOOK (notebook), page, TRUE); gtk_notebook_set_tab_detachable (GTK_NOTEBOOK (notebook), page, TRUE); labels++; } g_signal_connect (GTK_NOTEBOOK (notebook), "page-reordered", G_CALLBACK (on_page_reordered), NULL); g_signal_connect_after (G_OBJECT (notebook), "drag-begin", G_CALLBACK (on_notebook_drag_begin), NULL); return notebook; }
static void page_holder_app_add_browser_cb (MidoriApp* app, MidoriBrowser* browser, MidoriExtension* extension) { GtkWidget* panel; GtkWidget* notebook; GtkWidget* toolbar; GtkToolItem* toolitem; panel = katze_object_get_object (browser, "panel"); notebook = gtk_notebook_new (); gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_RIGHT); gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE); gtk_widget_show (notebook); toolbar = gtk_toolbar_new (); gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_BOTH_HORIZ); gtk_toolbar_set_icon_size (GTK_TOOLBAR (toolbar), GTK_ICON_SIZE_BUTTON); gtk_widget_show (toolbar); toolitem = gtk_tool_button_new_from_stock (GTK_STOCK_JUMP_TO); gtk_tool_item_set_is_important (toolitem, TRUE); g_signal_connect (toolitem, "clicked", G_CALLBACK (page_holder_button_jump_to_clicked_cb), notebook); gtk_widget_show (GTK_WIDGET (toolitem)); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1); toolitem = gtk_separator_tool_item_new (); gtk_separator_tool_item_set_draw (GTK_SEPARATOR_TOOL_ITEM (toolitem), FALSE); gtk_tool_item_set_expand (toolitem, TRUE); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1); gtk_widget_show (GTK_WIDGET (toolitem)); toolitem = gtk_tool_button_new_from_stock (GTK_STOCK_ADD); gtk_tool_item_set_is_important (toolitem, TRUE); g_signal_connect (toolitem, "clicked", G_CALLBACK (page_holder_button_add_clicked_cb), notebook); gtk_widget_show (GTK_WIDGET (toolitem)); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1); midori_panel_append_widget (MIDORI_PANEL (panel), notebook, /* i18n: A panel showing a user specified web page */ STOCK_PAGE_HOLDER, _("Pageholder"), toolbar); g_signal_connect (extension, "deactivate", G_CALLBACK (page_holder_deactivate_cb), notebook); g_object_unref (panel); }
static void anjuta_docman_instance_init (AnjutaDocman *docman) { docman->priv = g_new0 (AnjutaDocmanPriv, 1); /*g_new0 NULL's all content docman->priv->popup_menu = NULL; docman->priv->popup_menu_det = NULL; docman->priv->fileselection = NULL; */ gtk_notebook_popup_enable (GTK_NOTEBOOK (docman)); gtk_notebook_set_scrollable (GTK_NOTEBOOK (docman), TRUE); g_signal_connect (G_OBJECT (docman), "switch-page", G_CALLBACK (on_notebook_switch_page), docman); /* update pages-list after re-ordering (or deleting) */ g_signal_connect (G_OBJECT (docman), "page-reordered", G_CALLBACK (on_notebook_page_reordered), docman); }
static GtkWidget * nimf_settings_build_main_window (NimfSettings *nsettings) { GtkWidget *window; GtkWidget *notebook; GList *schema_list = NULL; gchar **non_relocatable; gint i; window = gtk_application_window_new (nsettings->app); gtk_window_set_default_size (GTK_WINDOW (window), 640, 480); gtk_window_set_title (GTK_WINDOW (window), _("Nimf Settings")); gtk_window_set_icon_name (GTK_WINDOW (window), "nimf"); notebook = gtk_notebook_new (); gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_LEFT); gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE); gtk_container_add (GTK_CONTAINER (window), notebook); g_settings_schema_source_list_schemas (nsettings->schema_source, TRUE, &non_relocatable, NULL); for (i = 0; non_relocatable[i] != NULL; i++) if (g_str_has_prefix (non_relocatable[i], "org.nimf")) schema_list = g_list_prepend (schema_list, non_relocatable[i]); for (schema_list = g_list_sort (schema_list, (GCompareFunc) on_comparison); schema_list != NULL; schema_list = schema_list->next) { NimfSettingsPage *page; GtkWidget *scrolled_w; scrolled_w = gtk_scrolled_window_new (NULL, NULL); page = nimf_settings_page_new (nsettings, (const gchar *) schema_list->data); gtk_container_add (GTK_CONTAINER (scrolled_w), page->box); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), scrolled_w, page->label); g_ptr_array_add (nsettings->pages, page); } g_strfreev (non_relocatable); g_list_free (schema_list); return window; }
static void gedit_notebook_init (GeditNotebook *notebook) { GeditNotebookPrivate *priv; notebook->priv = gedit_notebook_get_instance_private (notebook); priv = notebook->priv; priv->close_buttons_sensitive = TRUE; gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE); gtk_notebook_set_show_border (GTK_NOTEBOOK (notebook), FALSE); gtk_notebook_set_show_tabs (GTK_NOTEBOOK (notebook), TRUE); gtk_notebook_set_group_name (GTK_NOTEBOOK (notebook), GEDIT_NOTEBOOK_GROUP_NAME); gtk_container_set_border_width (GTK_CONTAINER (notebook), 0); }
ZLGtkOptionsDialog::ZLGtkOptionsDialog(const ZLResource &resource, shared_ptr<ZLRunnable> applyAction) : ZLOptionsDialog(resource, applyAction) { myDialog = createGtkDialog(caption()); std::string okString = gtkButtonName(ZLDialogManager::OK_BUTTON); std::string cancelString = gtkButtonName(ZLDialogManager::CANCEL_BUTTON); gtk_dialog_add_button(myDialog, okString.c_str(), GTK_RESPONSE_ACCEPT); gtk_dialog_add_button(myDialog, cancelString.c_str(), GTK_RESPONSE_REJECT); myNotebook = GTK_NOTEBOOK(gtk_notebook_new()); gtk_notebook_set_scrollable(myNotebook, true); gtk_container_set_border_width(GTK_CONTAINER(myNotebook), 8); gtk_box_pack_start(GTK_BOX(myDialog->vbox), GTK_WIDGET(myNotebook), true, true, 0); gtk_widget_show(GTK_WIDGET(myNotebook)); gtk_window_resize(GTK_WINDOW(myDialog), 1000, 1000); }
void prefs_dialog_create(PrefsDialog *dialog) { GtkWidget *window; GtkWidget *vbox; GtkWidget *notebook; GtkWidget *confirm_area; GtkWidget *ok_btn; GtkWidget *cancel_btn; GtkWidget *apply_btn; g_return_if_fail(dialog != NULL); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_container_set_border_width (GTK_CONTAINER (window), 6); gtk_window_set_position (GTK_WINDOW(window), GTK_WIN_POS_CENTER); gtk_window_set_modal (GTK_WINDOW (window), TRUE); gtk_window_set_policy (GTK_WINDOW(window), FALSE, TRUE, FALSE); vbox = gtk_vbox_new (FALSE, 6); gtk_widget_show(vbox); gtk_container_add (GTK_CONTAINER (window), vbox); notebook = gtk_notebook_new (); gtk_widget_show(notebook); gtk_box_pack_start (GTK_BOX (vbox), notebook, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (notebook), 2); /* GTK_WIDGET_UNSET_FLAGS (notebook, GTK_CAN_FOCUS); */ gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE); gtkut_stock_button_set_create(&confirm_area, &ok_btn, GTK_STOCK_OK, &cancel_btn, GTK_STOCK_CANCEL, &apply_btn, GTK_STOCK_APPLY); gtk_widget_show(confirm_area); gtk_box_pack_end (GTK_BOX(vbox), confirm_area, FALSE, FALSE, 0); gtk_widget_grab_default(ok_btn); dialog->window = window; dialog->notebook = notebook; dialog->confirm_area = confirm_area; dialog->ok_btn = ok_btn; dialog->cancel_btn = cancel_btn; dialog->apply_btn = apply_btn; }