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); }
static void gtk_tool_item_update (GtkActivatable *activatable, GtkAction *action, const gchar *property_name) { if (strcmp (property_name, "visible") == 0) { if (gtk_action_is_visible (action)) gtk_widget_show (GTK_WIDGET (activatable)); else gtk_widget_hide (GTK_WIDGET (activatable)); } else if (strcmp (property_name, "sensitive") == 0) gtk_widget_set_sensitive (GTK_WIDGET (activatable), gtk_action_is_sensitive (action)); else if (strcmp (property_name, "tooltip") == 0) gtk_tool_item_set_tooltip_text (GTK_TOOL_ITEM (activatable), gtk_action_get_tooltip (action)); else if (strcmp (property_name, "visible-horizontal") == 0) gtk_tool_item_set_visible_horizontal (GTK_TOOL_ITEM (activatable), gtk_action_get_visible_horizontal (action)); else if (strcmp (property_name, "visible-vertical") == 0) gtk_tool_item_set_visible_vertical (GTK_TOOL_ITEM (activatable), gtk_action_get_visible_vertical (action)); else if (strcmp (property_name, "is-important") == 0) gtk_tool_item_set_is_important (GTK_TOOL_ITEM (activatable), gtk_action_get_is_important (action)); }
/** * 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 ZLGtkApplicationWindow::updatePopupData(GtkMenuToolButton *button, shared_ptr<ZLPopupData> data) { if (data.isNull()) { return; } const size_t id = data->id(); if (id == myPopupIdMap[GTK_TOOL_ITEM(button)]) { return; } myPopupIdMap[GTK_TOOL_ITEM(button)] = id; GtkMenu *menu = GTK_MENU(gtk_menu_tool_button_get_menu(button)); GList *children = gtk_container_get_children(GTK_CONTAINER(menu)); if (children != 0) { for (GList *ptr = g_list_last(children); ; ptr = g_list_previous(ptr)) { gtk_container_remove(GTK_CONTAINER(menu), GTK_WIDGET(ptr->data)); if (ptr == children) { break; } } } const size_t count = data->count(); for (size_t i = 0; i < count; ++i) { GtkWidget *item = gtk_menu_item_new_with_label(data->text(i).c_str()); gtk_widget_show_all(item); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); ZLGtkSignalUtil::connectSignal(GTK_OBJECT(item), "activate", GTK_SIGNAL_FUNC(itemActivated), &*data); } }
gboolean ui_callback_on_filters_enabled(GtkToolButton *button, gpointer data) { gboolean enabled; gboolean changed; enabled = gtk_toggle_tool_button_get_active (GTK_TOGGLE_TOOL_BUTTON(button)); g_info("Filters enabled event occurred %d", enabled); changed = ui_filters_enable (enabled); if (changed) { /* Set the tool tip text */ if (enabled) { gtk_tool_item_set_tooltip_text (GTK_TOOL_ITEM(button), "Disable messages filtering"); } else { gtk_tool_item_set_tooltip_text (GTK_TOOL_ITEM(button), "Enable messages filtering"); } ui_tree_view_refilter (); } return TRUE; }
static void cb_toolbar_reconfigured (GOToolComboPixmaps *tool, GtkAction *a) { GtkOrientation o = gtk_tool_item_get_orientation (GTK_TOOL_ITEM (tool)); GtkReliefStyle relief = gtk_tool_item_get_relief_style (GTK_TOOL_ITEM (tool)); GOActionComboPixmaps *paction = (GOActionComboPixmaps *)a; GOActionComboPixmapsElement const *el = paction->elements; g_object_set (G_OBJECT (tool->combo), "show-arrow", o == GTK_ORIENTATION_HORIZONTAL, NULL); go_combo_pixmaps_clear_elements (tool->combo); for ( ; el->stock_id != NULL ; el++) { GdkPixbuf *icon = make_icon (a, el->stock_id, GTK_WIDGET (tool)); /* * FIXME FIXME FIXME: we must find a better solution for * translating strings not in goffice domain */ go_combo_pixmaps_add_element (tool->combo, icon, el->id, gettext (el->untranslated_tooltip)); } go_combo_pixmaps_select_id (tool->combo, paction->selected_id); go_combo_box_set_relief (GO_COMBO_BOX (tool->combo), relief); }
static void load_stock_items (GtkToolPalette *palette) { GtkWidget *group_af = gtk_tool_item_group_new ("Stock Icons (A-F)"); GtkWidget *group_gn = gtk_tool_item_group_new ("Stock Icons (G-N)"); GtkWidget *group_or = gtk_tool_item_group_new ("Stock Icons (O-R)"); GtkWidget *group_sz = gtk_tool_item_group_new ("Stock Icons (S-Z)"); GtkWidget *group = NULL; GtkToolItem *item; GSList *stock_ids; GSList *iter; stock_ids = gtk_stock_list_ids (); stock_ids = g_slist_sort (stock_ids, (GCompareFunc) strcmp); gtk_container_add (GTK_CONTAINER (palette), group_af); gtk_container_add (GTK_CONTAINER (palette), group_gn); gtk_container_add (GTK_CONTAINER (palette), group_or); gtk_container_add (GTK_CONTAINER (palette), group_sz); for (iter = stock_ids; iter; iter = g_slist_next (iter)) { GtkStockItem stock_item; gchar *id = iter->data; switch (id[4]) { case 'a': group = group_af; break; case 'g': group = group_gn; break; case 'o': group = group_or; break; case 's': group = group_sz; break; } item = gtk_tool_button_new_from_stock (id); gtk_tool_item_set_tooltip_text (GTK_TOOL_ITEM (item), id); gtk_tool_item_set_is_important (GTK_TOOL_ITEM (item), TRUE); gtk_tool_item_group_insert (GTK_TOOL_ITEM_GROUP (group), item, -1); if (!gtk_stock_lookup (id, &stock_item) || !stock_item.label) gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), id); g_free (id); } g_slist_free (stock_ids); }
static void show_icon(void) { mailbutton = GTK_WIDGET(gtk_tool_button_new_from_stock(GEANYSENDMAIL_STOCK_MAIL)); plugin_add_toolbar_item(geany_plugin, GTK_TOOL_ITEM(mailbutton)); ui_add_document_sensitive(mailbutton); #if GTK_CHECK_VERSION(2, 12, 0) gtk_tool_item_set_tooltip_text(GTK_TOOL_ITEM(mailbutton), _("Send by mail")); #endif g_signal_connect (G_OBJECT(mailbutton), "clicked", G_CALLBACK(send_as_attachment), NULL); gtk_widget_show_all (mailbutton); icon_in_toolbar = TRUE; }
static void set_homogeneous (GtkWidget *widget, gpointer data) { gboolean *is_hom_p = data; gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (widget), *is_hom_p); }
// helper to create a dropdown menu item void wxToolBarTool::CreateDropDown() { gtk_tool_item_set_homogeneous(m_item, false); GtkOrientation orient = GTK_ORIENTATION_HORIZONTAL; GtkArrowType arrowType = GTK_ARROW_DOWN; if (GetToolBar()->HasFlag(wxTB_LEFT | wxTB_RIGHT)) { orient = GTK_ORIENTATION_VERTICAL; arrowType = GTK_ARROW_RIGHT; } GtkWidget* box = gtk_box_new(orient, 0); GtkWidget* arrow = gtk_arrow_new(arrowType, GTK_SHADOW_NONE); GtkWidget* tool_button = gtk_bin_get_child(GTK_BIN(m_item)); g_object_ref(tool_button); gtk_container_remove(GTK_CONTAINER(m_item), tool_button); gtk_container_add(GTK_CONTAINER(box), tool_button); g_object_unref(tool_button); GtkWidget* arrow_button = gtk_toggle_button_new(); gtk_button_set_relief(GTK_BUTTON(arrow_button), gtk_tool_item_get_relief_style(GTK_TOOL_ITEM(m_item))); gtk_container_add(GTK_CONTAINER(arrow_button), arrow); gtk_container_add(GTK_CONTAINER(box), arrow_button); gtk_widget_show_all(box); gtk_container_add(GTK_CONTAINER(m_item), box); g_signal_connect(arrow_button, "toggled", G_CALLBACK(arrow_toggled), this); g_signal_connect(arrow_button, "button_press_event", G_CALLBACK(arrow_button_press_event), this); }
/* 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); }
static void button_toggled (GtkWidget *widget, GtkToggleToolButton *toggle_tool_button) { gboolean toggle_active; toggle_active = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)); if (toggle_tool_button->priv->active != toggle_active) { GtkWidget *menu_item; toggle_tool_button->priv->active = toggle_active; if ((menu_item = gtk_tool_item_get_proxy_menu_item (GTK_TOOL_ITEM (toggle_tool_button), MENU_ID))) { gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item), toggle_tool_button->priv->active); } g_object_notify (G_OBJECT (toggle_tool_button), "active"); g_signal_emit (toggle_tool_button, toggle_signals[TOGGLED], 0); } }
static void tm_populate(GtkWidget * toolbar, BalsaToolbarModel * model) { gboolean style_is_both; gboolean make_two_line; GArray *current; guint j; GActionMap *action_map = g_object_get_data(G_OBJECT(toolbar), BALSA_TOOLBAR_ACTION_MAP); style_is_both = (model->style == GTK_TOOLBAR_BOTH || (model->style == (GtkToolbarStyle) - 1 && tm_default_style() == GTK_TOOLBAR_BOTH)); make_two_line = style_is_both && tm_has_second_line(model); current = balsa_toolbar_model_get_current(model); for (j = 0; j < current->len; j++) { BalsaToolbarEntry *entry; GtkToolItem *item; entry = &g_array_index(current, BalsaToolbarEntry, j); if (!*entry->action) { item = gtk_separator_tool_item_new(); } else { GtkWidget *icon; GAction *action; const GVariantType *type; gchar *prefixed_action; icon = gtk_image_new_from_icon_name (balsa_icon_id(entry->icon), GTK_ICON_SIZE_SMALL_TOOLBAR); action = g_action_map_lookup_action(action_map, entry->action); if (action && (type = g_action_get_state_type(action)) && g_variant_type_equal(type, G_VARIANT_TYPE_BOOLEAN)) { item = gtk_toggle_tool_button_new(); g_object_set(G_OBJECT(item), "icon-widget", icon, "label", entry->action, NULL); } else { item = gtk_tool_button_new(icon, entry->action); } tm_set_tool_item_label(GTK_TOOL_ITEM(item), entry->icon, make_two_line); prefixed_action = g_strconcat(action ? "win." : "app.", entry->action, NULL); gtk_actionable_set_action_name(GTK_ACTIONABLE(item), prefixed_action); g_free(prefixed_action); } gtk_toolbar_insert((GtkToolbar *) toolbar, item, -1); } gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), model->style != (GtkToolbarStyle) (-1) ? model->style : tm_default_style()); gtk_widget_show_all(toolbar); }
void gimp_throbber_set_image (GimpThrobber *button, GtkWidget *image) { g_return_if_fail (GIMP_IS_THROBBER (button)); g_return_if_fail (image == NULL || GTK_IS_IMAGE (image)); if (image != button->priv->image) { if (button->priv->image) { if (gtk_widget_get_parent (button->priv->image)) gtk_container_remove (GTK_CONTAINER (gtk_widget_get_parent (button->priv->image)), button->priv->image); g_object_unref (button->priv->image); } if (image) g_object_ref_sink (image); button->priv->image = image; gimp_throbber_construct_contents (GTK_TOOL_ITEM (button)); g_object_notify (G_OBJECT (button), "image"); } }
static GtkToolItem* score_widget_new() { g_assert(score_widget == NULL); score_widget = sugar_toolkit_tool_text_new(); return GTK_TOOL_ITEM(score_widget); }
/* * Writes the source code needed to create this widget. * You have to output everything necessary to create the widget here, though * there are some convenience functions to help. */ static void gb_tool_item_write_source (GtkWidget * widget, GbWidgetWriteSourceData * data) { if (data->create_widget) { source_add (data, " %s = (GtkWidget*) gtk_tool_item_new ();\n", data->wname); } gb_widget_write_standard_source (widget, data); if (gtk_object_get_data (GTK_OBJECT (widget), VisibleHorz) != NULL) { source_add (data, " gtk_tool_item_set_visible_horizontal (GTK_TOOL_ITEM (%s), FALSE);\n", data->wname); } if (gtk_object_get_data (GTK_OBJECT (widget), VisibleVert) != NULL) { source_add (data, " gtk_tool_item_set_visible_vertical (GTK_TOOL_ITEM (%s), FALSE);\n", data->wname); } if (gtk_tool_item_get_is_important (GTK_TOOL_ITEM (widget))) { source_add (data, " gtk_tool_item_set_is_important (GTK_TOOL_ITEM (%s), TRUE);\n", data->wname); } }
static void connect_proxy (GtkAction *action, GtkWidget *proxy) { if (GTK_IS_TOOL_ITEM (proxy)) { GtkToolItem *item = GTK_TOOL_ITEM (proxy); NautilusZoomAction *zaction = NAUTILUS_ZOOM_ACTION (action); NautilusNavigationWindow *window = zaction->priv->window; GtkWidget *zoom_control; zoom_control = nautilus_zoom_control_new (); gtk_container_set_border_width (GTK_CONTAINER (item), 4); gtk_container_add (GTK_CONTAINER (item), zoom_control); gtk_widget_show (zoom_control); g_signal_connect_object (zoom_control, "zoom_in", G_CALLBACK (nautilus_window_zoom_in), window, G_CONNECT_SWAPPED); g_signal_connect_object (zoom_control, "zoom_out", G_CALLBACK (nautilus_window_zoom_out), window, G_CONNECT_SWAPPED); g_signal_connect_object (zoom_control, "zoom_to_level", G_CALLBACK (nautilus_window_zoom_to_level), window, G_CONNECT_SWAPPED); g_signal_connect_object (zoom_control, "zoom_to_default", G_CALLBACK (nautilus_window_zoom_to_default), window, G_CONNECT_SWAPPED); g_signal_connect (window, "zoom-changed", G_CALLBACK (zoom_changed_callback), zoom_control); } (* GTK_ACTION_CLASS (parent_class)->connect_proxy) (action, proxy); }
static void gtk_tool_item_parent_set (GtkWidget *toolitem, GtkWidget *prev_parent) { if (GTK_WIDGET (toolitem)->parent != NULL) gtk_tool_item_toolbar_reconfigured (GTK_TOOL_ITEM (toolitem)); }
static VALUE rg_insert(int argc, VALUE *argv, VALUE self) { GtkWidget* ret = NULL; VALUE type = Qnil; VALUE pos, widget, stock_id, element_type, text, ttext, ptext, icon, func; if (argc > 1) type = argv[1]; if (NIL_P(type) || TYPE(type) == T_STRING){ rb_scan_args(argc, argv, "15", &pos, &text, &ttext, &ptext, &icon, &func); if (NIL_P(func)) func = rb_block_proc(); G_RELATIVE(self, func); ret = gtk_toolbar_insert_item(_SELF(self),N_RVAL2CSTR(text), N_RVAL2CSTR(ttext), N_RVAL2CSTR(ptext), N_RVAL2WIDGET(icon), GTK_SIGNAL_FUNC(exec_callback), (gpointer)func, NUM2INT(pos)); } else if (TYPE(type) == T_FIXNUM) { rb_scan_args(argc, argv, "17", &pos, &element_type, &widget, &text, &ttext, &ptext, &icon, &func); if (NIL_P(func)) func = rb_block_proc(); G_RELATIVE(self, func); ret = gtk_toolbar_insert_element(_SELF(self), RVAL2GENUM(element_type, GTK_TYPE_TOOLBAR_CHILD_TYPE), N_RVAL2WIDGET(widget), N_RVAL2CSTR(text), N_RVAL2CSTR(ttext), N_RVAL2CSTR(ptext), N_RVAL2WIDGET(icon), GTK_SIGNAL_FUNC(exec_callback), (gpointer)func, NUM2INT(pos)); if (RVAL2GENUM(element_type, GTK_TYPE_TOOLBAR_CHILD_TYPE) == GTK_TOOLBAR_CHILD_SPACE) ret = NULL; } else if (TYPE(type) == T_SYMBOL) { rb_scan_args(argc, argv, "14", &pos, &stock_id, &ttext, &ptext, &func); if (NIL_P(func)) func = rb_block_proc(); G_RELATIVE(self, func); ret = gtk_toolbar_insert_stock(_SELF(self), rb_id2name(SYM2ID(stock_id)), N_RVAL2CSTR(ttext), N_RVAL2CSTR(ptext), GTK_SIGNAL_FUNC(exec_callback), (gpointer)func, NUM2INT(pos)); #if GTK_CHECK_VERSION(2,4,0) } else if (rb_obj_is_kind_of(type, GTYPE2CLASS(GTK_TYPE_TOOL_ITEM))){ rb_scan_args(argc, argv, "20", &pos, &widget); gtk_toolbar_insert(_SELF(self), GTK_TOOL_ITEM(RVAL2GOBJ(widget)), NUM2INT(pos)); return widget; #endif } else { rb_scan_args(argc, argv, "22", &pos, &widget, &ttext, &ptext); gtk_toolbar_insert_widget(_SELF(self), GTK_WIDGET(RVAL2GOBJ(widget)), N_RVAL2CSTR(ttext), N_RVAL2CSTR(ptext), NUM2INT(pos)); return widget; } return ret ? GOBJ2RVAL(ret) : Qnil; }
static gboolean gtk_tool_button_create_menu_proxy (GtkToolItem *item) { GtkToolButton *button = GTK_TOOL_BUTTON (item); GtkWidget *menu_item; GtkWidget *menu_image = NULL; GtkStockItem stock_item; gboolean use_mnemonic = TRUE; const char *label; if (_gtk_tool_item_create_menu_proxy (item)) return TRUE; if (GTK_IS_LABEL (button->priv->label_widget)) { label = gtk_label_get_label (GTK_LABEL (button->priv->label_widget)); use_mnemonic = gtk_label_get_use_underline (GTK_LABEL (button->priv->label_widget)); } else if (button->priv->label_text) { label = button->priv->label_text; use_mnemonic = button->priv->use_underline; } else if (button->priv->stock_id && gtk_stock_lookup (button->priv->stock_id, &stock_item)) { label = stock_item.label; } else { label = ""; } if (use_mnemonic) menu_item = gtk_image_menu_item_new_with_mnemonic (label); else menu_item = gtk_image_menu_item_new_with_label (label); if (GTK_IS_IMAGE (button->priv->icon_widget)) { menu_image = clone_image_menu_size (GTK_IMAGE (button->priv->icon_widget), gtk_widget_get_settings (GTK_WIDGET (button))); } else if (button->priv->stock_id) { menu_image = gtk_image_new_from_stock (button->priv->stock_id, GTK_ICON_SIZE_MENU); } if (menu_image) gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item), menu_image); g_signal_connect_closure_by_id (menu_item, g_signal_lookup ("activate", G_OBJECT_TYPE (menu_item)), 0, g_cclosure_new_object_swap (G_CALLBACK (gtk_button_clicked), G_OBJECT (GTK_TOOL_BUTTON (button)->priv->button)), FALSE); gtk_tool_item_set_proxy_menu_item (GTK_TOOL_ITEM (button), MENU_ID, menu_item); return TRUE; }
/* * Sets the properties of the widget. This is used for both applying the * properties changed in the property editor, and also for loading. */ static void gb_tool_item_set_properties (GtkWidget * widget, GbWidgetSetArgData * data) { gboolean visible_horz, visible_vert, is_important; visible_horz = gb_widget_input_bool (data, VisibleHorz); if (data->apply) { gtk_object_set_data (GTK_OBJECT (widget), VisibleHorz, visible_horz ? NULL : "FALSE"); } visible_vert = gb_widget_input_bool (data, VisibleVert); if (data->apply) { gtk_object_set_data (GTK_OBJECT (widget), VisibleVert, visible_vert ? NULL : "FALSE"); } is_important = gb_widget_input_bool (data, IsImportant); if (data->apply) { gtk_tool_item_set_is_important (GTK_TOOL_ITEM (widget), is_important); } }
void ToolDrawCombocontrol::selected(ActionGroup group, ActionType action) { XOJ_CHECK_TYPE(ToolDrawCombocontrol); if (!this->item) { return; } if (!GTK_IS_TOGGLE_TOOL_BUTTON(this->item)) { g_warning("ToolDrawCombocontrol: selected action %i which is not a toggle action!", action); return; } string description; for (ToolDrawType* t : drawTypes) { if (action == t->type && this->action != t->type) { this->action = t->type; gtk_image_set_from_icon_name(GTK_IMAGE(iconWidget), t->icon.c_str(), GTK_ICON_SIZE_SMALL_TOOLBAR); description = t->name; break; } } gtk_tool_item_set_tooltip_text(GTK_TOOL_ITEM(item), description.c_str()); if (gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(this->item)) != (this->action == action)) { this->toolToggleButtonActive = (this->action == action); gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(this->item), this->toolToggleButtonActive); } }
static void gtk_tool_item_size_allocate (GtkWidget *widget, GtkAllocation *allocation) { GtkToolItem *toolitem = GTK_TOOL_ITEM (widget); GtkAllocation child_allocation; gint border_width; GtkWidget *child = GTK_BIN (widget)->child; widget->allocation = *allocation; border_width = GTK_CONTAINER (widget)->border_width; if (toolitem->priv->drag_window) gdk_window_move_resize (toolitem->priv->drag_window, widget->allocation.x + border_width, widget->allocation.y + border_width, widget->allocation.width - border_width * 2, widget->allocation.height - border_width * 2); if (child && gtk_widget_get_visible (child)) { child_allocation.x = allocation->x + border_width; child_allocation.y = allocation->y + border_width; child_allocation.width = allocation->width - 2 * border_width; child_allocation.height = allocation->height - 2 * border_width; gtk_widget_size_allocate (child, &child_allocation); } }
void changed_download_progress(GObject *obj, GParamSpec *pspec, gpointer data) { WebKitDownload *download = WEBKIT_DOWNLOAD(obj); WebKitURIResponse *resp; GtkToolItem *tb = GTK_TOOL_ITEM(data); gdouble p, size_mb; const gchar *uri; gchar *t, *filename, *base; p = webkit_download_get_estimated_progress(download) * 100; resp = webkit_download_get_response(download); size_mb = webkit_uri_response_get_content_length(resp) / 1e6; uri = webkit_download_get_destination(download); filename = g_filename_from_uri(uri, NULL, NULL); if (filename == NULL) { /* This really should not happen because WebKit uses that URI to * write to a file... */ fprintf(stderr, __NAME__": Could not construct file name from URI!\n"); t = g_strdup_printf("%s (%.0f%% of %.1f MB)", webkit_uri_response_get_uri(resp), p, size_mb); } else { base = g_path_get_basename(filename); t = g_strdup_printf("%s (%.0f%% of %.1f MB)", base, p, size_mb); g_free(filename); g_free(base); } gtk_tool_button_set_label(GTK_TOOL_BUTTON(tb), t); g_free(t); }
static void gtk_tool_item_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { GtkToolItem *toolitem = GTK_TOOL_ITEM (object); switch (prop_id) { case PROP_VISIBLE_HORIZONTAL: g_value_set_boolean (value, toolitem->priv->visible_horizontal); break; case PROP_VISIBLE_VERTICAL: g_value_set_boolean (value, toolitem->priv->visible_vertical); break; case PROP_IS_IMPORTANT: g_value_set_boolean (value, toolitem->priv->is_important); break; case PROP_ACTIVATABLE_RELATED_ACTION: g_value_set_object (value, toolitem->priv->action); break; case PROP_ACTIVATABLE_USE_ACTION_APPEARANCE: g_value_set_boolean (value, toolitem->priv->use_action_appearance); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
GtkToolItem * ToolButton::newItem() { XOJ_CHECK_TYPE(ToolButton); GtkToolItem * it; if (!stock.isEmpty()) { if (popupMenu) { it = gtk_menu_tool_button_new_from_stock(stock.c_str()); gtk_menu_tool_button_set_menu(GTK_MENU_TOOL_BUTTON(it), popupMenu); } else { it = gtk_tool_button_new_from_stock(stock.c_str()); } } else if (group != GROUP_NOGROUP) { if (popupMenu) { it = gtk_menu_tool_toggle_button_new(this->gui->loadIcon(iconName.c_str()), description.c_str()); gtk_menu_tool_toggle_button_set_menu(GTK_MENU_TOOL_TOGGLE_BUTTON(it), popupMenu); } else { it = gtk_toggle_tool_button_new(); gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(it), this->gui->loadIcon(iconName.c_str())); } } else { if (popupMenu) { it = gtk_menu_tool_button_new(this->gui->loadIcon(iconName.c_str()), description.c_str()); gtk_menu_tool_button_set_menu(GTK_MENU_TOOL_BUTTON(it), popupMenu); } else { it = gtk_tool_button_new(this->gui->loadIcon(iconName.c_str()), description.c_str()); } } gtk_tool_item_set_tooltip_text(GTK_TOOL_ITEM(it), description.c_str()); gtk_tool_button_set_label(GTK_TOOL_BUTTON(it), description.c_str()); return it; }
/** 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)); }
// helper to create a dropdown menu item void wxToolBarTool::CreateDropDown() { gtk_tool_item_set_homogeneous(m_item, false); GtkWidget* box; GtkWidget* arrow; if (GetToolBar()->HasFlag(wxTB_LEFT | wxTB_RIGHT)) { box = gtk_vbox_new(false, 0); arrow = gtk_arrow_new(GTK_ARROW_RIGHT, GTK_SHADOW_NONE); } else { box = gtk_hbox_new(false, 0); arrow = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_NONE); } GtkWidget* tool_button = GTK_BIN(m_item)->child; gtk_widget_reparent(tool_button, box); GtkWidget* arrow_button = gtk_toggle_button_new(); gtk_button_set_relief(GTK_BUTTON(arrow_button), gtk_tool_item_get_relief_style(GTK_TOOL_ITEM(m_item))); gtk_container_add(GTK_CONTAINER(arrow_button), arrow); gtk_container_add(GTK_CONTAINER(box), arrow_button); gtk_widget_show_all(box); gtk_container_add(GTK_CONTAINER(m_item), box); g_signal_connect(arrow_button, "toggled", G_CALLBACK(arrow_toggled), this); g_signal_connect(arrow_button, "button_press_event", G_CALLBACK(arrow_button_press_event), this); }
void edit_metadata__gth_browser_construct_cb (GthBrowser *browser) { BrowserData *data; GError *error = NULL; g_return_if_fail (GTH_IS_BROWSER (browser)); data = g_new0 (BrowserData, 1); data->browser = browser; data->actions = gtk_action_group_new ("Edit Metadata Actions"); gtk_action_group_set_translation_domain (data->actions, NULL); gtk_action_group_add_actions (data->actions, edit_metadata_action_entries, G_N_ELEMENTS (edit_metadata_action_entries), browser); gtk_ui_manager_insert_action_group (gth_browser_get_ui_manager (browser), data->actions, 0); if (! gtk_ui_manager_add_ui_from_string (gth_browser_get_ui_manager (browser), fixed_ui_info, -1, &error)) { g_message ("building menus failed: %s", error->message); g_error_free (error); } gtk_tool_item_set_is_important (GTK_TOOL_ITEM (gtk_ui_manager_get_widget (gth_browser_get_ui_manager (browser), "/Fullscreen_ToolBar/Edit_Actions/Edit_Metadata")), TRUE); g_object_set_data_full (G_OBJECT (browser), BROWSER_DATA_KEY, data, (GDestroyNotify) browser_data_free); }
static VALUE rg_set_drop_highlight_item(VALUE self, VALUE item, VALUE index) { gtk_toolbar_set_drop_highlight_item(_SELF(self), GTK_TOOL_ITEM(RVAL2GOBJ(item)), NUM2INT(index)); return self; }