int nautilus_notebook_add_tab (NautilusNotebook *notebook, NautilusWindowSlot *slot, int position, gboolean jump_to) { GtkNotebook *gnotebook = GTK_NOTEBOOK (notebook); GtkWidget *tab_label; g_return_val_if_fail (NAUTILUS_IS_NOTEBOOK (notebook), -1); g_return_val_if_fail (NAUTILUS_IS_WINDOW_SLOT (slot), -1); tab_label = build_tab_label (notebook, slot); position = gtk_notebook_insert_page (GTK_NOTEBOOK (notebook), GTK_WIDGET (slot), tab_label, position); gtk_container_child_set (GTK_CONTAINER (notebook), GTK_WIDGET (slot), "tab-expand", TRUE, NULL); nautilus_notebook_sync_tab_label (notebook, slot); nautilus_notebook_sync_loading (notebook, slot); if (jump_to) { gtk_notebook_set_current_page (gnotebook, position); } return position; }
static void notebook_add_page(GtkWidget *notebook, const char* tab_name) { GtkListStore *store; GtkWidget *label; GtkWidget *child; GtkNotebook *nb = GTK_NOTEBOOK(notebook); gint page = gtk_notebook_get_current_page(nb); uint32_t addr; label = gtk_label_new(tab_name); gtk_widget_show(label); child = clist_create(&store); // display normal sscanf(tab_name, "%06x", &addr); clist_populate(store, addr, DUMP_SIZE); gtk_widget_show(child); gtk_notebook_insert_page(nb, child, label, page); gtk_notebook_set_current_page(nb, page); gtk_widget_grab_focus(child); }
static void bt_main_pages_add_tab (const BtMainPages * self, GtkWidget * content, gchar * str, gchar * icon, gchar * tip) { GtkWidget *label, *event_box, *box, *image; label = gtk_label_new (str); //gtk_label_set_ellipsize(GTK_LABEL(label),PANGO_ELLIPSIZE_END); gtk_widget_set_name (label, str); gtk_widget_show (label); image = gtk_image_new_from_icon_name (icon, GTK_ICON_SIZE_MENU); gtk_widget_show (image); box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, BOX_BORDER); gtk_widget_show (box); //gtk_box_pack_start(GTK_BOX(box),image,FALSE,FALSE,0); //gtk_box_pack_start(GTK_BOX(box),label,TRUE,FALSE,0); gtk_container_add (GTK_CONTAINER (box), image); gtk_container_add (GTK_CONTAINER (box), label); event_box = gtk_event_box_new (); g_object_set (event_box, "visible-window", FALSE, NULL); gtk_container_add (GTK_CONTAINER (event_box), box); gtk_widget_set_tooltip_text (event_box, tip); gtk_notebook_insert_page (GTK_NOTEBOOK (self), content, event_box, -1); }
static void create_side_panel(MainWindow *main_window){ /* Close button for the side bar */ GtkWidget *close_box = get_widget_from_builder(main_window, "sidepanelheader"); main_window->pclose_sidebar_button = gedit_close_button_new(); gtk_widget_set_tooltip_text(main_window->pclose_sidebar_button, _("Close side panel")); g_signal_connect(G_OBJECT(main_window->pclose_sidebar_button), "clicked", G_CALLBACK (side_panel_togle), main_window); gtk_widget_show(main_window->pclose_sidebar_button); gtk_box_pack_end(GTK_BOX(close_box), main_window->pclose_sidebar_button, FALSE, FALSE, 0); main_window->notebook_manager = get_widget_from_builder(main_window, "notebook_manager"); /* Classbrowser stuff creation */ GtkWidget *classbox = get_widget_from_builder(main_window, "classbox"); main_window->pclassbrowser = gphpedit_classbrowser_new (main_window); gtk_widget_show(main_window->pclassbrowser); gtk_box_pack_start(GTK_BOX(classbox), main_window->pclassbrowser, TRUE, TRUE, 0); /* File browser stuff creation */ if (get_preferences_manager_show_filebrowser(main_window->prefmg)) { main_window->pfolder= gphpedit_filebrowser_new(main_window); gtk_widget_show(main_window->pfolder); GtkWidget *label= gtk_image_new_from_icon_name ("file-manager", GTK_ICON_SIZE_SMALL_TOOLBAR); gtk_widget_show(label); gtk_notebook_insert_page (GTK_NOTEBOOK(main_window->notebook_manager), main_window->pfolder, label, 1); } }
/** * gedit_notebook_add_tab: * @nb: a #GeditNotebook * @tab: a #GeditTab * @position: the position where the @tab should be added * @jump_to: %TRUE to set the @tab as active * * Adds the specified @tab to the @nb. */ void gedit_notebook_add_tab (GeditNotebook *nb, GeditTab *tab, gint position, gboolean jump_to) { GtkWidget *tab_label; g_return_if_fail (GEDIT_IS_NOTEBOOK (nb)); g_return_if_fail (GEDIT_IS_TAB (tab)); tab_label = create_tab_label (nb, tab); gtk_notebook_insert_page (GTK_NOTEBOOK (nb), GTK_WIDGET (tab), tab_label, position); gtk_notebook_set_tab_reorderable (GTK_NOTEBOOK (nb), GTK_WIDGET (tab), TRUE); gtk_notebook_set_tab_detachable (GTK_NOTEBOOK (nb), GTK_WIDGET (tab), TRUE); /* The signal handler may have reordered the tabs */ position = gtk_notebook_page_num (GTK_NOTEBOOK (nb), GTK_WIDGET (tab)); if (jump_to) { gtk_notebook_set_current_page (GTK_NOTEBOOK (nb), position); gtk_widget_grab_focus (GTK_WIDGET (tab)); } }
/* Inserts in notebook a new page whose content is child, and whose bookmark * is tab_label. The page is inserted just before the page number position, * starting with 0. If position is out of bounds, it is assumed to be the * current number of pages. */ int clip_GTK_NOTEBOOKINSERTPAGE(ClipMachine * cm) { C_widget *cntb = _fetch_cw_arg(cm); C_widget *cchild = _fetch_cwidget(cm,_clip_spar(cm,2)); C_widget *clabel; GtkWidget *label; gint position = _clip_parni(cm,4); CHECKCWID(cntb,GTK_IS_NOTEBOOK); CHECKARG2(2,MAP_t,NUMERIC_t); CHECKCWID(cchild,GTK_IS_WIDGET); CHECKARG3(3,MAP_t,NUMERIC_t,CHARACTER_t); CHECKOPT(4,NUMERIC_t); if (_clip_parinfo(cm,3)==CHARACTER_t) { char * caption = _clip_parc(cm, 3); LOCALE_TO_UTF(caption); label = gtk_label_new_with_mnemonic(caption); FREE_TEXT(caption); } else { clabel = _fetch_cwidget(cm,_clip_spar(cm,3)); CHECKCWID(clabel,GTK_IS_WIDGET); if (clabel) label = clabel->widget; } if (_clip_parinfo(cm,4)==UNDEF_t) position = 1; gtk_notebook_insert_page(GTK_NOTEBOOK(cntb->widget), cchild->widget, label, position-1); return 0; err: return 1; }
void scale_init(void) { GtkWidget *nfr1, *nlbl, *vbox1; GtkWidget *b1; GtkWidget *cur_lbl; int scw, sch; char lbl[255]; nlbl = gtk_label_new("Image Scaling"); nfr1 = gtk_frame_new("Image Scaling"); gtk_container_set_border_width(GTK_CONTAINER(nfr1), 3); gtk_notebook_insert_page(GTK_NOTEBOOK(ModMdi), nfr1, nlbl, 6); gtk_widget_show(nlbl); gtk_widget_show(nfr1); vbox1 = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(nfr1), vbox1); b1 = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox1), b1, FALSE, TRUE, 0); imlib_context_set_image(im); scw = imlib_image_get_width(); sch = imlib_image_get_height(); sprintf(lbl, "Current Width: %d\nCurrent Height: %d\n", scw, sch); cur_lbl = gtk_label_new(lbl); gtk_box_pack_start(GTK_BOX(vbox1), cur_lbl, FALSE, TRUE, 0); gtk_widget_show(cur_lbl); gtk_widget_show(vbox1); gtk_widget_show(b1); }
/******************* Page d'affichage des règles *****************/ void create_show_rule_page(GtkNotebook * pNotebook){ 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")); pVBoxCentral = gtk_vbox_new(FALSE, 0); pVBoxSup = gtk_vbox_new(FALSE, 0); 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); // Insertion de la page avec le widget pVBoxCentral gtk_notebook_insert_page(GTK_NOTEBOOK(pNotebook), pVBoxCentral, pTabLabel,2); }
int ephy_notebook_add_tab (EphyNotebook *notebook, EphyEmbed *embed, int position, gboolean jump_to) { GtkNotebook *gnotebook = GTK_NOTEBOOK (notebook); g_assert (EPHY_IS_NOTEBOOK (notebook)); position = gtk_notebook_insert_page (GTK_NOTEBOOK (notebook), GTK_WIDGET (embed), NULL, position); gtk_container_child_set (GTK_CONTAINER (notebook), GTK_WIDGET (embed), "tab-expand", g_settings_get_boolean (EPHY_SETTINGS_UI, EPHY_PREFS_UI_EXPAND_TABS_BAR), NULL); if (jump_to) { gtk_notebook_set_current_page (gnotebook, position); g_object_set_data (G_OBJECT (embed), "jump_to", GINT_TO_POINTER (jump_to)); } return position; }
void setup_notebook_out(void) { const char ** ports_out; int i, j, k; char client_name[MAXLEN]; char client_name_prev[MAXLEN]; char port_name[MAXLEN]; GtkTreeIter iter; ports_out = jack_get_ports(jack_client, NULL, NULL, JackPortIsInput); for (j = 0; j < MAXLEN; j++) { client_name[j] = '\0'; client_name_prev[j] = '\0'; } i = 0; n_clients = -1; if (ports_out) { while (ports_out[i] != NULL) { /* get the client name */ j = 0; while ((ports_out[i][j] != ':') && (ports_out[i][j] != '\0')) { client_name[j] = ports_out[i][j]; j++; } client_name[j] = '\0'; /* create a new notebook page if needed */ if (strcmp(client_name, client_name_prev) != 0) { n_clients++; store_out_nb[n_clients] = gtk_list_store_new(1, G_TYPE_STRING); nb_out_labels[n_clients] = gtk_label_new(client_name); gtk_widget_show(nb_out_labels[n_clients]); gtk_notebook_insert_page(GTK_NOTEBOOK(nb_outs), GTK_WIDGET(setup_tree_out()), GTK_WIDGET(nb_out_labels[n_clients]), n_clients); } /* add the port to the list */ j = 0; while ((ports_out[i][j] != ':') && (ports_out[i][j] != '\0')) j++; if (ports_out[i][j] == '\0') fprintf(stderr, "ERROR: bad JACK port string: %s\n", ports_out[i]); else { k = 0; j++; while (ports_out[i][j] != '\0') port_name[k++] = ports_out[i][j++]; port_name[k] = '\0'; gtk_list_store_append(store_out_nb[n_clients], &iter); gtk_list_store_set(store_out_nb[n_clients], &iter, 0, port_name, -1); } strcpy(client_name_prev, client_name); i++; } free(ports_out); } }
void ui_playlist_notebook_create_tab(gint playlist) { GtkWidget *scrollwin, *treeview; GtkWidget *label, *entry, *ebox, *hbox; GtkAdjustment *vscroll; gint position = aud_playlist_get_position (playlist); scrollwin = gtk_scrolled_window_new(NULL, NULL); vscroll = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(scrollwin)); treeview = ui_playlist_widget_new(playlist); g_object_set_data(G_OBJECT(scrollwin), "treeview", treeview); gtk_container_add(GTK_CONTAINER(scrollwin), treeview); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_widget_show_all(scrollwin); ebox = gtk_event_box_new(); gtk_event_box_set_visible_window ((GtkEventBox *) ebox, FALSE); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); label = gtk_label_new (""); set_tab_label (playlist, (GtkLabel *) label); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); entry = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(hbox), entry, FALSE, FALSE, 0); gtk_container_add(GTK_CONTAINER(ebox), hbox); gtk_widget_show_all(ebox); gtk_widget_hide(entry); gtk_box_pack_end ((GtkBox *) hbox, make_close_button (playlist), FALSE, FALSE, 0); g_object_set_data(G_OBJECT(ebox), "label", label); g_object_set_data(G_OBJECT(ebox), "entry", entry); g_object_set_data(G_OBJECT(ebox), "page", scrollwin); gtk_notebook_insert_page (UI_PLAYLIST_NOTEBOOK, scrollwin, ebox, playlist); gtk_notebook_set_tab_reorderable(UI_PLAYLIST_NOTEBOOK, scrollwin, TRUE); g_object_set_data ((GObject *) treeview, "playlist-id", GINT_TO_POINTER (aud_playlist_get_unique_id (playlist))); if (position >= 0) { aud_playlist_select_all (playlist, FALSE); aud_playlist_entry_set_selected (playlist, position, TRUE); audgui_list_set_highlight (treeview, position); audgui_list_set_focus (treeview, position); } g_signal_connect(ebox, "button-press-event", G_CALLBACK(tab_button_press_cb), NULL); g_signal_connect(ebox, "key-press-event", G_CALLBACK(tab_key_press_cb), NULL); g_signal_connect(entry, "activate", G_CALLBACK(tab_title_save), ebox); g_signal_connect_swapped (vscroll, "value-changed", G_CALLBACK(ui_playlist_widget_scroll), treeview); }
void recreate_front_page(){ GtkWidget * pNotebook = dw->pNotebook; GtkWidget *pVBoxCentral; GtkWidget *pVBox1; GtkWidget *pVBox2; GtkWidget *pSeparatorH; GtkWidget *pButtonAddRule; //debug gint i = 0; GtkWidget *pLabel2; GtkWidget *pTabLabel; pSeparatorH = gtk_hseparator_new(); pButtonAddRule = gtk_button_new_with_label("AddRule"); g_signal_connect(G_OBJECT(pButtonAddRule),"clicked",G_CALLBACK(OnButtonAddRule),pNotebook); pVBoxCentral = gtk_vbox_new(FALSE, 0); pVBox1 = gtk_vbox_new(FALSE, 0); pVBox2 = gtk_vbox_new(FALSE, 0); //on ajoute tout cela dans dfp dfp->pVBoxCentral = pVBoxCentral; dfp->pVBox1 = pVBox1; dfp->pVBox2 = pVBox2; /* Creation des differents GtkLabel */ pTabLabel = gtk_label_new(g_strdup_printf("Nouvelle page %d", i)); pLabel2 = gtk_label_new(g_strdup_printf("Nouvo label Box 2:%d", i)); create_vbox_from_caract_list(GTK_BOX(pVBox1)); gtk_box_pack_start(GTK_BOX(pVBox2), pSeparatorH, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(pVBox2), pLabel2, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(pVBox2), pButtonAddRule, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(pVBoxCentral), pVBox1, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(pVBoxCentral), pVBox2, FALSE, FALSE, 0); gint current_page = gtk_notebook_get_current_page (GTK_NOTEBOOK(pNotebook)); printf("Current page = %d\n", current_page); // Insertion de la page avec le widget pLabel gtk_notebook_remove_page(GTK_NOTEBOOK(pNotebook),0); printf("On enleve une page\n"); gtk_notebook_insert_page(GTK_NOTEBOOK(pNotebook), pVBoxCentral, pTabLabel,0); 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(pNotebook),current_page); }
GtkWidget* GroupDialog_addPage(const char* tabLabel, GtkWidget* widget, const StringExportCallback& title) { GtkWidget* w = gtk_label_new(tabLabel); gtk_widget_show(w); GtkWidget* page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(g_GroupDlg.m_pNotebook), gtk_notebook_insert_page(GTK_NOTEBOOK(g_GroupDlg.m_pNotebook), widget, w, -1)); g_pages.push_back(title); return page; }
static GtkWidget *build_develop_panel(void) { develop_notebook = gtk_notebook_new(); gtk_notebook_set_show_tabs(GTK_NOTEBOOK(develop_notebook), FALSE); gtk_notebook_set_show_border(GTK_NOTEBOOK(develop_notebook), FALSE); gtk_widget_show(develop_notebook); gtk_notebook_insert_page(GTK_NOTEBOOK(develop_notebook), develop_build_page(), NULL, 0); gtk_notebook_insert_page(GTK_NOTEBOOK(develop_notebook), discard_build_page(), NULL, 1); gtk_notebook_insert_page(GTK_NOTEBOOK(develop_notebook), gold_build_page(), NULL, 2); gtk_notebook_insert_page(GTK_NOTEBOOK(develop_notebook), prompt_build_page(), NULL, 3); return develop_notebook; }
void gcal_editable_set_edit_widget (GcalEditable *editable, GtkWidget *widget) { g_return_if_fail (GCAL_IS_EDITABLE (editable)); if (gtk_notebook_get_nth_page (GTK_NOTEBOOK (editable), 1) != NULL) gtk_notebook_remove_page (GTK_NOTEBOOK (editable), 1); gtk_notebook_insert_page (GTK_NOTEBOOK (editable), widget, NULL, 1); }
girara_tab_t* girara_tab_new(girara_session_t* session, const char* title, GtkWidget* widget, bool next_to_current, void* data) { if (session == NULL || widget == NULL) { return NULL; } girara_tab_t* tab = g_slice_new(girara_tab_t); tab->title = title ? g_strdup(title) : g_strdup(UNTITLED_TAB_TITLE); tab->widget = widget; tab->session = session; tab->data = data; int position = (next_to_current) ? (gtk_notebook_get_current_page(session->gtk.tabs) + 1) : -1; /* insert tab into notebook */ if (gtk_notebook_insert_page(session->gtk.tabs, tab->widget, NULL, position) == -1) { g_free(tab->title); g_slice_free(girara_tab_t, tab); return NULL; } /* create tab label */ GtkWidget *tab_label = gtk_label_new(tab->title); GtkWidget *tab_event = gtk_event_box_new(); g_object_set_data(G_OBJECT(tab->widget), "event", (gpointer) tab_event); g_object_set_data(G_OBJECT(tab->widget), "label", (gpointer) tab_label); g_object_set_data(G_OBJECT(tab->widget), "tab", (gpointer) tab); g_signal_connect(G_OBJECT(tab_event), "button_press_event", G_CALLBACK(girara_callback_tab_clicked), tab); gtk_misc_set_alignment(GTK_MISC(tab_label), 0.0f, 0.0f); gtk_misc_set_padding(GTK_MISC(tab_label), 4, 4); gtk_widget_modify_font(tab_label, session->style.font); gtk_container_add(GTK_CONTAINER(tab_event), tab_label); gtk_box_pack_start(GTK_BOX(session->gtk.tabbar), tab_event, TRUE, TRUE, 0); gtk_box_reorder_child(GTK_BOX(session->gtk.tabbar), tab_event, position); gtk_widget_show_all(widget); gtk_widget_show_all(tab_event); gtk_notebook_set_current_page(session->gtk.tabs, position); girara_tab_update(session); return tab; }
static VALUE rg_insert_page(int argc, VALUE *argv, VALUE self) { VALUE pos, child, label; rb_scan_args(argc, argv, "21", &pos, &child, &label); gtk_notebook_insert_page(_SELF(self), RVAL2WIDGET(child), NIL_P(label) ? NULL : RVAL2WIDGET(label), NUM2INT(pos)); return self; }
static void create_vte(void) { GtkWidget *vte, *scrollbar, *hbox, *frame; vc->vte = vte = vf->vte_terminal_new(); scrollbar = gtk_vscrollbar_new(GTK_ADJUSTMENT(VTE_TERMINAL(vte)->adjustment)); GTK_WIDGET_UNSET_FLAGS(scrollbar, GTK_CAN_FOCUS); /* create menu now so copy/paste shortcuts work */ vc->menu = vte_create_popup_menu(); g_object_ref_sink(vc->menu); frame = gtk_frame_new(NULL); hbox = gtk_hbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(frame), hbox); gtk_box_pack_start(GTK_BOX(hbox), vte, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox), scrollbar, FALSE, FALSE, 0); /* set the default widget size first to prevent VTE expanding too much, * sometimes causing the hscrollbar to be too big or out of view. */ gtk_widget_set_size_request(GTK_WIDGET(vte), 10, 10); vf->vte_terminal_set_size(VTE_TERMINAL(vte), 30, 1); vf->vte_terminal_set_mouse_autohide(VTE_TERMINAL(vte), TRUE); vf->vte_terminal_set_word_chars(VTE_TERMINAL(vte), VTE_WORDCHARS); gtk_drag_dest_set(vte, GTK_DEST_DEFAULT_ALL, dnd_targets, G_N_ELEMENTS(dnd_targets), GDK_ACTION_COPY); g_signal_connect(vte, "child-exited", G_CALLBACK(vte_start), NULL); g_signal_connect(vte, "button-press-event", G_CALLBACK(vte_button_pressed), NULL); g_signal_connect(vte, "event", G_CALLBACK(vte_keypress_cb), NULL); g_signal_connect(vte, "key-release-event", G_CALLBACK(vte_keyrelease_cb), NULL); g_signal_connect(vte, "commit", G_CALLBACK(vte_commit_cb), NULL); g_signal_connect(vte, "motion-notify-event", G_CALLBACK(on_motion_event), NULL); g_signal_connect(vte, "drag-data-received", G_CALLBACK(vte_drag_data_received), NULL); // ktuan hack // void *tmp_obj = ktuan_callback(vte); // g_signal_connect(tmp_obj, "text-changed::insert", G_CALLBACK( g_signal_connect(vte, "ktuan-text-append", G_CALLBACK(ktuan_text_append), NULL); vte_start(vte); gtk_widget_show_all(frame); gtk_notebook_insert_page(GTK_NOTEBOOK(msgwindow.notebook), frame, gtk_label_new(_("Terminal")), MSG_VTE); g_signal_connect_after(vte, "realize", G_CALLBACK(on_vte_realize), NULL); }
static void page_initialized (CEPage *page, GError *error, gpointer user_data) { NMConnectionEditor *editor = NM_CONNECTION_EDITOR (user_data); GtkWidget *widget, *parent; GtkNotebook *notebook; GtkWidget *label; GList *children, *iter; gpointer order, child_order; int i; if (error) { gtk_widget_hide (editor->window); nm_connection_editor_error (editor->parent_window, _("Error initializing editor"), "%s", error->message); g_signal_emit (editor, editor_signals[EDITOR_DONE], 0, GTK_RESPONSE_NONE); return; } /* Add the page to the UI */ notebook = GTK_NOTEBOOK (gtk_builder_get_object (editor->builder, "notebook")); label = gtk_label_new (ce_page_get_title (page)); widget = ce_page_get_page (page); parent = gtk_widget_get_parent (widget); if (parent) gtk_container_remove (GTK_CONTAINER (parent), widget); order = g_object_get_data (G_OBJECT (page), ORDER_TAG); g_object_set_data (G_OBJECT (widget), ORDER_TAG, order); children = gtk_container_get_children (GTK_CONTAINER (notebook)); for (iter = children, i = 0; iter; iter = iter->next, i++) { child_order = g_object_get_data (G_OBJECT (iter->data), ORDER_TAG); if (child_order > order) break; } g_list_free (children); gtk_notebook_insert_page (notebook, widget, label, i); if (CE_IS_PAGE_VPN (page) && ce_page_vpn_can_export (CE_PAGE_VPN (page))) gtk_widget_show (editor->export_button); /* Move the page from the initializing list to the main page list */ editor->initializing_pages = g_slist_remove (editor->initializing_pages, page); editor->pages = g_slist_append (editor->pages, page); recheck_initialization (editor); }
void bastile_pkcs11_certificate_props_insert_view (BastilePkcs11CertificateProps *self, const gchar *title, GtkWidget *view, gint position) { BastilePkcs11CertificatePropsPrivate *pv = BASTILE_PKCS11_CERTIFICATE_PROPS_GET_PRIVATE (self); g_return_if_fail (BASTILE_IS_PKCS11_CERTIFICATE_PROPS (self)); g_return_if_fail (title); g_return_if_fail (GTK_IS_WIDGET (view)); g_return_if_fail (gtk_notebook_page_num (pv->tabs, view) == -1); gtk_notebook_insert_page (pv->tabs, view, gtk_label_new (title), position); }
static void update_information_page () { static GtkWidget *page; if (selected) { update_information_widget (); page = iwidget; } else { page = ilabel; } gtk_notebook_remove_page (GTK_NOTEBOOK (notebook), INFORMATION_TAB_POSITION); gtk_notebook_insert_page (GTK_NOTEBOOK (notebook), page, itablabel, INFORMATION_TAB_POSITION); }
void gui_set_game_params(const GameParams * params) { GList *list; GtkWidget *label; gmap->map = params->map; gmap->player_num = my_player_num(); gtk_widget_queue_resize(gmap->area); gui_toolbar_show_button("BuildRoad", params->num_build_type[BUILD_ROAD] > 0); gui_toolbar_show_button("BuildShip", params->num_build_type[BUILD_SHIP] > 0); gui_toolbar_show_button("MoveShip", params->num_build_type[BUILD_SHIP] > 0); gui_toolbar_show_button("BuildBridge", params->num_build_type[BUILD_BRIDGE] > 0); /* In theory, it is possible to play a game without cities */ gui_toolbar_show_button("BuildCity", params->num_build_type[BUILD_CITY] > 0); gui_toolbar_show_button("BuildCityWall", params->num_build_type[BUILD_CITY_WALL] > 0); identity_draw(); gui_set_vp_target_value(params->victory_points); list = rules_callback_list; while (list) { G_CALLBACK(list->data) (); list = g_list_next(list); } label = gtk_notebook_get_tab_label(GTK_NOTEBOOK(map_notebook), legend_page); g_object_ref(label); gtk_widget_destroy(legend_page); legend_page = legend_create_content(); gtk_notebook_insert_page(GTK_NOTEBOOK(map_notebook), legend_page, label, LEGEND_PAGE); if (!legend_page_enabled) gui_show_legend_page(FALSE); g_object_unref(label); }
//This function adds a new tab to the browser notebook each time its called void addNewTab( GtkWidget* Notebook, gpointer data){ Widget Window, TableHeading, HboxHeader, HboxLabel, NoteBook, Cancel, Add, Table,Image2,Image3; gint currentPageNum; gint nextPageNum; Image2=gtk_image_new_from_stock(GTK_STOCK_ADD,1); Image3=gtk_image_new_from_stock(GTK_STOCK_CANCEL,1); //seting the count of the notebook count =gtk_notebook_get_current_page(GTK_NOTEBOOK(Notebook)); web[count]=webkit_web_view_new(); //Number of tabs increase by one each time a tab is added NUMBER_OF_TABS++; HboxHeader = gtk_hbox_new( TRUE, 0); gtk_widget_set_size_request( HboxHeader, 200, 20); HboxLabel = gtk_label_new("The Bolf"); gtk_widget_set_size_request(HboxLabel, 95, 20); gtk_box_pack_start_defaults( GTK_BOX(HboxHeader), HboxLabel); Cancel = gtk_button_new(); gtk_container_add(GTK_CONTAINER(Cancel),Image3); gtk_button_set_relief( GTK_BUTTON( Cancel), GTK_RELIEF_NONE); //Connects signal related to close button g_signal_connect_swapped( G_OBJECT(Cancel), "clicked", G_CALLBACK(delete_tab), (gpointer) Notebook); gtk_box_pack_start_defaults( GTK_BOX(HboxHeader), Cancel); Add = gtk_button_new(); gtk_container_add(GTK_CONTAINER(Add),Image2); gtk_widget_set_size_request( Add, 20, 20); //Connects the Add to its callback function when clicked g_signal_connect_swapped( G_OBJECT(Add), "clicked", G_CALLBACK(addNewTab), (gpointer) Notebook); gtk_box_pack_start_defaults( GTK_BOX(HboxHeader), Add); gtk_widget_show_all(HboxHeader); //Table = gtk_table_new( 50, 50, FALSE); Table = BolfView(); currentPageNum = gtk_notebook_get_current_page(GTK_NOTEBOOK(Notebook)); //g_signal_connect(SearchButton, "clicked", G_CALLBACK(InputConnect), InputText); nextPageNum = currentPageNum + 1; gtk_notebook_insert_page( GTK_NOTEBOOK(Notebook), Table, HboxHeader, nextPageNum); gtk_notebook_next_page( GTK_NOTEBOOK(Notebook)); gtk_widget_show_all(Notebook); }
static void update_properties_page () { static GtkWidget *page; if (selected) { update_properties_widget (); page = pwidget; } else { page = plabel; } gtk_notebook_remove_page (GTK_NOTEBOOK (notebook), PROPERTIES_TAB_POSITION); gtk_notebook_insert_page (GTK_NOTEBOOK (notebook), page, ptablabel, PROPERTIES_TAB_POSITION); }
/*************** Page Frontale **************/ void create_front_page(GtkNotebook * pNotebook){ GtkWidget *pVBoxCentral; GtkWidget *pVBox1; GtkWidget *pVBox2; GtkWidget *pSeparatorH; GtkWidget *pButtonAddRule; GtkWidget *pScrollbar; //debug gint i = 0; GtkWidget *pLabel2; GtkWidget *pTabLabel; pSeparatorH = gtk_hseparator_new(); pButtonAddRule = gtk_button_new_with_label("AddRule"); g_signal_connect(G_OBJECT(pButtonAddRule),"clicked",G_CALLBACK(OnButtonAddRule),pNotebook); pVBoxCentral = gtk_vbox_new(FALSE, 0); pVBox1 = gtk_vbox_new(FALSE, 0); pVBox2 = gtk_vbox_new(FALSE, 0); //on ajoute tout cela dans dfp dfp->pVBoxCentral = pVBoxCentral; dfp->pVBox1 = pVBox1; dfp->pVBox2 = pVBox2; /* Creation des differents GtkLabel */ pTabLabel = gtk_label_new(g_strdup_printf("Page %d", i)); pLabel2 = gtk_label_new(g_strdup_printf("Label Box 2:%d", i)); create_vbox_from_caract_list(GTK_BOX(pVBox1)); gtk_box_pack_start(GTK_BOX(pVBox2), pSeparatorH, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(pVBox2), pLabel2, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(pVBox2), pButtonAddRule, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(pVBoxCentral), pVBox1, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(pVBoxCentral), pVBox2, FALSE, FALSE, 0); // Insertion de la page avec le widget pLabel gtk_notebook_insert_page(GTK_NOTEBOOK(pNotebook), pVBoxCentral, pTabLabel,1); }
static void update_logs_page () { static GtkWidget *page; if (selected) { update_logs_widget (); page = lwidget; } else { page = llabel; } gtk_notebook_remove_page (GTK_NOTEBOOK (notebook), LOGS_TAB_POSITION); gtk_notebook_insert_page (GTK_NOTEBOOK (notebook), page, ltablabel, LOGS_TAB_POSITION); }
/* Inserts a widget into the notebook widget at an index */ static gint luaH_notebook_insert(lua_State *L) { widget_t *w = luaH_checkudata(L, 1, &widget_class); widget_t *child = luaH_checkudata(L, 3, &widget_class); gint i = luaL_checknumber(L, 2); /* correct index */ if (i != -1) i--; i = gtk_notebook_insert_page(GTK_NOTEBOOK(w->widget), child->widget, NULL, i); /* return new index or nil */ if (!++i) return 0; lua_pushnumber(L, i); return 1; }
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); }
/** * Add a page to the Grisbi assistant. * * \param assistant Grisbi assistant to add a page to. * \param widget Widget containing the new page to insert. * \param position Number of the page to insert. Page 0 is * reserved to the explanation label. * \param prev Page to display when the "Previous" button is * clicked. * \param next Page to display when the "Next" button is clicked. * \param enter_callback A callback to connect to the "switch-page" callback * of the Grisbi assistant notebook. (the callback should * be : gboolean callback ( GtkWidget *assistant, gint new_page ) ) */ void gsb_assistant_add_page ( GtkWidget * assistant, GtkWidget * widget, gint position, gint prev, gint next, GCallback enter_callback ) { GtkWidget * notebook; gchar *tmpstr; notebook = g_object_get_data ( G_OBJECT(assistant), "notebook" ); gtk_notebook_insert_page ( GTK_NOTEBOOK(notebook), widget, gtk_label_new(NULL), position ); gsb_assistant_set_prev ( assistant, position, prev ); gsb_assistant_set_next ( assistant, position, next ); tmpstr = g_strdup_printf ( "enter%d", position ); g_object_set_data ( G_OBJECT(assistant), tmpstr, enter_callback ); g_free (tmpstr); gtk_widget_show_all ( widget ); }
int nemo_notebook_add_tab (NemoNotebook *notebook, NemoWindowSlot *slot, int position, gboolean jump_to) { GtkNotebook *gnotebook = GTK_NOTEBOOK (notebook); GtkWidget *tab_label; g_return_val_if_fail (NEMO_IS_NOTEBOOK (notebook), -1); g_return_val_if_fail (NEMO_IS_WINDOW_SLOT (slot), -1); tab_label = build_tab_label (notebook, slot); position = gtk_notebook_insert_page (GTK_NOTEBOOK (notebook), GTK_WIDGET (slot), tab_label, position); gtk_container_child_set (GTK_CONTAINER (notebook), GTK_WIDGET (slot), "tab-expand", TRUE, NULL); nemo_notebook_sync_tab_label (notebook, slot); nemo_notebook_sync_loading (notebook, slot); /* FIXME gtk bug! */ /* FIXME: this should be fixed in gtk 2.12; check & remove this! */ /* The signal handler may have reordered the tabs */ position = gtk_notebook_page_num (gnotebook, GTK_WIDGET (slot)); if (jump_to) { gtk_notebook_set_current_page (gnotebook, position); } return position; }