%%
ignore
  gtk_tool_button_new_from_stock
  gtk_menu_tool_button_new_from_stock
  gtk_toggle_tool_button_new_from_stock
%%
ignore-glob
  gtk_radio_tool_button_new_*
%%
override gtk_toolbar_append_item kwargs
static PyObject *
_wrap_gtk_toolbar_append_item(PyGObject *self, PyObject *args,
                              PyObject *kwargs)
{
    static char *kwlist[] = { "text", "tooltip_text", "tooltip_private_text",
                              "icon", "callback", "user_data", NULL };
    char *text, *tooltip_text, *tooltip_private_text;
    PyGObject *py_icon;
    PyObject *callback, *param = NULL, *py_ret;
    GtkWidget *icon = NULL, *ret;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
                                     "zzzOO|O:GtkToolbar.append_item", kwlist,
                                     &text, &tooltip_text,
                                     &tooltip_private_text, &py_icon,
                                     &callback, &param))
        return NULL;
    if (PyErr_Warn(PyExc_DeprecationWarning, "") < 0)
        return NULL;
    if (pygobject_check(py_icon, &PyGtkWidget_Type))
        icon = GTK_WIDGET(py_icon->obj);
    else if ((PyObject *)py_icon != Py_None) {
        PyErr_SetString(PyExc_TypeError,
                        "forth argument must be a GtkWidget or None");
        return NULL;
    }
    ret = gtk_toolbar_append_item(GTK_TOOLBAR(self->obj), text, tooltip_text,
                                  tooltip_private_text, icon, NULL, NULL);
    py_ret = pygobject_new((GObject *)ret);
    if (ret && PyCallable_Check(callback)) {
        GClosure *closure;

        closure = pyg_closure_new(callback, param, NULL);
        g_signal_connect_closure(ret, "clicked", closure, FALSE);
        pygobject_watch_closure(py_ret, closure);
    }
    return py_ret;
}
%%
override gtk_toolbar_prepend_item kwargs
static PyObject *
_wrap_gtk_toolbar_prepend_item(PyGObject *self, PyObject *args,
                               PyObject *kwargs)
{
    static char *kwlist[] = { "text", "tooltip_text", "tooltip_private_text",
                              "icon", "callback", "user_data", NULL };
    char *text, *tooltip_text, *tooltip_private_text;
    PyGObject *py_icon;
    PyObject *callback, *param, *py_ret;
    GtkWidget *icon = NULL, *ret;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
                                     "zzzOOO:GtkToolbar.prepend_item", kwlist,
                                     &text, &tooltip_text,
                                     &tooltip_private_text, &py_icon,
                                     &callback, &param))
        return NULL;
    if (PyErr_Warn(PyExc_DeprecationWarning, "") < 0)
        return NULL;
    if (pygobject_check(py_icon, &PyGtkWidget_Type))
        icon = GTK_WIDGET(py_icon->obj);
    else if ((PyObject *)py_icon != Py_None) {
        PyErr_SetString(PyExc_TypeError,
                        "forth argument must be a GtkWidget or None");
        return NULL;
    }
    ret = gtk_toolbar_prepend_item(GTK_TOOLBAR(self->obj), text, tooltip_text,
                                  tooltip_private_text, icon, NULL, NULL);
    py_ret = pygobject_new((GObject *)ret);
    if (ret && PyCallable_Check(callback)) {
        GClosure *closure;

        closure = pyg_closure_new(callback, param, NULL);
        g_signal_connect_closure(ret, "clicked", closure, FALSE);
        pygobject_watch_closure(py_ret, closure);
    }
    return py_ret;
}
%%
override gtk_toolbar_insert_item kwargs
static PyObject *
_wrap_gtk_toolbar_insert_item(PyGObject *self, PyObject *args,
                              PyObject *kwargs)
{
    static char *kwlist[] = { "text", "tooltip_text", "tooltip_private_text",
                              "icon", "callback", "user_data", "position",
                              NULL };
    char *text, *tooltip_text, *tooltip_private_text;
    PyGObject *py_icon;
    PyObject *callback, *param, *py_ret;
    GtkWidget *icon = NULL, *ret;
    int position;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
                                     "zzzOOOi:GtkToolbar.insert_item", kwlist,
                                     &text, &tooltip_text,
                                     &tooltip_private_text, &py_icon,
                                     &callback, &param, &position))
        return NULL;
    if (PyErr_Warn(PyExc_DeprecationWarning, "") < 0)
        return NULL;
    if (pygobject_check(py_icon, &PyGtkWidget_Type))
        icon = GTK_WIDGET(py_icon->obj);
    else if ((PyObject *)py_icon != Py_None) {
        PyErr_SetString(PyExc_TypeError,
                        "forth argument must be a GtkWidget or None");
        return NULL;
    }
    ret = gtk_toolbar_insert_item(GTK_TOOLBAR(self->obj), text, tooltip_text,
                                  tooltip_private_text, icon, NULL, NULL,
                                  position);
    py_ret = pygobject_new((GObject *)ret);
    if (ret && PyCallable_Check(callback)) {
        GClosure *closure;

        closure = pyg_closure_new(callback, param, NULL);
        g_signal_connect_closure(ret, "clicked", closure, FALSE);
        pygobject_watch_closure(py_ret, closure);
    }
    return py_ret;
}
%%
override gtk_toolbar_insert_stock kwargs
static PyObject *
_wrap_gtk_toolbar_insert_stock(PyGObject *self, PyObject *args,
                              PyObject *kwargs)
{
    static char *kwlist[] = { "stock_id", "tooltip_text", "tooltip_private_text",
                              "callback", "user_data", "position",
                              NULL };
    char *stock_id, *tooltip_text, *tooltip_private_text;
    PyObject *callback, *param, *py_ret;
    GtkWidget *ret;
    int position;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
                                     "zzzOOi:GtkToolbar.insert_stock", kwlist,
                                     &stock_id, &tooltip_text,
                                     &tooltip_private_text,
                                     &callback, &param, &position))
        return NULL;
    if (PyErr_Warn(PyExc_DeprecationWarning, "") < 0)
        return NULL;

    ret = gtk_toolbar_insert_stock(GTK_TOOLBAR(self->obj), stock_id, tooltip_text,
                                  tooltip_private_text, NULL, NULL,
                                  position);
    py_ret = pygobject_new((GObject *)ret);
    if (ret && PyCallable_Check(callback)) {
        GClosure *closure;

        closure = pyg_closure_new(callback, param, NULL);
        g_signal_connect_closure(ret, "clicked", closure, FALSE);
        pygobject_watch_closure(py_ret, closure);
    }
    return py_ret;
}
%%
override gtk_toolbar_append_element kwargs
static PyObject *
_wrap_gtk_toolbar_append_element(PyGObject *self, PyObject *args,
                                 PyObject *kwargs)
{
    static char *kwlist[] = { "type", "widget", "text", "tooltip_text",
                              "tooltip_private_text", "icon", "callback",
                              "user_data", NULL };
    char *text, *tooltip_text, *tooltip_private_text;
    PyObject *py_type, *callback, *param, *py_ret;
    PyGObject *py_widget, *py_icon;
    GtkWidget *widget = NULL, *icon = NULL, *ret;
    GtkToolbarChildType type;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
                                     "OOzzzOOO:GtkToolbar.append_element",
                                     kwlist,
                                     &py_type, &py_widget,
                                     &text, &tooltip_text,
                                     &tooltip_private_text, &py_icon,
                                     &callback, &param))
        return NULL;
    if (PyErr_Warn(PyExc_DeprecationWarning, "") < 0)
        return NULL;
    if (pyg_enum_get_value(GTK_TYPE_TOOLBAR_CHILD_TYPE,
                           py_type, (gint *)&type))
        return NULL;
    if (pygobject_check(py_widget, &PyGtkWidget_Type))
        widget = GTK_WIDGET(py_widget->obj);
    else if ((PyObject *)py_widget != Py_None) {
        PyErr_SetString(PyExc_TypeError,
                        "second argument must be a GtkWidget or None");
        return NULL;
    }
    if (pygobject_check(py_icon, &PyGtkWidget_Type))
        icon = GTK_WIDGET(py_icon->obj);
    else if ((PyObject *)py_icon != Py_None) {
        PyErr_SetString(PyExc_TypeError,
                        "sixth argument must be a GtkWidget or None");
        return NULL;
    }
    ret = gtk_toolbar_append_element(GTK_TOOLBAR(self->obj), type, widget,
                                     text, tooltip_text, tooltip_private_text,
                                     icon, NULL, NULL);
    py_ret = pygobject_new((GObject *)ret);
    if (ret && PyCallable_Check(callback) &&
        (type == GTK_TOOLBAR_CHILD_BUTTON ||
         type == GTK_TOOLBAR_CHILD_TOGGLEBUTTON ||
         type == GTK_TOOLBAR_CHILD_RADIOBUTTON)) {
        GClosure *closure;

        closure = pyg_closure_new(callback, param, NULL);
        g_signal_connect_closure(ret, "clicked", closure, FALSE);
        pygobject_watch_closure(py_ret, closure);
    }
    return py_ret;
}
%%
override gtk_toolbar_prepend_element kwargs
static PyObject *
_wrap_gtk_toolbar_prepend_element(PyGObject *self, PyObject *args,
                                  PyObject *kwargs)
{
    static char *kwlist[] = { "type", "widget", "text", "tooltip_text",
                              "tooltip_private_text", "icon", "callback",
                              "user_data", NULL };
    char *text, *tooltip_text, *tooltip_private_text;
    PyObject *py_type, *callback, *param, *py_ret;
    PyGObject *py_widget, *py_icon;
    GtkWidget *widget = NULL, *icon = NULL, *ret;
    GtkToolbarChildType type;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
                                     "OOzzzOOO:GtkToolbar.prepend_element",
                                     kwlist,
                                     &py_type, &py_widget,
                                     &text, &tooltip_text,
                                     &tooltip_private_text, &py_icon,
                                     &callback, &param))
        return NULL;
    if (PyErr_Warn(PyExc_DeprecationWarning, "") < 0)
        return NULL;
    if (pyg_enum_get_value(GTK_TYPE_TOOLBAR_CHILD_TYPE,
                           py_type, (gint *)&type))
        return NULL;
    if (pygobject_check(py_widget, &PyGtkWidget_Type))
        widget = GTK_WIDGET(py_widget->obj);
    else if ((PyObject *)py_widget != Py_None) {
        PyErr_SetString(PyExc_TypeError,
                        "second argument must be a GtkWidget or None");
        return NULL;
    }
    if (pygobject_check(py_icon, &PyGtkWidget_Type))
        icon = GTK_WIDGET(py_icon->obj);
    else if ((PyObject *)py_icon != Py_None) {
        PyErr_SetString(PyExc_TypeError,
                        "sixth argument must be a GtkWidget or None");
        return NULL;
    }
    ret = gtk_toolbar_prepend_element(GTK_TOOLBAR(self->obj), type, widget,
                                      text, tooltip_text, tooltip_private_text,
                                      icon, NULL, NULL);
    py_ret = pygobject_new((GObject *)ret);
    if (ret && PyCallable_Check(callback) &&
        (type == GTK_TOOLBAR_CHILD_BUTTON ||
         type == GTK_TOOLBAR_CHILD_TOGGLEBUTTON ||
         type == GTK_TOOLBAR_CHILD_RADIOBUTTON)) {
        GClosure *closure;

        closure = pyg_closure_new(callback, param, NULL);
        g_signal_connect_closure(ret, "clicked", closure, FALSE);
        pygobject_watch_closure(py_ret, closure);
    }
    return py_ret;
}
%%
override gtk_toolbar_insert_element kwargs
static PyObject *
_wrap_gtk_toolbar_insert_element(PyGObject *self, PyObject *args,
                                 PyObject *kwargs)
{
    static char *kwlist[] = { "type", "widget", "text", "tooltip_text",
                              "tooltip_private_text", "icon", "callback",
                              "user_data", "position", NULL };
    char *text, *tooltip_text, *tooltip_private_text;
    PyObject *py_type, *callback, *param, *py_ret;
    PyGObject *py_widget, *py_icon;
    GtkWidget *widget = NULL, *icon = NULL, *ret;
    GtkToolbarChildType type;
    int position;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
                                     "OOzzzOOOi:GtkToolbar.insert_element",
                                     kwlist,
                                     &py_type, &py_widget,
                                     &text, &tooltip_text,
                                     &tooltip_private_text, &py_icon,
                                     &callback, &param, &position))
        return NULL;
    if (PyErr_Warn(PyExc_DeprecationWarning, "") < 0)
        return NULL;
    if (pyg_enum_get_value(GTK_TYPE_TOOLBAR_CHILD_TYPE,
                           py_type, (gint *)&type))
        return NULL;
    if (pygobject_check(py_widget, &PyGtkWidget_Type))
        widget = GTK_WIDGET(py_widget->obj);
    else if ((PyObject *)py_widget != Py_None) {
        PyErr_SetString(PyExc_TypeError,
                        "second argument must be a GtkWidget or None");
        return NULL;
    }
    if (pygobject_check(py_icon, &PyGtkWidget_Type))
        icon = GTK_WIDGET(py_icon->obj);
    else if ((PyObject *)py_icon != Py_None) {
        PyErr_SetString(PyExc_TypeError,
                        "sixth argument must be a GtkWidget or None");
        return NULL;
    }
    ret = gtk_toolbar_insert_element(GTK_TOOLBAR(self->obj), type, widget,
                                     text, tooltip_text, tooltip_private_text,
                                     icon, NULL, NULL, position);
    py_ret = pygobject_new((GObject *)ret);
    if (ret && PyCallable_Check(callback) &&
        (type == GTK_TOOLBAR_CHILD_BUTTON ||
         type == GTK_TOOLBAR_CHILD_TOGGLEBUTTON ||
         type == GTK_TOOLBAR_CHILD_RADIOBUTTON)) {
        GClosure *closure;

        closure = pyg_closure_new(callback, param, NULL);
        g_signal_connect_closure(ret, "clicked", closure, FALSE);
        pygobject_watch_closure(py_ret, closure);
    }
    return py_ret;
}
%%
override gtk_toggle_tool_button_new kwargs
static int
_wrap_gtk_toggle_tool_button_new(PyGObject *self, PyObject *args,
				 PyObject *kwargs)
{
    static char *kwlist[] = { "stock_id", NULL };
    char *stock_id = NULL;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
				     "|z:GtkToggleToolButton.__init__",
				     kwlist, &stock_id))
        return -1;

    if (stock_id)
        pygobject_construct(self, "stock-id", stock_id, NULL);
    else
        pygobject_construct(self, NULL);

    if (!self->obj) {
        PyErr_SetString(PyExc_RuntimeError,
			"could not create GtkToggleToolButton object");
        return -1;
    }
    return 0;
}
%%
new-constructor GTK_TYPE_TOGGLE_TOOL_BUTTON
%%
override gtk_tool_button_new kwargs
static int
_wrap_gtk_tool_button_new(PyGObject *self, PyObject *args,
				 PyObject *kwargs)
{
    static char *kwlist1[] = { "stock_id", NULL };
    static char *kwlist2[] = { "icon_widget", "label", NULL };
    PyGObject *py_icon_widget = NULL;
    GtkWidget *icon_widget = NULL;
    char *label = NULL;
    char *stock_id = NULL;

    if (PyArg_ParseTupleAndKeywords(args, kwargs,
				    "s:GtkToolButton.__init__", kwlist1,
				    &stock_id)) {
        pygobject_construct(self, "stock-id", stock_id, NULL);
    } else {
	PyErr_Clear();
	if (!PyArg_ParseTupleAndKeywords(args, kwargs,
					 "|Oz:GtkToolButton.__init__", kwlist2,
					 &py_icon_widget, &label)) {
	    PyErr_Clear();
	    PyErr_SetString(PyExc_TypeError,
			    "Usage: one of:\n"
			    "  gtk.ToolButton(icon_widget=None, label=None)\n"
			    "  gtk.ToolButton(stock_id)");
	    return -1;
	}

	if (py_icon_widget && (PyObject *)py_icon_widget != Py_None) {
	    if (!pygobject_check(py_icon_widget, &PyGtkWidget_Type)) {
		PyErr_SetString(PyExc_TypeError,
			    "Usage: one of:\n"
			    "  gtk.ToolButton(icon_widget=None, label=None)\n"
			    "  gtk.ToolButton(stock_id)");
		return -1;
	    }
	    icon_widget = GTK_WIDGET(py_icon_widget->obj);
	}
        pygobject_construct(self, "icon-widget", icon_widget,
                            "label", label, NULL);
    }

    if (!self->obj) {
        PyErr_SetString(PyExc_RuntimeError,
			"could not create GtkToolButton object");
        return -1;
    }
    return 0;
}
%%
new-constructor GTK_TYPE_TOOL_BUTTON
%%
override gtk_radio_tool_button_new kwargs
static int
_wrap_gtk_radio_tool_button_new(PyGObject *self, PyObject *args,
                              PyObject *kwargs)
{
    static char *kwlist[] = { "group", "stock_id", NULL };
    gchar *stock = NULL;
    PyObject *py_widget = Py_None;
    GtkRadioToolButton *widget = NULL;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
                                     "|Oz:GtkRadioToolButton.__init__", kwlist,
                                     &py_widget, &stock))
        return -1;

    if (py_widget != Py_None) {
	if (pygobject_check(py_widget, &PyGtkRadioToolButton_Type))
	    widget = GTK_RADIO_TOOL_BUTTON(pygobject_get(py_widget));
	else {
	    PyErr_SetString(PyExc_TypeError,
			    "first argument must be a GtkRadioToolButton or None");
	    return -1;
	}
    }

    /* various configs for create radio tool buttons ... */
    if (stock == NULL) {
        if (widget == NULL)
            pygobject_construct(self, NULL);
        else
            pygobject_construct(self, "group", widget, NULL);
    } else {
        if (widget == NULL)
            pygobject_construct(self, "stock-id", stock, NULL);
        else
            pygobject_construct(self, "stock-id", stock, "group", widget, NULL);
    }
    if (!self->obj) {
        PyErr_SetString(PyExc_RuntimeError,
			"could not create GtkRadioToolButton object");
        return -1;
    }
    return 0;
}
%%
new-constructor GTK_TYPE_RADIO_TOOL_BUTTON
%%
override gtk_radio_tool_button_set_group kwargs
static PyObject *
_wrap_gtk_radio_tool_button_set_group(PyGObject *self, PyObject *args,
				 PyObject *kwargs)
{
    static char *kwlist[] = { "group", NULL };
    GSList *list;
    GtkRadioToolButton *group;
    PyObject *py_group;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
				     "O:GtkRadioToolButton.set_group",
				     kwlist, &py_group))
        return NULL;

    if (pygobject_check(py_group, &PyGtkRadioToolButton_Type)) {
	group = GTK_RADIO_TOOL_BUTTON(pygobject_get(py_group));
	list = gtk_radio_tool_button_get_group(group);
	if (list == gtk_radio_tool_button_get_group(GTK_RADIO_TOOL_BUTTON(self->obj))) {
	    PyErr_SetString(PyExc_ValueError, "radio tool button already in group");
	    return NULL;
	}
    } else if (py_group == Py_None) {
	list = NULL;
    } else {
	PyErr_SetString(PyExc_TypeError, "group must be a RadioToolButton or None");
	return NULL;
    }

    gtk_radio_tool_button_set_group(GTK_RADIO_TOOL_BUTTON(self->obj), list);
    
    Py_INCREF(Py_None);
    return Py_None;
}
%%
override gtk_radio_tool_button_get_group noargs
static PyObject *
_wrap_gtk_radio_tool_button_get_group(PyGObject *self) {
    PyObject *py_list;
    GSList *list, *tmp;
    PyObject *gtk_obj;

    list = gtk_radio_tool_button_get_group(GTK_RADIO_TOOL_BUTTON(self->obj));

    if ((py_list = PyList_New(0)) == NULL) {
        return NULL;
    }
    for (tmp = list; tmp != NULL; tmp = tmp->next) {
        gtk_obj = pygobject_new(G_OBJECT(tmp->data));
        if (gtk_obj == NULL) {
            Py_DECREF(py_list);
            return NULL;
        }
        PyList_Append(py_list, gtk_obj);
        Py_DECREF(gtk_obj);
    }
    return py_list;
}
%%
override gtk_menu_tool_button_new kwargs
static int
_wrap_gtk_menu_tool_button_new(PyGObject *self, PyObject *args,
				  PyObject *kwargs)
{
    static char *kwlist1[] = { "stock_id", NULL };
    static char *kwlist2[] = { "icon_widget", "label", NULL };
    gchar *stock_id, *label;
    PyObject *py_icon_widget;
    GtkWidget *icon_widget = NULL;
 
    if (PyArg_ParseTupleAndKeywords(args, kwargs,
				     "s:GtkMenuToolButton.__init__",
				     kwlist1, &stock_id))
        pygobject_construct(self, "stock-id", stock_id, NULL);
    else {
        PyErr_Clear();
	if (!PyArg_ParseTupleAndKeywords(args, kwargs,
					 "Oz:GtkFileChooserButton.__init__",
                                         kwlist2, &py_icon_widget, &label)) {
	    PyErr_Clear();
	    PyErr_SetString(PyExc_TypeError,
			    "Usage: one of:\n"
			    "  gtk.MenuToolButton(stock_id)\n"
			    "  gtk.MenuToolButton(icon_widget, label)");
	    return -1;
	}
        if (py_icon_widget != Py_None) {
            if (pygobject_check(py_icon_widget, &PyGtkWidget_Type)) {
                icon_widget = GTK_WIDGET(pygobject_get(py_icon_widget));
            } else {
                PyErr_SetString(PyExc_TypeError,
                                "icon_widget must be a GtkWidget type or None");
                return -1;
            }
        }
        pygobject_construct(self, "icon-widget", icon_widget,
                            "label", label, NULL);
    }
    if (!self->obj) {
        PyErr_SetString(PyExc_RuntimeError,
			"could not create GtkMenuToolButton object");
        return -1;
    }
    return 0;
}
%%
new-constructor GTK_TYPE_MENU_TOOL_BUTTON