static GtkWidget * mug_toolbar (MugData * mugdata) { GtkWidget *toolbar; int i; struct { const char *stock_id; ToolAction action; } tools[] = { {"go-up", ACTION_PREV_MSG}, {"go-down", ACTION_NEXT_MSG}, {NULL, ACTION_SEPARATOR}, {"view-refresh", ACTION_REINDEX}, {NULL, ACTION_SEPARATOR}, {"help-about", ACTION_ABOUT}, {NULL, ACTION_SEPARATOR}, {"application-exit", ACTION_DO_QUIT}}; toolbar = gtk_toolbar_new (); for (i = 0; i != G_N_ELEMENTS (tools); ++i) { if (tools[i].action == ACTION_SEPARATOR) { /* separator? */ gtk_toolbar_insert (GTK_TOOLBAR (toolbar), gtk_separator_tool_item_new (), i); continue; } else /* nope: a real item */ gtk_toolbar_insert (GTK_TOOLBAR (toolbar), get_connected_tool_button (tools[i].stock_id, tools[i].action, mugdata), i); } return toolbar; }
/** Inserts a toolbar item before the Quit button, or after the previous plugin toolbar item. * A separator is added on the first call to this function, and will be shown when @a item is * shown; hidden when @a item is hidden. * @note You should still destroy @a item yourself, usually in @ref plugin_cleanup(). * @param plugin Must be @ref geany_plugin. * @param item The item to add. */ GEANY_API_SYMBOL void plugin_add_toolbar_item(GeanyPlugin *plugin, GtkToolItem *item) { GtkToolbar *toolbar = GTK_TOOLBAR(main_widgets.toolbar); gint pos; GeanyAutoSeparator *autosep; g_return_if_fail(plugin); autosep = &plugin->priv->toolbar_separator; if (!autosep->widget) { GtkToolItem *sep; pos = toolbar_get_insert_position(); sep = gtk_separator_tool_item_new(); gtk_toolbar_insert(toolbar, sep, pos); autosep->widget = GTK_WIDGET(sep); toolbar_item_ref(sep); } else { pos = gtk_toolbar_get_item_index(toolbar, GTK_TOOL_ITEM(autosep->widget)); g_return_if_fail(pos >= 0); } gtk_toolbar_insert(toolbar, item, pos + autosep->item_count + 1); toolbar_item_ref(item); /* hide the separator widget if there are no toolbar items showing for the plugin */ ui_auto_separator_add_ref(autosep, GTK_WIDGET(item)); }
static void remmina_main_create_quick_search(RemminaMain *remminamain) { GtkWidget *widget; GValue val = { 0 }; remminamain->priv->quick_search_separator = gtk_separator_tool_item_new(); gtk_toolbar_insert(GTK_TOOLBAR(remminamain->priv->toolbar), remminamain->priv->quick_search_separator, -1); remminamain->priv->quick_search_item = gtk_tool_item_new(); gtk_toolbar_insert(GTK_TOOLBAR(remminamain->priv->toolbar), remminamain->priv->quick_search_item, -1); widget = gtk_entry_new(); gtk_widget_show(widget); gtk_entry_set_icon_from_stock(GTK_ENTRY(widget), GTK_ENTRY_ICON_PRIMARY, GTK_STOCK_FIND); gtk_entry_set_icon_from_stock(GTK_ENTRY(widget), GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_CLEAR); gtk_entry_set_width_chars(GTK_ENTRY(widget), 25); gtk_container_add(GTK_CONTAINER(remminamain->priv->quick_search_item), widget); g_value_init(&val, G_TYPE_BOOLEAN); g_value_set_boolean(&val, FALSE); g_object_set_property(G_OBJECT(widget), "primary-icon-activatable", &val); g_value_unset(&val); g_signal_connect(G_OBJECT(widget), "icon-press", G_CALLBACK(remmina_main_quick_search_on_icon_press), remminamain); g_signal_connect(G_OBJECT(widget), "changed", G_CALLBACK(remmina_main_quick_search_on_changed), remminamain); remminamain->priv->quick_search_entry = widget; }
void nautilus_navigation_window_activate_spinner (NautilusNavigationWindow *window) { GtkToolItem *item; GtkWidget *spinner; if (window->details->spinner != NULL) { return; } item = gtk_tool_item_new (); gtk_widget_show (GTK_WIDGET (item)); gtk_tool_item_set_expand (item, TRUE); gtk_toolbar_insert (GTK_TOOLBAR (window->details->toolbar), item, -1); spinner = gtk_spinner_new (); gtk_widget_show (GTK_WIDGET (spinner)); item = gtk_tool_item_new (); gtk_container_add (GTK_CONTAINER (item), spinner); gtk_widget_show (GTK_WIDGET (item)); gtk_toolbar_insert (GTK_TOOLBAR (window->details->toolbar), item, -1); window->details->spinner = spinner; }
static GtkWidget * create_toolbar (void) { GtkWidget *toolbar; GtkToolItem *item; toolbar = gtk_toolbar_new (); item = gtk_tool_button_new (gtk_image_new_from_icon_name ("document-new", GTK_ICON_SIZE_SMALL_TOOLBAR), NULL); gtk_tool_item_set_tooltip_markup (item, "Open another one of these windows"); gtk_actionable_set_action_name (GTK_ACTIONABLE (item), "demo.new"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_tool_button_new (gtk_image_new_from_icon_name ("document-open", GTK_ICON_SIZE_SMALL_TOOLBAR), NULL); gtk_tool_item_set_tooltip_markup (item, "This is a demo button that locks up the demo"); gtk_actionable_set_action_name (GTK_ACTIONABLE (item), "demo.lock"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_tool_button_new (gtk_image_new_from_icon_name ("document-open", GTK_ICON_SIZE_SMALL_TOOLBAR), NULL); gtk_tool_item_set_tooltip_markup (item, "This is a demo button that toggles window decorations"); gtk_actionable_set_action_name (GTK_ACTIONABLE (item), "demo.decorations"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_tool_button_new (gtk_image_new_from_icon_name ("document-open", GTK_ICON_SIZE_SMALL_TOOLBAR), NULL); gtk_tool_item_set_tooltip_markup (item, "This is a demo button that locks the aspect ratio using a hint"); gtk_actionable_set_action_name (GTK_ACTIONABLE (item), "demo.ratio"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_tool_button_new (gtk_image_new_from_icon_name ("gtk-quit", GTK_ICON_SIZE_SMALL_TOOLBAR), NULL); gtk_tool_item_set_tooltip_markup (item, "This is a demo button with a 'quit' icon"); gtk_actionable_set_action_name (GTK_ACTIONABLE (item), "demo.quit"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); return toolbar; }
/* Create a toolbar with cut, copy, paste and select all */ static void create_toolbar( GtkWidget *toolbar, GtkWidget *entry ) { GtkToolItem *cut = gtk_tool_button_new_from_stock( GTK_STOCK_CUT ); GtkToolItem *copy = gtk_tool_button_new_from_stock( GTK_STOCK_COPY ); GtkToolItem *paste = gtk_tool_button_new_from_stock( GTK_STOCK_PASTE ); GtkToolItem *selectall = gtk_tool_button_new_from_stock( GTK_STOCK_SELECT_ALL ); GtkToolItem *separator = gtk_separator_tool_item_new(); gtk_toolbar_set_show_arrow( GTK_TOOLBAR( toolbar ), TRUE ); gtk_toolbar_set_style( GTK_TOOLBAR( toolbar ), GTK_TOOLBAR_BOTH ); gtk_toolbar_insert( GTK_TOOLBAR( toolbar ), cut, 0 ); gtk_toolbar_insert( GTK_TOOLBAR( toolbar ), copy, 1 ); gtk_toolbar_insert( GTK_TOOLBAR( toolbar ), paste, 2 ); gtk_toolbar_insert( GTK_TOOLBAR( toolbar ), separator, 3 ); gtk_toolbar_insert( GTK_TOOLBAR( toolbar ), selectall, 4 ); g_signal_connect_swapped( G_OBJECT( cut ), "clicked", G_CALLBACK( gtk_editable_cut_clipboard ), entry ); g_signal_connect_swapped( G_OBJECT( copy ), "clicked", G_CALLBACK( gtk_editable_copy_clipboard ), entry ); g_signal_connect_swapped( G_OBJECT( paste ), "clicked", G_CALLBACK( gtk_editable_paste_clipboard ), entry ); g_signal_connect_swapped( G_OBJECT( selectall ), "clicked", G_CALLBACK( select_all ), entry ); }
static GtkWidget* create_toolbar() { GtkWidget* toolbar=gtk_toolbar_new(); gtk_toolbar_set_orientation(GTK_TOOLBAR (toolbar), GTK_ORIENTATION_HORIZONTAL); gtk_toolbar_set_style(GTK_TOOLBAR (toolbar), GTK_TOOLBAR_BOTH_HORIZ); GtkToolItem* item; // botao para voltar item = gtk_tool_button_new_from_stock(GTK_STOCK_GO_BACK); g_signal_connect(G_OBJECT (item), "clicked", G_CALLBACK (go_back_box), NULL); gtk_toolbar_insert(GTK_TOOLBAR (toolbar), item, -1); // botao para ir para url que esta antes item = gtk_tool_button_new_from_stock(GTK_STOCK_GO_FORWARD); g_signal_connect(G_OBJECT (item), "clicked", G_CALLBACK (go_forward_box), NULL); gtk_toolbar_insert(GTK_TOOLBAR (toolbar), item, -1); // form de entrada de url item = gtk_tool_item_new(); gtk_tool_item_set_expand(item, TRUE); uri_entry = gtk_entry_new(); gtk_container_add(GTK_CONTAINER (item), uri_entry); g_signal_connect(G_OBJECT (uri_entry), "activate", G_CALLBACK (activate_uri_entry_box), NULL); gtk_toolbar_insert(GTK_TOOLBAR (toolbar), item, -1); // botao bara ir e abrir item = gtk_tool_button_new_from_stock(GTK_STOCK_OK); g_signal_connect_swapped(G_OBJECT (item), "clicked", G_CALLBACK (activate_uri_entry_box), (gpointer)uri_entry); gtk_toolbar_insert(GTK_TOOLBAR (toolbar), item, -1); return toolbar; }
GtkWidget *hwidget_get_toolbar(HviewWidgetsT *w) { GtkWidget *tbar; GtkToolItem *but; tbar = gtk_toolbar_new(); gtk_toolbar_set_style(GTK_TOOLBAR(tbar), GTK_TOOLBAR_BOTH); but = hwidget_get_tool_button("close.png", "Close", "Close session", hview_session_close_call, w, HWIDGET_TOOL_BUTTON); gtk_toolbar_insert(GTK_TOOLBAR(tbar), but, -1); but = hwidget_get_tool_button("discover.png", "Discover", "Discover domain", hview_discover_call, w, HWIDGET_TOOL_BUTTON); gtk_toolbar_insert(GTK_TOOLBAR(tbar), but, -1); but = hwidget_get_tool_button("sub_events.png", "Subscribe", "Subscribe events", hview_subscribe_events_call, w, HWIDGET_TOOL_BUTTON); gtk_toolbar_insert(GTK_TOOLBAR(tbar), but, -1); w->subev_item = but; but = hwidget_get_tool_button("get_events.png", "Get event", "Get event", hview_get_events_call, w, HWIDGET_TOOL_BUTTON); gtk_toolbar_insert(GTK_TOOLBAR(tbar), but, -1); return tbar; }
static void schema_browser_perspective_customize (BrowserPerspective *perspective, GtkToolbar *toolbar, GtkHeaderBar *header) { g_print ("%s ()\n", __FUNCTION__); customization_data_init (G_OBJECT (perspective), toolbar, header); /* add perspective's actions */ customization_data_add_actions (G_OBJECT (perspective), win_entries, G_N_ELEMENTS (win_entries)); /* add to toolbar */ GtkToolItem *titem; titem = gtk_toggle_tool_button_new (); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (titem), "user-bookmarks-symbolic"); gtk_widget_set_tooltip_text (GTK_WIDGET (titem), _("Show favorites")); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), titem, -1); gtk_actionable_set_action_name (GTK_ACTIONABLE (titem), "win.show-favorites"); gtk_widget_show (GTK_WIDGET (titem)); customization_data_add_part (G_OBJECT (perspective), G_OBJECT (titem)); #ifdef HAVE_GOOCANVAS titem = gtk_tool_button_new (NULL, NULL); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (titem), "tab-new-symbolic"); gtk_widget_set_tooltip_text (GTK_WIDGET (titem), _("Create a new diagram")); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), titem, -1); gtk_actionable_set_action_name (GTK_ACTIONABLE (titem), "win.action-diagram-new"); gtk_widget_show (GTK_WIDGET (titem)); customization_data_add_part (G_OBJECT (perspective), G_OBJECT (titem)); #endif }
static void add_section_toolbar (CEPageIP6 *page, GtkWidget *section, GCallback add_cb) { GtkWidget *toolbar; GtkToolItem *item; GtkStyleContext *context; GtkWidget *box; GtkWidget *button; GtkWidget *image; toolbar = gtk_toolbar_new (); gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS); gtk_toolbar_set_icon_size (GTK_TOOLBAR (toolbar), GTK_ICON_SIZE_MENU); context = gtk_widget_get_style_context (toolbar); gtk_style_context_set_junction_sides (context, GTK_JUNCTION_TOP); gtk_style_context_add_class (context, GTK_STYLE_CLASS_INLINE_TOOLBAR); gtk_container_add (GTK_CONTAINER (section), toolbar); item = gtk_separator_tool_item_new (); gtk_tool_item_set_expand (item, TRUE); gtk_separator_tool_item_set_draw (GTK_SEPARATOR_TOOL_ITEM (item), FALSE); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (item), 0); box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); item = gtk_tool_item_new (); gtk_container_add (GTK_CONTAINER (item), box); button = gtk_button_new (); g_signal_connect_swapped (button, "clicked", G_CALLBACK (add_cb), page); image = gtk_image_new_from_icon_name ("list-add-symbolic", GTK_ICON_SIZE_MENU); atk_object_set_name (gtk_widget_get_accessible (button), _("Add")); gtk_button_set_image (GTK_BUTTON (button), image); gtk_container_add (GTK_CONTAINER (box), button); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (item), 1); }
SidebarToolbar::SidebarToolbar(Control* control) { XOJ_INIT_TYPE(SidebarToolbar); this->control = control; this->toolbar = GTK_TOOLBAR(gtk_toolbar_new()); gtk_toolbar_set_icon_size(this->toolbar, GTK_ICON_SIZE_SMALL_TOOLBAR); g_object_ref(this->toolbar); this->btUp = gtk_tool_button_new_from_stock(GTK_STOCK_GO_UP); gtk_toolbar_insert(this->toolbar, this->btUp, -1); g_signal_connect(this->btUp, "clicked", G_CALLBACK(&btUpClicked), this); this->btDown = gtk_tool_button_new_from_stock(GTK_STOCK_GO_DOWN); gtk_toolbar_insert(this->toolbar, this->btDown, -1); g_signal_connect(this->btDown, "clicked", G_CALLBACK(&btDownClicked), this); this->btCopy = gtk_tool_button_new_from_stock(GTK_STOCK_COPY); gtk_toolbar_insert(this->toolbar, this->btCopy, -1); g_signal_connect(this->btCopy, "clicked", G_CALLBACK(&btCopyClicked), this); this->btDelete = gtk_tool_button_new_from_stock(GTK_STOCK_DELETE); gtk_toolbar_insert(this->toolbar, this->btDelete, -1); g_signal_connect(this->btDelete, "clicked", G_CALLBACK(&btDeleteClicked), this); gtk_widget_show_all(GTK_WIDGET(this->toolbar)); }
static void create_toolbar() { browser->toolbar = gtk_toolbar_new(); #ifndef GTK_ORIENTABLE gtk_toolbar_set_orientation(GTK_TOOLBAR (browser->toolbar), GTK_ORIENTATION_HORIZONTAL); #else gtk_orientable_set_orientation(GTK_ORIENTABLE (browser->toolbar), GTK_ORIENTATION_HORIZONTAL); #endif gtk_toolbar_set_style(GTK_TOOLBAR (browser->toolbar), GTK_TOOLBAR_BOTH_HORIZ); GtkToolItem* item; /* the back button */ item = gtk_tool_button_new_from_stock(GTK_STOCK_GO_BACK); g_signal_connect (G_OBJECT (item), "clicked", G_CALLBACK (go_back_cb), (gpointer) browser); gtk_toolbar_insert(GTK_TOOLBAR (browser->toolbar), item, -1); /* The forward button */ item = gtk_tool_button_new_from_stock(GTK_STOCK_GO_FORWARD); g_signal_connect (G_OBJECT (item), "clicked", G_CALLBACK (go_forward_cb), (gpointer) browser); gtk_toolbar_insert(GTK_TOOLBAR (browser->toolbar), item, -1); /* The URL entry */ item = gtk_tool_item_new(); gtk_tool_item_set_expand(item, TRUE); browser->uri_entry = gtk_entry_new(); gtk_container_add(GTK_CONTAINER (item), browser->uri_entry); g_signal_connect (G_OBJECT (browser->uri_entry), "activate", G_CALLBACK (activate_uri_entry_cb), (gpointer)browser); gtk_toolbar_insert(GTK_TOOLBAR (browser->toolbar), item, -1); /* The go button */ item = gtk_tool_button_new_from_stock(GTK_STOCK_OK); g_signal_connect_swapped (G_OBJECT (item), "clicked", G_CALLBACK (activate_uri_entry_cb), (gpointer)browser->uri_entry); gtk_toolbar_insert(GTK_TOOLBAR (browser->toolbar), item, -1); }
static GtkWidget * mug_toolbar (MugData * mugdata) { GtkWidget *toolbar; int i; struct { const char *stock_id; ToolAction action; } tools[] = { {GTK_STOCK_GO_UP, ACTION_PREV_MSG}, {GTK_STOCK_GO_DOWN, ACTION_NEXT_MSG}, {NULL, ACTION_SEPARATOR}, {GTK_STOCK_REFRESH, ACTION_REINDEX}, {NULL, ACTION_SEPARATOR}, {GTK_STOCK_ABOUT, ACTION_ABOUT}, {NULL, ACTION_SEPARATOR}, {GTK_STOCK_QUIT, ACTION_DO_QUIT}}; toolbar = gtk_toolbar_new (); for (i = 0; i != G_N_ELEMENTS (tools); ++i) { if (tools[i].action == ACTION_SEPARATOR) { /* separator? */ gtk_toolbar_insert (GTK_TOOLBAR (toolbar), gtk_separator_tool_item_new (), i); continue; } else /* nope: a real item */ gtk_toolbar_insert (GTK_TOOLBAR (toolbar), get_connected_tool_button (tools[i].stock_id, tools[i].action, mugdata), i); } return toolbar; }
GtkWidget *toolbar_init(GtkWindow *parent) { GtkWidget *vbox = gtk_vbox_new(FALSE, 0); GtkToolbar *toolbar; GtkActionGroup *ag = gtk_action_group_new("Actions"); gtk_action_group_add_actions(ag, action_items, G_N_ELEMENTS(action_items), parent); gtk_action_group_add_toggle_actions(ag, toggle_items, G_N_ELEMENTS(toggle_items), parent); GtkUIManager *ui = gtk_ui_manager_new(); g_object_set_data(G_OBJECT(parent), "ui_manager", ui); gtk_ui_manager_insert_action_group(ui, ag, 0); GtkAccelGroup *accel = gtk_ui_manager_get_accel_group(ui); gtk_window_add_accel_group(parent, accel); GError *error = NULL; if (!gtk_ui_manager_add_ui_from_string (ui, ui_xml, -1, &error)) { g_message ("building menus failed: %s", error->message); g_error_free (error); exit (-1); } GtkWidget *menubar = gtk_ui_manager_get_widget(ui, "/menubar"); gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(menubar), FALSE, TRUE, 0); toolbar = GTK_TOOLBAR(gtk_ui_manager_get_widget(ui, "/toolbar")); gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(toolbar), FALSE, TRUE, 0); /* Device selection GtkComboBox */ GtkToolItem *toolitem = gtk_tool_item_new(); GtkWidget *dev = dev_select_combo_box_new(parent); gtk_container_add(GTK_CONTAINER(toolitem), dev); gtk_toolbar_insert(toolbar, toolitem, 0); /* Time/Samples entry */ toolitem = gtk_tool_item_new(); GtkWidget *timesamples = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(timesamples), "100"); gtk_entry_set_alignment(GTK_ENTRY(timesamples), 1.0); gtk_widget_set_size_request(timesamples, 100, -1); gtk_container_add(GTK_CONTAINER(toolitem), timesamples); gtk_toolbar_insert(toolbar, toolitem, 7); /* Time unit combo box */ toolitem = gtk_tool_item_new(); GtkWidget *timeunit = gtk_combo_box_new_text(); gtk_combo_box_append_text(GTK_COMBO_BOX(timeunit), "samples"); gtk_combo_box_append_text(GTK_COMBO_BOX(timeunit), "ms"); gtk_combo_box_append_text(GTK_COMBO_BOX(timeunit), "s"); gtk_combo_box_set_active(GTK_COMBO_BOX(timeunit), 0); gtk_container_add(GTK_CONTAINER(toolitem), timeunit); gtk_toolbar_insert(toolbar, toolitem, 8); g_object_set_data(G_OBJECT(parent), "timesamples", timesamples); g_object_set_data(G_OBJECT(parent), "timeunit", timeunit); return GTK_WIDGET(vbox); }
void make_toolbar(Viewer *viewer, GtkWidget *parent) { GtkWidget *toolbar = gtk_toolbar_new(); gtk_box_pack_start(GTK_BOX(parent), toolbar, FALSE, FALSE, 0); // add a recording button to the toolbar viewer->record_button = GTK_WIDGET( gtk_toggle_tool_button_new_from_stock (GTK_STOCK_MEDIA_RECORD)); gtk_tool_item_set_is_important (GTK_TOOL_ITEM (viewer->record_button), TRUE); gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (viewer->record_button), viewer->tips, "Record an AVI of the viewport, saved in the current directory", NULL); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (viewer->record_button), 0); gtk_widget_show (viewer->record_button); g_signal_connect (G_OBJECT (viewer->record_button), "toggled", G_CALLBACK (on_record_toggled), viewer); // screenshot button GtkToolItem *ssbt = gtk_tool_button_new_from_stock (GTK_STOCK_FLOPPY); gtk_tool_button_set_label (GTK_TOOL_BUTTON (ssbt), "Screenshot"); gtk_tool_item_set_is_important (GTK_TOOL_ITEM (ssbt), TRUE); gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (ssbt), viewer->tips, "Save a PPM screenshot of the viewport to the current directory", NULL); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), ssbt, 1); gtk_widget_show (GTK_WIDGET (ssbt)); g_signal_connect (G_OBJECT (ssbt), "clicked", G_CALLBACK (on_screenshot_clicked), viewer); // quit button GtkToolItem *quitbt = gtk_tool_button_new_from_stock (GTK_STOCK_QUIT); gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (quitbt), viewer->tips, "Quit", NULL); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), quitbt, 2); gtk_widget_show (GTK_WIDGET (quitbt)); g_signal_connect (G_OBJECT (quitbt), "clicked", gtk_main_quit, NULL); GtkToolItem * sep = gtk_separator_tool_item_new (); gtk_widget_show (GTK_WIDGET (sep)); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), sep, 3); GtkWidget * hbox = gtk_hbox_new (FALSE, 5); GtkWidget * label = gtk_label_new ("Record FPS"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); viewer->fps_spin = gtk_spin_button_new_with_range (0.1, 120.0, 1.0); gtk_spin_button_set_digits (GTK_SPIN_BUTTON (viewer->fps_spin), 1); gtk_spin_button_set_value (GTK_SPIN_BUTTON (viewer->fps_spin), 30); gtk_box_pack_start (GTK_BOX (hbox), viewer->fps_spin, FALSE, FALSE, 0); GtkToolItem * toolitem = gtk_tool_item_new (); gtk_container_add (GTK_CONTAINER (toolitem), hbox); gtk_widget_show_all (GTK_WIDGET (toolitem)); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, 4); viewer->toolbar = GTK_TOOLBAR (toolbar); }
static void populate_window (GtkWidget * win, ViewerCbInfo * info, int xid, gint win_width, gint win_height) { GtkWidget *vbox; GtkWidget *scroll; gint img_width, img_height; vbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (win), vbox); /* create a new image */ info->image = gtk_image_new_from_pixbuf (info->pixbuf); /* pack the window with the image */ img_width = gdk_pixbuf_get_width (info->pixbuf); img_height = gdk_pixbuf_get_height (info->pixbuf); if (xid <= 0) { GtkWidget *toolbar; GtkToolItem *toolitem; GtkRequisition requisition; toolbar = gtk_toolbar_new (); gtk_box_pack_start (GTK_BOX (vbox), toolbar, FALSE, FALSE, 0); toolitem = gtk_tool_button_new_from_stock (GTK_STOCK_ZOOM_IN); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, 0); g_signal_connect (G_OBJECT (toolitem), "clicked", G_CALLBACK (zoom_in), info); toolitem = gtk_tool_button_new_from_stock (GTK_STOCK_ZOOM_OUT); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, 1); g_signal_connect (G_OBJECT (toolitem), "clicked", G_CALLBACK (zoom_out), info); gtk_widget_size_request(toolbar, &requisition); /* HACK: adjust for frame width & height + packing borders */ img_height += requisition.height + 30; win_height += requisition.height + 30; img_width += 20; win_width += 20; } if ((xid > 0 && (img_width > win_width || img_height > win_height)) || (xid <= 0)) { gtk_window_set_default_size (GTK_WINDOW (win), MIN (img_width, win_width), MIN (img_height, win_height)); scroll = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scroll), info->image); gtk_box_pack_start (GTK_BOX (vbox), scroll, TRUE, TRUE, 0); } else { gtk_box_pack_start (GTK_BOX (vbox), info->image, TRUE, TRUE, 0); gtk_window_set_default_size (GTK_WINDOW (win), img_width, img_height); } }
static void activate(GtkApplication *app, gpointer user_data) { GtkWidget *window; GtkWidget *grid; GtkWidget *toolbar; GtkToolItem *tool_item; GtkWidget *notes; int position = 0; // toolbar position // Create a window with a title, default size, and set border width window = gtk_application_window_new (app); gtk_window_set_title (GTK_WINDOW(window), "GUI: notebook"); gtk_window_set_default_size(GTK_WINDOW(window), 400, 300); gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); gtk_container_set_border_width (GTK_CONTAINER(window), 10); // ------------- TOOLBAR ---------------- // Create a basic toolbar toolbar = gtk_toolbar_new(); gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS); tool_item = gtk_tool_button_new_from_stock (GTK_STOCK_REFRESH); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tool_item, position ++); tool_item = gtk_separator_tool_item_new(); gtk_separator_tool_item_set_draw(GTK_SEPARATOR_TOOL_ITEM(tool_item), FALSE); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tool_item, position ++); tool_item = gtk_tool_button_new_from_stock (GTK_STOCK_CLOSE); // connect application quit callback here gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tool_item, position ++); // ------------- NOTEPAD ----------------- notes = gtk_notebook_new(); gtk_notebook_append_page(GTK_NOTEBOOK(notes), create_notepage_fileselect(), gtk_label_new("Config")); // Create a full-window grid to contain toolbar and the notebook grid = gtk_grid_new(); gtk_grid_attach (GTK_GRID(grid), toolbar, 0, 0, 1, 1); gtk_grid_attach (GTK_GRID(grid), notes, 0, 1, 1, 1); gtk_container_add (GTK_CONTAINER(window), GTK_WIDGET(grid)); gtk_widget_show_all (window); }
static void tenso_properties_dialog(GtkButton * CodecButt, struct ALL_DATA *all_data) { struct GWIDGET *gwidget = all_data->gwidget; GtkTextIter start, end; GtkTextIter iter; GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); gtk_window_set_default_size(GTK_WINDOW(window), 400, 200); gtk_window_set_title(GTK_WINDOW(window), "Tenso incoming data"); gtk_container_set_border_width(GTK_CONTAINER(window), 5); GtkWidget *vbox = gtk_vbox_new(FALSE, 0); //-------------------------tool bar-------------------------------------------- GtkWidget *toolbar = gtk_toolbar_new(); gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS); GtkToolItem *startBtn = gtk_tool_button_new_from_stock(GTK_STOCK_OK); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), startBtn, -1); GtkToolItem *stopBtn = gtk_tool_button_new_from_stock(GTK_STOCK_CANCEL); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), stopBtn, -1); gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 5); GtkWidget *view = gtk_text_view_new(); gtk_box_pack_start(GTK_BOX(vbox), view, TRUE, TRUE, 0); gwidget->tenso_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(view)); gtk_text_buffer_create_tag(gwidget->tenso_buffer, "gap", "pixels_above_lines", 30, NULL); gtk_text_buffer_create_tag(gwidget->tenso_buffer, "lmarg", "left_margin", 5, NULL); gtk_text_buffer_create_tag(gwidget->tenso_buffer, "blue_fg", "foreground", "blue", NULL); gtk_text_buffer_get_iter_at_offset(gwidget->tenso_buffer, &iter, 0); gtk_text_buffer_insert_with_tags_by_name(gwidget->tenso_buffer, &iter, "Tenso test output\n", -1, "blue_fg", "lmarg", NULL); gtk_text_buffer_insert(gwidget->tenso_buffer, &iter, "Waiting...\n", -1); GtkWidget *statusbar = gtk_statusbar_new(); gtk_box_pack_start(GTK_BOX(vbox), statusbar, FALSE, FALSE, 0); update_statusbar(gwidget->tenso_buffer, GTK_STATUSBAR (statusbar)); gtk_container_add(GTK_CONTAINER(window), vbox); g_signal_connect(G_OBJECT(startBtn), "clicked", G_CALLBACK(tenso_startBtn_clicked), all_data); g_signal_connect(G_OBJECT(stopBtn), "clicked", G_CALLBACK(tenso_stopBtn_clicked), all_data); gtk_widget_show_all(window); }
static void gcal_toolbar_constructed (GObject *object) { GcalToolbarPrivate *priv; GtkStyleContext *context; GtkToolItem *spacer; GtkWidget *bin; priv = GCAL_TOOLBAR (object)->priv; if (G_OBJECT_CLASS (gcal_toolbar_parent_class)->constructed != NULL) G_OBJECT_CLASS (gcal_toolbar_parent_class)->constructed (object); priv->widget = gtk_toolbar_new (); gtk_widget_set_hexpand (priv->widget, TRUE); gtk_widget_set_vexpand (priv->widget, TRUE); gtk_toolbar_set_icon_size (GTK_TOOLBAR (priv->widget), GTK_ICON_SIZE_BUTTON); context = gtk_widget_get_style_context (priv->widget); gtk_style_context_add_class (context, "main-toolbar"); /* adding toolbar */ bin = gtk_clutter_actor_get_widget (GTK_CLUTTER_ACTOR (object)); gtk_container_add (GTK_CONTAINER (bin), priv->widget); /* adding sections */ /* left */ priv->left_item = gtk_tool_item_new (); gtk_toolbar_insert (GTK_TOOLBAR (priv->widget), priv->left_item, 0); /* spacer */ spacer = gtk_tool_item_new (); gtk_tool_item_set_expand (spacer, TRUE); gtk_toolbar_insert (GTK_TOOLBAR (priv->widget), spacer, -1); /* central */ priv->central_item = gtk_tool_item_new (); gtk_toolbar_insert (GTK_TOOLBAR (priv->widget), priv->central_item, -1); /* spacer */ spacer = gtk_tool_item_new (); gtk_tool_item_set_expand (spacer, TRUE); gtk_toolbar_insert (GTK_TOOLBAR (priv->widget), spacer, -1); /* right */ priv->right_item = gtk_tool_item_new (); gtk_toolbar_insert (GTK_TOOLBAR (priv->widget), priv->right_item, -1); gcal_toolbar_set_overview_mode (GCAL_TOOLBAR (object)); gtk_widget_show_all (bin); }
int main(int argc,char *argv[]) { GtkWidget *window; GtkWidget *vbox; GtkWidget *toolbar; GtkWidget *undo; GtkWidget *redo; GtkWidget *sep; GtkWidget *exit; gtk_init(&argc,&argv); window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER); gtk_window_set_default_size(GTK_WINDOW(window),250,200); gtk_window_set_title(GTK_WINDOW(window),"undoredo"); vbox = gtk_vbox_new(FALSE,0); gtk_container_add(GTK_CONTAINER(window),vbox); toolbar = gtk_toolbar_new(); gtk_toolbar_set_style(GTK_TOOLBAR(toolbar),GTK_TOOLBAR_ICONS); gtk_container_set_border_width(GTK_CONTAINER(toolbar),2); undo = gtk_tool_button_new_from_stock(GTK_STOCK_UNDO); gtk_widget_set_name(GTK_WIDGET(undo),"undo"); gtk_toolbar_insert(GTK_TOOLBAR(toolbar),undo,-1); redo = gtk_tool_button_new_from_stock(GTK_STOCK_REDO); gtk_toolbar_insert(GTK_TOOLBAR(toolbar),redo,-1); sep = gtk_separator_tool_item_new(); gtk_toolbar_insert(GTK_TOOLBAR(toolbar),sep,-1); exit = gtk_tool_button_new_from_stock(GTK_STOCK_QUIT); gtk_toolbar_insert(GTK_TOOLBAR(toolbar),exit,-1); gtk_box_pack_start(GTK_BOX(vbox),toolbar,FALSE,FALSE,5); g_signal_connect(G_OBJECT(undo),"clicked",G_CALLBACK(undo_redo),redo); g_signal_connect(G_OBJECT(redo),"clicked",G_CALLBACK(undo_redo),undo); g_signal_connect(G_OBJECT(exit),"clicked",G_CALLBACK(gtk_main_quit),NULL); g_signal_connect_swapped(G_OBJECT(window),"destroy",G_CALLBACK(gtk_main_quit),NULL); gtk_widget_show_all(window); gtk_main(); return 0; }
/* desktop_toolbar_create */ GtkWidget * desktop_toolbar_create(DesktopToolbar * toolbar, gpointer data, GtkAccelGroup * accel) { GtkWidget * ret; size_t i; DesktopToolbar * p; GtkWidget * widget; ret = gtk_toolbar_new(); for(i = 0; toolbar[i].name != NULL; i++) { p = &toolbar[i]; if(p->name[0] == '\0') { p->widget = gtk_separator_tool_item_new(); gtk_toolbar_insert(GTK_TOOLBAR(ret), p->widget, -1); continue; } #if !GTK_CHECK_VERSION(3, 10, 0) else if(strncmp(p->stock, "gtk-", 4) == 0) /* stock icon */ p->widget = gtk_tool_button_new_from_stock(p->stock); #endif else if(p->stock != NULL) /* icon name */ { widget = gtk_image_new_from_icon_name(p->stock, GTK_ICON_SIZE_LARGE_TOOLBAR); p->widget = gtk_tool_button_new(widget, p->name); } else p->widget = gtk_tool_button_new(NULL, _(p->name)); if(p->callback != NULL) g_signal_connect_swapped(G_OBJECT(p->widget), "clicked", G_CALLBACK(p->callback), data); else gtk_widget_set_sensitive(GTK_WIDGET(p->widget), FALSE); if(accel != NULL && p->accel != 0) gtk_widget_add_accelerator(GTK_WIDGET(p->widget), "clicked", accel, p->accel, p->modifier, GTK_ACCEL_VISIBLE); #if 0 /* GTK_CHECK_VERSION(2, 12, 0) */ /* XXX the default is returned instead of the configuration */ if(gtk_toolbar_get_style(GTK_TOOLBAR(ret)) == GTK_TOOLBAR_ICONS) gtk_tool_item_set_tooltip_text(p->widget, p->name); #endif gtk_toolbar_insert(GTK_TOOLBAR(ret), p->widget, -1); } return ret; }
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); }
int main (int argc, char *argv[]) { GtkWidget *window; GtkToolbar *toolbar; GtkToolItem *item; gtk_init (&argc, &argv); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_signal_connect (window, "delete-event", G_CALLBACK (on_window_delete), NULL); toolbar = GTK_TOOLBAR (gtk_toolbar_new ()); gtk_toolbar_set_style (toolbar, GTK_TOOLBAR_TEXT); item = gtk_tool_button_new (NULL, "Prompt"); g_signal_connect (item, "clicked", G_CALLBACK (on_prompt_clicked), window); gtk_toolbar_insert (toolbar, item, 0); gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (toolbar)); gtk_window_set_default_size (GTK_WINDOW (window), 400, 80); gtk_widget_show_all (window); gtk_main (); return 0; }
static void item_added_cb (EggToolbarsModel *model, int tpos, int ipos, EggEditableToolbar *etoolbar) { GtkWidget *dock; GtkWidget *toolbar; GtkToolItem *item; toolbar = get_toolbar_nth (etoolbar, tpos); item = create_item_from_position (etoolbar, tpos, ipos); if (item == NULL) return; gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, ipos); connect_widget_signals (GTK_WIDGET (item), etoolbar); configure_item_tooltip (item); configure_item_cursor (item, etoolbar); configure_item_sensitivity (item, etoolbar); dock = get_dock_nth (etoolbar, tpos); gtk_widget_set_size_request (dock, -1, -1); gtk_widget_queue_resize_no_redraw (dock); toolbar_visibility_refresh (etoolbar); }
/** * physically add widgets to store window */ bool nsgtk_toolbar_add_store_widget(GtkWidget *widget) { if (window->numberh >= NSGTK_STORE_WIDTH) { window->currentbar = gtk_toolbar_new(); if (window->currentbar == NULL) { warn_user("NoMemory", 0); return false; } gtk_toolbar_set_style(GTK_TOOLBAR(window->currentbar), GTK_TOOLBAR_BOTH); gtk_toolbar_set_icon_size(GTK_TOOLBAR(window->currentbar), GTK_ICON_SIZE_LARGE_TOOLBAR); gtk_box_pack_start(GTK_BOX(window->widgetvbox), window->currentbar, FALSE, FALSE, 0); window->numberh = 0; } gtk_widget_set_size_request(widget, NSGTK_BUTTON_WIDTH, NSGTK_BUTTON_HEIGHT); gtk_toolbar_insert(GTK_TOOLBAR(window->currentbar), GTK_TOOL_ITEM( widget), window->numberh++); gtk_tool_item_set_use_drag_window(GTK_TOOL_ITEM(widget), TRUE); gtk_drag_source_set(widget, GDK_BUTTON1_MASK, &entry, 1, GDK_ACTION_COPY); gtk_widget_show_all(window->window); return true; }
/* Creates a toolbar based on the data found in the passed xmlNode * Returns the fully populated GtkToolbar */ GtkToolbar* ToolbarManager::createToolbar(xml::Node& node) { // Get all action children elements xml::NodeList toolItemList = node.getChildren(); GtkWidget* toolbar; if (!toolItemList.empty()) { // Create a new toolbar toolbar = gtk_toolbar_new(); gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS); // Try to set the alignment, if the attribute is properly set std::string align = node.getAttributeValue("align"); GtkOrientation orientation = (align == "vertical") ? GTK_ORIENTATION_VERTICAL : GTK_ORIENTATION_HORIZONTAL; gtk_toolbar_set_orientation(GTK_TOOLBAR(toolbar), orientation); for (std::size_t i = 0; i < toolItemList.size(); i++) { // Create and get the toolItem with the parsing GtkWidget* toolItem = createToolItem(toolItemList[i]); // It is possible that no toolItem is returned, only add it if it's safe to do so if (toolItem != NULL) { gtk_toolbar_insert(GTK_TOOLBAR(toolbar), GTK_TOOL_ITEM(toolItem), -1); } } } else { throw std::runtime_error("No elements in toolbar."); } return GTK_TOOLBAR(toolbar); }
void ui_common_toolbar_append_separator(GtkWidget * toolbar) { GtkToolItem * toolbar_item; toolbar_item = gtk_separator_tool_item_new(); gtk_tool_item_set_homogeneous(toolbar_item, FALSE); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolbar_item, -1); return; }
/********************************************************************************************************* * gui functions */ void create_filter() { GtkToolItem* toolitem; GtkWidget* label; GtkWidget* hbox; hbox = gtk_hbox_new(FALSE, 0); toolitem = gtk_tool_item_new(); /* This is how gtk does more complex toolbar items. */ gtk_tool_item_set_expand(toolitem, TRUE); g_MainWindow.filterBar = gtk_toolbar_new(); gtk_toolbar_set_orientation(GTK_TOOLBAR(g_MainWindow.filterBar), GTK_ORIENTATION_HORIZONTAL); label = gtk_label_new_with_mnemonic(tr("F_ilter:")); g_MainWindow.filter = gtk_entry_new(); gtk_label_set_mnemonic_widget(GTK_LABEL(label), g_MainWindow.filter); gtk_entry_set_text(GTK_ENTRY(g_MainWindow.filter), ""); g_signal_connect(g_MainWindow.filter, "changed", G_CALLBACK(callback_apply_filter), NULL); g_signal_connect(g_MainWindow.filter, "activate", G_CALLBACK(callback_apply_filter), NULL); g_signal_connect(g_MainWindow.filter, "focus-in-event", G_CALLBACK(callback_filter_selected), NULL); g_signal_connect(g_MainWindow.filter, "focus-out-event", G_CALLBACK(callback_filter_unselected), NULL); g_signal_connect(g_MainWindow.filter, "grab-notify", G_CALLBACK(callback_filter_grab_unselected), NULL); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(hbox), g_MainWindow.filter, TRUE, TRUE, 5); gtk_container_add(GTK_CONTAINER(toolitem), hbox); gtk_toolbar_insert(GTK_TOOLBAR(g_MainWindow.filterBar), toolitem, 0); gtk_box_pack_start(GTK_BOX(g_MainWindow.toplevelVBox), g_MainWindow.filterBar, FALSE, FALSE, 0); }
static int filter_button_add(const char *label, const char *expr, struct filter_expression *newfe) { struct filter_expression *fe; /* No duplicate buttons when adding a new one */ if (newfe == NULL) fe = filter_expression_new(label, expr, TRUE); else fe = newfe; if (fe->enabled == FALSE) return(0); /* Create the "Label" button */ fe->button = gtk_tool_button_new(NULL, fe->label); g_signal_connect(fe->button, "clicked", G_CALLBACK(filter_button_cb), NULL); gtk_widget_set_sensitive(GTK_WIDGET(fe->button), FALSE); gtk_widget_show(GTK_WIDGET(fe->button)); gtk_toolbar_insert(GTK_TOOLBAR(_filter_tb), (GtkToolItem *)fe->button, -1); gtk_widget_set_sensitive(GTK_WIDGET(fe->button), TRUE); gtk_widget_set_tooltip_text(GTK_WIDGET(fe->button), fe->expression); return(0); }
JNIEXPORT void JNICALL Java_org_gnome_gtk_GtkToolbar_gtk_1toolbar_1insert ( JNIEnv* env, jclass cls, jlong _self, jlong _item, jint _pos ) { GtkToolbar* self; GtkToolItem* item; gint pos; // convert parameter self self = (GtkToolbar*) _self; // convert parameter item item = (GtkToolItem*) _item; // convert parameter pos pos = (gint) _pos; // call function gtk_toolbar_insert(self, item, pos); // cleanup parameter self // cleanup parameter item // cleanup parameter pos }