自学教程：C++ GTK_TOOL_ITEM函数代码示例

static voidadd_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 voidgtk_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 voidload_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 voidset_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 itemvoid 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);}

static voidbutton_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 voidtm_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);}

voidgimp_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 voidgb_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 voidconnect_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 voidgtk_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 VALUErg_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 gbooleangtk_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 voidgb_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 voidgtk_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);    }}

voidchanged_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 voidgtk_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_SYMBOLvoid 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 itemvoid 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);}

voidedit_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 VALUErg_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;}