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; }
void GTKMusicBrowser::CreateToolbar(GtkWidget *vbox) { toolbar = gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH); gtk_toolbar_set_button_relief(GTK_TOOLBAR(toolbar), GTK_RELIEF_NONE); gtk_toolbar_set_space_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_SPACE_LINE); gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "New Playlist", "Start Editing a new Playlist", "Toolbar/New", NewPixmap(new_pic), GTK_SIGNAL_FUNC(new_plist_tool), this); gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Save Playlist", "Save the Current Playlist to Disk", "Toolbar/Save", NewPixmap(save_pic), GTK_SIGNAL_FUNC(save_list_tool), this); gtk_toolbar_append_space(GTK_TOOLBAR(toolbar)); gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Import Items", "Import a Playlist or Track into My Music", "Toolbar/Import", NewPixmap(import_pic), GTK_SIGNAL_FUNC(import_tool), this); toolRemove = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Remove Track", "Remove a Track from the Playlist", "Toolbar/Remove", NewPixmap(trash_pic), GTK_SIGNAL_FUNC(remove_tool), this); gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Edit", "Edit a Track or Playlist", "Toolbar/Edit", NewPixmap(edit_pic), GTK_SIGNAL_FUNC(edit_tool), this); gtk_toolbar_append_space(GTK_TOOLBAR(toolbar)); addTrack = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Add Items", "Add Music from My Music to the Playlist", "Toolbar/AddItem", NewPixmap(add_track_pic), GTK_SIGNAL_FUNC(add_track_tool), this); addFile = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Add File", "Add a File to the Playlist", "Toolbar/Add", NewPixmap(add_file), GTK_SIGNAL_FUNC(add_tool), this); toolUp = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Move Up", "Move The Currently Selected Track in the Playlist Up", "Toolbar/Up", NewPixmap(up_pic), GTK_SIGNAL_FUNC(move_up_tool), this); toolDown = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Move Down", "Move the Currently Selected Track in the Playlist Down", "Toolbar/Down", NewPixmap(down_pic), GTK_SIGNAL_FUNC(move_down_tool), this); gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, TRUE, 0); SetToolbarType(); gtk_widget_show(toolbar); }
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 *balsa_toolbar_new(BalsaToolbarModel * model, GActionMap * action_map) { toolbar_info *info; GtkWidget *toolbar; info = g_new(toolbar_info, 1); info->model = model; info->menu = NULL; toolbar = gtk_toolbar_new(); g_object_set_data_full(G_OBJECT(toolbar), BALSA_TOOLBAR_ACTION_MAP, g_object_ref(action_map), (GDestroyNotify) g_object_unref); tm_populate(toolbar, model); g_signal_connect(model, "changed", G_CALLBACK(tm_changed_cb), toolbar); g_signal_connect(toolbar, "realize", G_CALLBACK(tm_realize_cb), model); g_object_weak_ref(G_OBJECT(toolbar), (GWeakNotify) tm_toolbar_weak_notify, info); g_signal_connect(toolbar, "button-press-event", G_CALLBACK(tm_button_press_cb), info); g_signal_connect(toolbar, "popup-menu", G_CALLBACK(tm_popup_menu_cb), info); gtk_widget_show_all(toolbar); return 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 * 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 the find toolbar */ void create_find_toolbar(AppData * view) { #ifdef MAEMO4 view->find_toolbar = HILDON_FIND_TOOLBAR (hildon_find_toolbar_new("Find String: ")); /* Add signal listers to "Search" and "Close" buttons */ g_signal_connect(G_OBJECT(view->find_toolbar), "search", G_CALLBACK(find_tb_search), view); g_signal_connect(G_OBJECT(view->find_toolbar), "close", G_CALLBACK(find_tb_close), view); hildon_window_add_toolbar(view->window, GTK_TOOLBAR(view->find_toolbar)); /* Set variables to AppData */ view->find_visible = FALSE; #else view->find_toolbar = gtk_toolbar_new(); view->entry = GTK_ENTRY(gtk_entry_new ()); g_signal_connect(GTK_WIDGET(view->entry), "key-press-event", G_CALLBACK(on_insert_text), (gpointer)view); gtk_widget_show ( GTK_WIDGET(view->entry) ); #endif }
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 GtkWidget * create_dock (EggEditableToolbar *etoolbar) { GtkWidget *toolbar, *hbox; hbox = gtk_hbox_new (0, FALSE); toolbar = gtk_toolbar_new (); gtk_toolbar_set_show_arrow (GTK_TOOLBAR (toolbar), TRUE); gtk_widget_show (toolbar); gtk_box_pack_start (GTK_BOX (hbox), toolbar, TRUE, TRUE, 0); g_signal_connect (toolbar, "drag_drop", G_CALLBACK (toolbar_drag_drop_cb), etoolbar); g_signal_connect (toolbar, "drag_motion", G_CALLBACK (toolbar_drag_motion_cb), etoolbar); g_signal_connect (toolbar, "drag_leave", G_CALLBACK (toolbar_drag_leave_cb), etoolbar); g_signal_connect (toolbar, "drag_data_received", G_CALLBACK (toolbar_drag_data_received_cb), etoolbar); g_signal_connect (toolbar, "popup_context_menu", G_CALLBACK (popup_context_menu_cb), etoolbar); configure_drag_dest (etoolbar, GTK_TOOLBAR (toolbar)); return hbox; }
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); }
int main (int argc, char **args) { gtk_init (&argc, &args); HildonProgram *program = hildon_program_get_instance (); GtkWidget *window = hildon_window_new (); hildon_program_add_window (program, HILDON_WINDOW (window)); gtk_init (&argc, &args); HildonSeekbar *bar = HILDON_SEEKBAR (hildon_seekbar_new ()); gtk_widget_set_size_request (GTK_WIDGET (bar), 400, -1); hildon_seekbar_set_total_time (bar, 100); hildon_seekbar_set_position (bar, 50); GtkToolbar *toolbar = gtk_toolbar_new (); GtkToolItem *item = gtk_tool_item_new (); gtk_container_add (GTK_CONTAINER (item), GTK_WIDGET (bar)); gtk_toolbar_insert (toolbar, item , 0); hildon_window_add_toolbar (window, toolbar); g_signal_connect (G_OBJECT (window), "delete_event", G_CALLBACK (gtk_main_quit), NULL); gtk_widget_show_all (GTK_WIDGET (window)); gtk_main (); return 0; }
static GtkWidget *create_toolbar(void) { GtkWidget *toolbar, *item; GtkToolItem *tool_item; toolbar = gtk_toolbar_new(); gtk_toolbar_set_icon_size(GTK_TOOLBAR(toolbar), GTK_ICON_SIZE_MENU); gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS); tool_item = gtk_menu_tool_button_new(NULL, NULL); gtk_tool_button_set_stock_id(GTK_TOOL_BUTTON(tool_item), GTK_STOCK_JUMP_TO); item = (GtkWidget*)tool_item; gtk_widget_set_tooltip_text(item, _("Show the current document")); gtk_container_add(GTK_CONTAINER(toolbar), item); g_signal_connect(item, "clicked", G_CALLBACK(on_refresh), NULL); item = gtk_menu_new(); gtk_menu_tool_button_set_menu(GTK_MENU_TOOL_BUTTON(tool_item), item); g_signal_connect(item, "show", G_CALLBACK(on_doc_menu_show), NULL); tool_item = gtk_tool_item_new(); gtk_tool_item_set_expand(tool_item, TRUE); gtk_container_add(GTK_CONTAINER(toolbar), GTK_WIDGET(tool_item)); item = gtk_label_new(NULL); gtk_label_set_ellipsize(GTK_LABEL(item), PANGO_ELLIPSIZE_START); gtk_container_add(GTK_CONTAINER(tool_item), item); edit_window.name_label = item; item = ui_tool_button_new(GTK_STOCK_CLOSE, _("_Unsplit"), NULL); gtk_container_add(GTK_CONTAINER(toolbar), item); g_signal_connect(item, "clicked", G_CALLBACK(on_unsplit), NULL); return toolbar; }
void downloadmanager_setup(void) { dm.win = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_type_hint(GTK_WINDOW(dm.win), GDK_WINDOW_TYPE_HINT_DIALOG); gtk_window_set_default_size(GTK_WINDOW(dm.win), 500, 250); gtk_window_set_title(GTK_WINDOW(dm.win), __NAME__" - Download Manager"); g_signal_connect(G_OBJECT(dm.win), "delete-event", G_CALLBACK(gtk_widget_hide_on_delete), NULL); g_signal_connect(G_OBJECT(dm.win), "key-press-event", G_CALLBACK(key_downloadmanager), NULL); dm.toolbar = gtk_toolbar_new(); gtk_orientable_set_orientation(GTK_ORIENTABLE(dm.toolbar), GTK_ORIENTATION_VERTICAL); gtk_toolbar_set_style(GTK_TOOLBAR(dm.toolbar), GTK_TOOLBAR_BOTH_HORIZ); gtk_toolbar_set_show_arrow(GTK_TOOLBAR(dm.toolbar), FALSE); dm.scroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(dm.scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(dm.scroll), dm.toolbar); gtk_container_add(GTK_CONTAINER(dm.win), dm.scroll); }
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; }
void roadmap_main_add_tool (const char *label, const char *icon, const char *tip, RoadMapCallback callback) { if (RoadMapMainToolbar == NULL) { RoadMapMainToolbar = gtk_toolbar_new (); gtk_box_pack_start (GTK_BOX(RoadMapMainBox), RoadMapMainToolbar, FALSE, FALSE, 0); } gtk_toolbar_append_item (GTK_TOOLBAR(RoadMapMainToolbar), label, tip, NULL, roadmap_main_toolbar_icon (icon), (GtkSignalFunc) roadmap_main_activate, callback); if (gdk_screen_height() < 550) { /* When using a small screen, we want either the labels or the icons, * but not both (small screens are typical with PDAs). */ gtk_toolbar_set_style (GTK_TOOLBAR(RoadMapMainToolbar), GtkIconsInitialized?GTK_TOOLBAR_ICONS:GTK_TOOLBAR_TEXT); } }
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_menu() { GtkWidget *iconw; GtkWidget *close_button; bdk_window.toolbar = gtk_toolbar_new (); gtk_toolbar_set_orientation (GTK_TOOLBAR (bdk_window.toolbar), GTK_ORIENTATION_HORIZONTAL); gtk_toolbar_set_style (GTK_TOOLBAR (bdk_window.toolbar), GTK_TOOLBAR_BOTH); /* our first item is <close> button */ iconw = gtk_image_new_from_stock (GTK_STOCK_OPEN, GTK_ICON_SIZE_SMALL_TOOLBAR) ; // ("gtk.xpm"); /* icon widget */ close_button = gtk_toolbar_append_item (GTK_TOOLBAR (bdk_window.toolbar), /* our toolbar */ "Open", /* button label */ "Open a file", /* this button's tooltip */ "Private", /* tooltip private info */ iconw, /* icon widget */ GTK_SIGNAL_FUNC (open_event), /* a signal */ NULL); gtk_toolbar_append_space (GTK_TOOLBAR (bdk_window.toolbar)); /* space after item */ /* our first item is <close> button */ iconw = gtk_image_new_from_stock (GTK_STOCK_QUIT, GTK_ICON_SIZE_SMALL_TOOLBAR) ; // ("gtk.xpm"); /* icon widget */ close_button = gtk_toolbar_append_item( GTK_TOOLBAR (bdk_window.toolbar), /* our toolbar */ "Close", /* button label */ "Closes this app", /* this button's tooltip */ "Private", /* tooltip private info */ iconw, /* icon widget */ GTK_SIGNAL_FUNC (gtk_main_quit), /* a signal */ NULL); gtk_box_pack_start (GTK_BOX (bdk_window.main_vbox), bdk_window.toolbar, FALSE, TRUE, 0); }
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; }
static GtkWidget * alleyoop_toolbar_new (Alleyoop *grind) { GtkWidget *toolbar, *image; GtkToolbarChild *child; toolbar = gtk_toolbar_new (); image = gtk_image_new_from_stock (GTK_STOCK_EXECUTE, GTK_ICON_SIZE_LARGE_TOOLBAR); gtk_widget_show (image); gtk_toolbar_append_item ((GtkToolbar *) toolbar, _("Run"), _("Run Program"), NULL, image, G_CALLBACK (file_run_cb), grind); image = gtk_image_new_from_stock (GTK_STOCK_CANCEL, GTK_ICON_SIZE_LARGE_TOOLBAR); gtk_widget_show (image); gtk_toolbar_append_item ((GtkToolbar *) toolbar, _("Kill"), _("Kill Program"), NULL, image, G_CALLBACK (file_kill_cb), grind); gtk_toolbar_insert_stock ((GtkToolbar *) toolbar, GTK_STOCK_OPEN, _("Open Log File"), NULL, G_CALLBACK (file_open_cb), grind, 2); gtk_toolbar_insert_stock ((GtkToolbar *) toolbar, GTK_STOCK_SAVE, _("Save Log File"), NULL, G_CALLBACK (file_save_cb), grind, 3); gtk_widget_show (toolbar); child = ((GtkToolbar *) toolbar)->children->data; grind->toolbar_run = child->widget; child = ((GtkToolbar *) toolbar)->children->next->data; grind->toolbar_kill = child->widget; return toolbar; }
/* 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); }
/********************************************************************************************************* * 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); }
/** * 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; }
void widgets_get_bottom_toolbar(GtkWidget **toolbar){ GtkToolItem *new_tool_item; GtkWidget *new_tool_item_icon; *toolbar = gtk_toolbar_new(); gtk_toolbar_set_style(GTK_TOOLBAR(*toolbar), GTK_TOOLBAR_ICONS); int i; int nicons = sizeof toolbar_item_icons / sizeof (*toolbar_item_icons); for (i = 0; i < nicons; i++){ new_tool_item_icon = gtk_image_new_from_file(toolbar_item_icons[i].path_to_image); new_tool_item = gtk_tool_button_new(new_tool_item_icon,toolbar_item_icons[i].name); FormShifterToolItemType tool_type = toolbar_item_icons[i].type; switch(tool_type){ /*case XPainter_UNDO_TOOL: g_signal_connect(new_tool_item, "clicked", G_CALLBACK(undo), NULL); break; case XPainter_REDO_TOOL: g_signal_connect(new_tool_item, "clicked", G_CALLBACK(redo), NULL); break;*/ default: g_signal_connect(new_tool_item, "clicked", G_CALLBACK(assign_current_tool), (gpointer) tool_type); break; } gtk_toolbar_insert(GTK_TOOLBAR(*toolbar), new_tool_item, -1); gtk_widget_set_can_focus ((GtkWidget*) new_tool_item, TRUE); } }
ZLGtkApplicationWindow::ZLGtkApplicationWindow(ZLApplication *application) : ZLApplicationWindow(application), KeyActionOnReleaseNotOnPressOption(ZLCategoryKey::CONFIG, "KeyAction", "OnRelease", false), myFullScreen(false) { myProgram = HILDON_PROGRAM(hildon_program_get_instance()); g_set_application_name(""); myWindow = HILDON_WINDOW(hildon_window_new()); ((ZLMaemoCommunicationManager&)ZLCommunicationManager::Instance()).init(); myToolbar = GTK_TOOLBAR(gtk_toolbar_new()); gtk_toolbar_set_show_arrow(myToolbar, false); gtk_toolbar_set_orientation(myToolbar, GTK_ORIENTATION_HORIZONTAL); gtk_toolbar_set_style(myToolbar, GTK_TOOLBAR_ICONS); myMenu = GTK_MENU(gtk_menu_new()); hildon_window_set_menu(myWindow, myMenu); gtk_widget_show_all(GTK_WIDGET(myMenu)); hildon_window_add_toolbar(myWindow, myToolbar); hildon_program_add_window(myProgram, myWindow); gtk_widget_show_all(GTK_WIDGET(myWindow)); myViewWidget = 0; ZLGtkSignalUtil::connectSignal(GTK_OBJECT(myWindow), "delete_event", GTK_SIGNAL_FUNC(applicationQuit), this); ZLGtkSignalUtil::connectSignal(GTK_OBJECT(myWindow), "key_press_event", GTK_SIGNAL_FUNC(handleKeyPress), this); ZLGtkSignalUtil::connectSignal(GTK_OBJECT(myWindow), "key_release_event", GTK_SIGNAL_FUNC(handleKeyRelease), this); }
int main( int argc, char *argv[]) { GtkWidget *window; GtkWidget *vbox; GtkWidget *toolbar; GtkWidget *view; GtkWidget *statusbar; GtkToolItem *exit; GtkTextBuffer *buffer; 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), "lines & cols"); 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); 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); view = gtk_text_view_new(); gtk_box_pack_start(GTK_BOX(vbox), view, TRUE, TRUE, 0); gtk_widget_grab_focus(view); buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(view)); statusbar = gtk_statusbar_new(); gtk_box_pack_start(GTK_BOX(vbox), statusbar, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(exit), "clicked", G_CALLBACK(gtk_main_quit), NULL); g_signal_connect(buffer, "changed", G_CALLBACK(update_statusbar), statusbar); g_signal_connect_object(buffer, "mark_set", G_CALLBACK(mark_set_callback), statusbar, 0); g_signal_connect_swapped(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL); gtk_widget_show_all(window); update_statusbar(buffer, GTK_STATUSBAR (statusbar)); gtk_main(); return 0; }
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 gboolean stress_test_old_api (gpointer data) { typedef enum { ADD_RANDOM, REMOVE_RANDOM, LAST_ACTION } Action; Info *info = data; Action action; if (info->counter++ == 200) { gtk_main_quit (); return FALSE; } if (!info->toolbar) { info->toolbar = GTK_TOOLBAR (gtk_toolbar_new ()); gtk_container_add (GTK_CONTAINER (info->window), GTK_WIDGET (info->toolbar)); gtk_widget_show (GTK_WIDGET (info->toolbar)); } if (!info->toolbar->children) { add_random (info->toolbar, info->counter); return TRUE; } else if (g_list_length (info->toolbar->children) > 50) { int i; for (i = 0; i < 25; i++) remove_random (info->toolbar); return TRUE; } action = g_random_int_range (0, LAST_ACTION); switch (action) { case ADD_RANDOM: add_random (info->toolbar, info->counter); break; case REMOVE_RANDOM: remove_random (info->toolbar); break; default: g_assert_not_reached(); break; } return TRUE; }
bool wxToolBar::Create( wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style, const wxString& name ) { if ( !PreCreation( parent, pos, size ) || !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name )) { wxFAIL_MSG( wxT("wxToolBar creation failed") ); return false; } FixupStyle(); m_toolbar = GTK_TOOLBAR( gtk_toolbar_new() ); #if !GTK_CHECK_VERSION(3,0,0) && !defined(GTK_DISABLE_DEPRECATED) if (gtk_check_version(2, 12, 0)) { m_tooltips = gtk_tooltips_new(); g_object_ref(m_tooltips); gtk_object_sink(GTK_OBJECT(m_tooltips)); } #endif GtkSetStyle(); if (style & wxTB_DOCKABLE) { m_widget = gtk_handle_box_new(); g_signal_connect(m_widget, "child_detached", G_CALLBACK(child_detached), NULL); g_signal_connect(m_widget, "child_attached", G_CALLBACK(child_attached), NULL); if (style & wxTB_FLAT) gtk_handle_box_set_shadow_type( GTK_HANDLE_BOX(m_widget), GTK_SHADOW_NONE ); } else { m_widget = gtk_event_box_new(); ConnectWidget( m_widget ); } g_object_ref(m_widget); gtk_container_add(GTK_CONTAINER(m_widget), GTK_WIDGET(m_toolbar)); gtk_widget_show(GTK_WIDGET(m_toolbar)); m_parent->DoAddChild( this ); PostCreation(size); g_signal_connect_after(m_toolbar, "size_request", G_CALLBACK(size_request), this); return true; }
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 wxVisualAttributes wxToolBar::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant)) { wxVisualAttributes attr; GtkWidget* widget = gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH); attr = GetDefaultAttributesFromGTKWidget(widget); gtk_widget_destroy(widget); return attr; }