[Xfce4-commits] <pyxfce:master> Merge branch 'master' of ssh://git.xfce.org/git/bindings/pyxfce
Danny Milosavljevic
noreply at xfce.org
Sun Jan 2 20:34:02 CET 2011
Updating branch refs/heads/master
to f003847dcad1c2034083bb53386d4c46eae0e1e7 (commit)
from 5ccce1e7e29304735b8074843b8aece1017feb43 (commit)
commit f003847dcad1c2034083bb53386d4c46eae0e1e7
Merge: 5ccce1e 13fdab2
Author: Danny Milosavljevic <dannym at xfce.org>
Date: Sun Jan 2 20:33:05 2011 +0100
Merge branch 'master' of ssh://git.xfce.org/git/bindings/pyxfce
Conflicts:
__init__.py
commit 13fdab2b3ef05a53bc28be66dc1cf23e73985cc3
Author: Danny Milosavljevic <dannym at xfce.org>
Date: Wed Dec 29 23:50:40 2010 +0100
add xfconf to '__init__.py'.
commit 5d30bc1232fc6a6c50cff22f5c2f8ca3197cc957
Author: Danny Milosavljevic <dannym at xfce.org>
Date: Wed Dec 29 23:42:39 2010 +0100
add xfconf files.
__init__.py | 13 -
configure.ac | 1 +
panel/convenience.c | 121 ++++++++
panel/{arrow_button.c => hvbox.c} | 118 +++-----
panel/plugin.c | 542 ++++++++++++++++++++++++++++++++++
panel/{enums.c => plugin_provider.c} | 27 ++-
xfconf/channel.c | 501 +++++++++++++++++++++++++++++++
xfconf/channel.defs | 408 +++++++++++++++++++++++++
xfconf/{binding.c => errors.c} | 44 ++--
xfconf/errors.defs | 40 +++
util/rc.c => xfconf/types.c | 26 +-
xfconf/types.defs | 56 ++++
12 files changed, 1758 insertions(+), 139 deletions(-)
diff --git a/__init__.py b/__init__.py
index 4dc9cc5..f4c653d 100644
--- a/__init__.py
+++ b/__init__.py
@@ -1,15 +1,2 @@
__all__ = [ "ui", "menu", "panel", "util", "xfconf" ]
-
-#import util
-#import gui
-#import netk
-#import menu
-#import exceptions
-#
-#try:
-# import panel
-#except exceptions.ImportError, e:
-# pass
-
-
diff --git a/configure.ac b/configure.ac
index 2d63d0b..2f93b3c 100644
--- a/configure.ac
+++ b/configure.ac
@@ -12,6 +12,7 @@ m4_define(pyxfce_version, pyxfce_major_version.pyxfce_minor_version.pyxfce_micro
m4_define(xfce_required_version, 4.4.0)
AC_INIT(pyxfce, pyxfce_version, [])
+AC_CONFIG_MACRO_DIR([m4])
AC_DEFINE(PYXFCE_MAJOR_VERSION, pyxfce_major_version, [pyxfce major version])
AC_DEFINE(PYXFCE_MINOR_VERSION, pyxfce_minor_version, [pyxfce minor version])
diff --git a/panel/convenience.c b/panel/convenience.c
new file mode 100644
index 0000000..ac41f0a
--- /dev/null
+++ b/panel/convenience.c
@@ -0,0 +1,121 @@
+/* -- THIS FILE IS GENERATED - DO NOT EDIT *//* -*- Mode: C; c-basic-offset: 4 -*- */
+
+#include <Python.h>
+
+
+
+#line 6 "convenience.override"
+#include "pygobject.h"
+#include <gtk/gtk.h>
+#include <libxfce4panel/libxfce4panel.h>
+
+extern PyTypeObject PyGtkWidget_Type;
+
+#line 15 "convenience.c"
+
+
+/* ---------- types from other modules ---------- */
+static PyTypeObject *_PyGObject_Type;
+#define PyGObject_Type (*_PyGObject_Type)
+static PyTypeObject *_PyGtkWidget_Type;
+#define PyGtkWidget_Type (*_PyGtkWidget_Type)
+static PyTypeObject *_PyGtkToggleButton_Type;
+#define PyGtkToggleButton_Type (*_PyGtkToggleButton_Type)
+
+
+/* ---------- forward type declarations ---------- */
+
+#line 29 "convenience.c"
+
+
+
+/* ----------- functions ----------- */
+
+static PyObject *
+_wrap_xfce_panel_create_button(PyObject *self)
+{
+ GtkWidget *ret;
+
+
+ ret = xfce_panel_create_button();
+
+ /* pygobject_new handles NULL checking */
+ return pygobject_new((GObject *)ret);
+}
+
+static PyObject *
+_wrap_xfce_panel_create_toggle_button(PyObject *self)
+{
+ GtkWidget *ret;
+
+
+ ret = xfce_panel_create_toggle_button();
+
+ /* pygobject_new handles NULL checking */
+ return pygobject_new((GObject *)ret);
+}
+
+static PyObject *
+_wrap_xfce_panel_get_channel_name(PyObject *self)
+{
+ const gchar *ret;
+
+
+ ret = xfce_panel_get_channel_name();
+
+ if (ret)
+ return PyString_FromString(ret);
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+const PyMethodDef pyconvenience_functions[] = {
+ { "xfce_panel_create_button", (PyCFunction)_wrap_xfce_panel_create_button, METH_NOARGS,
+ NULL },
+ { "xfce_panel_create_toggle_button", (PyCFunction)_wrap_xfce_panel_create_toggle_button, METH_NOARGS,
+ NULL },
+ { "xfce_panel_get_channel_name", (PyCFunction)_wrap_xfce_panel_get_channel_name, METH_NOARGS,
+ NULL },
+ { NULL, NULL, 0, NULL }
+};
+
+/* initialise stuff extension classes */
+void
+pyconvenience_register_classes(PyObject *d)
+{
+ PyObject *module;
+
+ if ((module = PyImport_ImportModule("gobject")) != NULL) {
+ _PyGObject_Type = (PyTypeObject *)PyObject_GetAttrString(module, "GObject");
+ if (_PyGObject_Type == NULL) {
+ PyErr_SetString(PyExc_ImportError,
+ "cannot import name GObject from gobject");
+ return ;
+ }
+ } else {
+ PyErr_SetString(PyExc_ImportError,
+ "could not import gobject");
+ return ;
+ }
+ if ((module = PyImport_ImportModule("gtk")) != NULL) {
+ _PyGtkWidget_Type = (PyTypeObject *)PyObject_GetAttrString(module, "Widget");
+ if (_PyGtkWidget_Type == NULL) {
+ PyErr_SetString(PyExc_ImportError,
+ "cannot import name Widget from gtk");
+ return ;
+ }
+ _PyGtkToggleButton_Type = (PyTypeObject *)PyObject_GetAttrString(module, "ToggleButton");
+ if (_PyGtkToggleButton_Type == NULL) {
+ PyErr_SetString(PyExc_ImportError,
+ "cannot import name ToggleButton from gtk");
+ return ;
+ }
+ } else {
+ PyErr_SetString(PyExc_ImportError,
+ "could not import gtk");
+ return ;
+ }
+
+
+#line 121 "convenience.c"
+}
diff --git a/panel/arrow_button.c b/panel/hvbox.c
similarity index 55%
copy from panel/arrow_button.c
copy to panel/hvbox.c
index 13fe4fa..b8a3851 100644
--- a/panel/arrow_button.c
+++ b/panel/hvbox.c
@@ -4,14 +4,16 @@
-#line 6 "arrow_button.override"
+#line 6 "hvbox.override"
#include "pygobject.h"
#include <gtk/gtk.h>
-#include <libxfce4panel/xfce-arrow-button.h>
+#include <libxfce4panel/libxfce4panel.h>
+#define XFCE_TYPE_HV_BOX XFCE_TYPE_HVBOX
+#define XFCE_HV_BOX XFCE_HVBOX
extern PyTypeObject PyGtkWidget_Type;
-#line 15 "arrow_button.c"
+#line 17 "hvbox.c"
/* ---------- types from other modules ---------- */
@@ -21,110 +23,60 @@ static PyTypeObject *_PyGtkWidget_Type;
#define PyGtkWidget_Type (*_PyGtkWidget_Type)
static PyTypeObject *_PyGtkToggleButton_Type;
#define PyGtkToggleButton_Type (*_PyGtkToggleButton_Type)
+static PyTypeObject *_PyGtkBox_Type;
+#define PyGtkBox_Type (*_PyGtkBox_Type)
/* ---------- forward type declarations ---------- */
-PyTypeObject G_GNUC_INTERNAL PyXfceArrowButton_Type;
+PyTypeObject G_GNUC_INTERNAL PyXfceHVBox_Type;
-#line 30 "arrow_button.c"
+#line 34 "hvbox.c"
-/* ----------- XfceArrowButton ----------- */
-
-static int
-_wrap_xfce_arrow_button_new(PyGObject *self, PyObject *args, PyObject *kwargs)
-{
- static char *kwlist[] = { "arrow_type", NULL };
- PyObject *py_arrow_type = NULL;
- GtkArrowType arrow_type;
-
- if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:XfceArrowButton.__init__", kwlist, &py_arrow_type))
- return -1;
- if (pyg_enum_get_value(GTK_TYPE_ARROW_TYPE, py_arrow_type, (gpointer)&arrow_type))
- return -1;
- self->obj = (GObject *)xfce_arrow_button_new(arrow_type);
-
- if (!self->obj) {
- PyErr_SetString(PyExc_RuntimeError, "could not create XfceArrowButton object");
- return -1;
- }
- pygobject_register_wrapper((PyObject *)self);
- return 0;
-}
+/* ----------- XfceHVBox ----------- */
static PyObject *
-_wrap_xfce_arrow_button_get_arrow_type(PyGObject *self)
+_wrap_xfce_hvbox_set_orientation(PyGObject *self, PyObject *args, PyObject *kwargs)
{
- gint ret;
+ static char *kwlist[] = { "orientation", NULL };
+ GtkOrientation orientation;
+ PyObject *py_orientation = NULL;
-
- ret = xfce_arrow_button_get_arrow_type(XFCE_ARROW_BUTTON(self->obj));
-
- return pyg_enum_from_gtype(GTK_TYPE_ARROW_TYPE, ret);
-}
-
-static PyObject *
-_wrap_xfce_arrow_button_set_arrow_type(PyGObject *self, PyObject *args, PyObject *kwargs)
-{
- static char *kwlist[] = { "arrow_type", NULL };
- PyObject *py_arrow_type = NULL;
- GtkArrowType arrow_type;
-
- if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:XfceArrowButton.set_arrow_type", kwlist, &py_arrow_type))
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:XfceHVBox.set_orientation", kwlist, &py_orientation))
return NULL;
- if (pyg_enum_get_value(GTK_TYPE_ARROW_TYPE, py_arrow_type, (gpointer)&arrow_type))
+ if (pyg_enum_get_value(GTK_TYPE_ORIENTATION, py_orientation, (gpointer)&orientation))
return NULL;
- xfce_arrow_button_set_arrow_type(XFCE_ARROW_BUTTON(self->obj), arrow_type);
+ xfce_hvbox_set_orientation(XFCE_HV_BOX(self->obj), orientation);
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
-_wrap_xfce_arrow_button_get_blinking(PyGObject *self)
+_wrap_xfce_hvbox_get_orientation(PyGObject *self)
{
- int ret;
-
-
- ret = xfce_arrow_button_get_blinking(XFCE_ARROW_BUTTON(self->obj));
-
- return PyBool_FromLong(ret);
-
-}
-
-static PyObject *
-_wrap_xfce_arrow_button_set_blinking(PyGObject *self, PyObject *args, PyObject *kwargs)
-{
- static char *kwlist[] = { "blinking", NULL };
- int blinking;
+ gint ret;
- if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:XfceArrowButton.set_blinking", kwlist, &blinking))
- return NULL;
- xfce_arrow_button_set_blinking(XFCE_ARROW_BUTTON(self->obj), blinking);
+ ret = xfce_hvbox_get_orientation(XFCE_HV_BOX(self->obj));
- Py_INCREF(Py_None);
- return Py_None;
+ return pyg_enum_from_gtype(GTK_TYPE_ORIENTATION, ret);
}
-static const PyMethodDef _PyXfceArrowButton_methods[] = {
- { "get_arrow_type", (PyCFunction)_wrap_xfce_arrow_button_get_arrow_type, METH_NOARGS,
- NULL },
- { "set_arrow_type", (PyCFunction)_wrap_xfce_arrow_button_set_arrow_type, METH_VARARGS|METH_KEYWORDS,
- NULL },
- { "get_blinking", (PyCFunction)_wrap_xfce_arrow_button_get_blinking, METH_NOARGS,
+static const PyMethodDef _PyXfceHVBox_methods[] = {
+ { "set_orientation", (PyCFunction)_wrap_xfce_hvbox_set_orientation, METH_VARARGS|METH_KEYWORDS,
NULL },
- { "set_blinking", (PyCFunction)_wrap_xfce_arrow_button_set_blinking, METH_VARARGS|METH_KEYWORDS,
+ { "get_orientation", (PyCFunction)_wrap_xfce_hvbox_get_orientation, METH_NOARGS,
NULL },
{ NULL, NULL, 0, NULL }
};
-PyTypeObject G_GNUC_INTERNAL PyXfceArrowButton_Type = {
+PyTypeObject G_GNUC_INTERNAL PyXfceHVBox_Type = {
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
- "arrowbutton.ArrowButton", /* tp_name */
+ "hvbox.HVBox", /* tp_name */
sizeof(PyGObject), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
@@ -151,7 +103,7 @@ PyTypeObject G_GNUC_INTERNAL PyXfceArrowButton_Type = {
offsetof(PyGObject, weakreflist), /* tp_weaklistoffset */
(getiterfunc)0, /* tp_iter */
(iternextfunc)0, /* tp_iternext */
- (struct PyMethodDef*)_PyXfceArrowButton_methods, /* tp_methods */
+ (struct PyMethodDef*)_PyXfceHVBox_methods, /* tp_methods */
(struct PyMemberDef*)0, /* tp_members */
(struct PyGetSetDef*)0, /* tp_getset */
NULL, /* tp_base */
@@ -159,7 +111,7 @@ PyTypeObject G_GNUC_INTERNAL PyXfceArrowButton_Type = {
(descrgetfunc)0, /* tp_descr_get */
(descrsetfunc)0, /* tp_descr_set */
offsetof(PyGObject, inst_dict), /* tp_dictoffset */
- (initproc)_wrap_xfce_arrow_button_new, /* tp_init */
+ (initproc)0, /* tp_init */
(allocfunc)0, /* tp_alloc */
(newfunc)0, /* tp_new */
(freefunc)0, /* tp_free */
@@ -170,13 +122,13 @@ PyTypeObject G_GNUC_INTERNAL PyXfceArrowButton_Type = {
/* ----------- functions ----------- */
-const PyMethodDef pyarrow_button_functions[] = {
+const PyMethodDef pyhvbox_functions[] = {
{ NULL, NULL, 0, NULL }
};
/* initialise stuff extension classes */
void
-pyarrow_button_register_classes(PyObject *d)
+pyhvbox_register_classes(PyObject *d)
{
PyObject *module;
@@ -205,6 +157,12 @@ pyarrow_button_register_classes(PyObject *d)
"cannot import name ToggleButton from gtk");
return ;
}
+ _PyGtkBox_Type = (PyTypeObject *)PyObject_GetAttrString(module, "Box");
+ if (_PyGtkBox_Type == NULL) {
+ PyErr_SetString(PyExc_ImportError,
+ "cannot import name Box from gtk");
+ return ;
+ }
} else {
PyErr_SetString(PyExc_ImportError,
"could not import gtk");
@@ -212,6 +170,6 @@ pyarrow_button_register_classes(PyObject *d)
}
-#line 216 "arrow_button.c"
- pygobject_register_class(d, "XfceArrowButton", XFCE_TYPE_ARROW_BUTTON, &PyXfceArrowButton_Type, Py_BuildValue("(O)", &PyGtkToggleButton_Type));
+#line 174 "hvbox.c"
+ pygobject_register_class(d, "XfceHVBox", XFCE_TYPE_HV_BOX, &PyXfceHVBox_Type, Py_BuildValue("(O)", &PyGtkBox_Type));
}
diff --git a/panel/plugin.c b/panel/plugin.c
new file mode 100644
index 0000000..f1cbb8e
--- /dev/null
+++ b/panel/plugin.c
@@ -0,0 +1,542 @@
+/* -- THIS FILE IS GENERATED - DO NOT EDIT *//* -*- Mode: C; c-basic-offset: 4 -*- */
+
+#include <Python.h>
+
+
+
+#line 6 "plugin.override"
+#include "pygobject.h"
+#include <gtk/gtk.h>
+#include <libxfce4panel/libxfce4panel.h>
+
+extern PyTypeObject PyGtkWidget_Type;
+
+#line 15 "plugin.c"
+
+
+/* ---------- types from other modules ---------- */
+static PyTypeObject *_PyGObject_Type;
+#define PyGObject_Type (*_PyGObject_Type)
+static PyTypeObject *_PyGtkWidget_Type;
+#define PyGtkWidget_Type (*_PyGtkWidget_Type)
+static PyTypeObject *_PyGtkWindow_Type;
+#define PyGtkWindow_Type (*_PyGtkWindow_Type)
+static PyTypeObject *_PyGtkToggleButton_Type;
+#define PyGtkToggleButton_Type (*_PyGtkToggleButton_Type)
+static PyTypeObject *_PyGtkMenuItem_Type;
+#define PyGtkMenuItem_Type (*_PyGtkMenuItem_Type)
+static PyTypeObject *_PyGtkMenu_Type;
+#define PyGtkMenu_Type (*_PyGtkMenu_Type)
+static PyTypeObject *_PyGtkEventBox_Type;
+#define PyGtkEventBox_Type (*_PyGtkEventBox_Type)
+
+
+/* ---------- forward type declarations ---------- */
+PyTypeObject G_GNUC_INTERNAL PyXfcePanelPlugin_Type;
+
+#line 38 "plugin.c"
+
+
+
+/* ----------- XfcePanelPlugin ----------- */
+
+static PyObject *
+_wrap_xfce_panel_plugin_get_name(PyGObject *self)
+{
+ const gchar *ret;
+
+
+ ret = xfce_panel_plugin_get_name(XFCE_PANEL_PLUGIN(self->obj));
+
+ if (ret)
+ return PyString_FromString(ret);
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+static PyObject *
+_wrap_xfce_panel_plugin_get_display_name(PyGObject *self)
+{
+ const gchar *ret;
+
+
+ ret = xfce_panel_plugin_get_display_name(XFCE_PANEL_PLUGIN(self->obj));
+
+ if (ret)
+ return PyString_FromString(ret);
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+static PyObject *
+_wrap_xfce_panel_plugin_get_comment(PyGObject *self)
+{
+ const gchar *ret;
+
+
+ ret = xfce_panel_plugin_get_comment(XFCE_PANEL_PLUGIN(self->obj));
+
+ if (ret)
+ return PyString_FromString(ret);
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+static PyObject *
+_wrap_xfce_panel_plugin_get_unique_id(PyGObject *self)
+{
+ int ret;
+
+
+ ret = xfce_panel_plugin_get_unique_id(XFCE_PANEL_PLUGIN(self->obj));
+
+ return PyInt_FromLong(ret);
+}
+
+static PyObject *
+_wrap_xfce_panel_plugin_get_property_base(PyGObject *self)
+{
+ const gchar *ret;
+
+
+ ret = xfce_panel_plugin_get_property_base(XFCE_PANEL_PLUGIN(self->obj));
+
+ if (ret)
+ return PyString_FromString(ret);
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+static PyObject *
+_wrap_xfce_panel_plugin_get_size(PyGObject *self)
+{
+ int ret;
+
+
+ ret = xfce_panel_plugin_get_size(XFCE_PANEL_PLUGIN(self->obj));
+
+ return PyInt_FromLong(ret);
+}
+
+static PyObject *
+_wrap_xfce_panel_plugin_get_expand(PyGObject *self)
+{
+ int ret;
+
+
+ ret = xfce_panel_plugin_get_expand(XFCE_PANEL_PLUGIN(self->obj));
+
+ return PyBool_FromLong(ret);
+
+}
+
+static PyObject *
+_wrap_xfce_panel_plugin_set_expand(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+ static char *kwlist[] = { "expand", NULL };
+ int expand;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:XfcePanelPlugin.set_expand", kwlist, &expand))
+ return NULL;
+
+ xfce_panel_plugin_set_expand(XFCE_PANEL_PLUGIN(self->obj), expand);
+
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+static PyObject *
+_wrap_xfce_panel_plugin_get_orientation(PyGObject *self)
+{
+ gint ret;
+
+
+ ret = xfce_panel_plugin_get_orientation(XFCE_PANEL_PLUGIN(self->obj));
+
+ return pyg_enum_from_gtype(GTK_TYPE_ORIENTATION, ret);
+}
+
+static PyObject *
+_wrap_xfce_panel_plugin_get_screen_position(PyGObject *self)
+{
+ gint ret;
+
+
+ ret = xfce_panel_plugin_get_screen_position(XFCE_PANEL_PLUGIN(self->obj));
+
+ return pyg_enum_from_gtype(XFCE_TYPE_SCREEN_POSITION, ret);
+}
+
+static PyObject *
+_wrap_xfce_panel_plugin_take_window(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+ static char *kwlist[] = { "window", NULL };
+ PyGObject *window;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:XfcePanelPlugin.take_window", kwlist, &PyGtkWindow_Type, &window))
+ return NULL;
+
+ xfce_panel_plugin_take_window(XFCE_PANEL_PLUGIN(self->obj), GTK_WINDOW(window->obj));
+
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+static PyObject *
+_wrap_xfce_panel_plugin_add_action_widget(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+ static char *kwlist[] = { "widget", NULL };
+ PyGObject *widget;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:XfcePanelPlugin.add_action_widget", kwlist, &PyGtkWidget_Type, &widget))
+ return NULL;
+
+ xfce_panel_plugin_add_action_widget(XFCE_PANEL_PLUGIN(self->obj), GTK_WIDGET(widget->obj));
+
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+static PyObject *
+_wrap_xfce_panel_plugin_menu_insert_item(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+ static char *kwlist[] = { "item", NULL };
+ PyGObject *item;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:XfcePanelPlugin.menu_insert_item", kwlist, &PyGtkMenuItem_Type, &item))
+ return NULL;
+
+ xfce_panel_plugin_menu_insert_item(XFCE_PANEL_PLUGIN(self->obj), GTK_MENU_ITEM(item->obj));
+
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+static PyObject *
+_wrap_xfce_panel_plugin_menu_show_configure(PyGObject *self)
+{
+
+ xfce_panel_plugin_menu_show_configure(XFCE_PANEL_PLUGIN(self->obj));
+
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+static PyObject *
+_wrap_xfce_panel_plugin_menu_show_about(PyGObject *self)
+{
+
+ xfce_panel_plugin_menu_show_about(XFCE_PANEL_PLUGIN(self->obj));
+
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+static PyObject *
+_wrap_xfce_panel_plugin_get_locked(PyGObject *self)
+{
+ int ret;
+
+
+ ret = xfce_panel_plugin_get_locked(XFCE_PANEL_PLUGIN(self->obj));
+
+ return PyBool_FromLong(ret);
+
+}
+
+static PyObject *
+_wrap_xfce_panel_plugin_remove(PyGObject *self)
+{
+
+ xfce_panel_plugin_remove(XFCE_PANEL_PLUGIN(self->obj));
+
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+static PyObject *
+_wrap_xfce_panel_plugin_block_menu(PyGObject *self)
+{
+
+ xfce_panel_plugin_block_menu(XFCE_PANEL_PLUGIN(self->obj));
+
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+static PyObject *
+_wrap_xfce_panel_plugin_unblock_menu(PyGObject *self)
+{
+
+ xfce_panel_plugin_unblock_menu(XFCE_PANEL_PLUGIN(self->obj));
+
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+static PyObject *
+_wrap_xfce_panel_plugin_register_menu(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+ static char *kwlist[] = { "menu", NULL };
+ PyGObject *menu;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:XfcePanelPlugin.register_menu", kwlist, &PyGtkMenu_Type, &menu))
+ return NULL;
+
+ xfce_panel_plugin_register_menu(XFCE_PANEL_PLUGIN(self->obj), GTK_MENU(menu->obj));
+
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+static PyObject *
+_wrap_xfce_panel_plugin_arrow_type(PyGObject *self)
+{
+ gint ret;
+
+
+ ret = xfce_panel_plugin_arrow_type(XFCE_PANEL_PLUGIN(self->obj));
+
+ return pyg_enum_from_gtype(GTK_TYPE_ARROW_TYPE, ret);
+}
+
+static PyObject *
+_wrap_xfce_panel_plugin_focus_widget(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+ static char *kwlist[] = { "widget", NULL };
+ PyGObject *widget;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:XfcePanelPlugin.focus_widget", kwlist, &PyGtkWidget_Type, &widget))
+ return NULL;
+
+ xfce_panel_plugin_focus_widget(XFCE_PANEL_PLUGIN(self->obj), GTK_WIDGET(widget->obj));
+
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+static PyObject *
+_wrap_xfce_panel_plugin_block_autohide(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+ static char *kwlist[] = { "blocked", NULL };
+ int blocked;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:XfcePanelPlugin.block_autohide", kwlist, &blocked))
+ return NULL;
+
+ xfce_panel_plugin_block_autohide(XFCE_PANEL_PLUGIN(self->obj), blocked);
+
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+static PyObject *
+_wrap_xfce_panel_plugin_lookup_rc_file(PyGObject *self)
+{
+ gchar *ret;
+
+
+ ret = xfce_panel_plugin_lookup_rc_file(XFCE_PANEL_PLUGIN(self->obj));
+
+ if (ret) {
+ PyObject *py_ret = PyString_FromString(ret);
+ g_free(ret);
+ return py_ret;
+ }
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+static PyObject *
+_wrap_xfce_panel_plugin_save_location(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+ static char *kwlist[] = { "create", NULL };
+ int create;
+ gchar *ret;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:XfcePanelPlugin.save_location", kwlist, &create))
+ return NULL;
+
+ ret = xfce_panel_plugin_save_location(XFCE_PANEL_PLUGIN(self->obj), create);
+
+ if (ret) {
+ PyObject *py_ret = PyString_FromString(ret);
+ g_free(ret);
+ return py_ret;
+ }
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+static const PyMethodDef _PyXfcePanelPlugin_methods[] = {
+ { "get_name", (PyCFunction)_wrap_xfce_panel_plugin_get_name, METH_NOARGS,
+ NULL },
+ { "get_display_name", (PyCFunction)_wrap_xfce_panel_plugin_get_display_name, METH_NOARGS,
+ NULL },
+ { "get_comment", (PyCFunction)_wrap_xfce_panel_plugin_get_comment, METH_NOARGS,
+ NULL },
+ { "get_unique_id", (PyCFunction)_wrap_xfce_panel_plugin_get_unique_id, METH_NOARGS,
+ NULL },
+ { "get_property_base", (PyCFunction)_wrap_xfce_panel_plugin_get_property_base, METH_NOARGS,
+ NULL },
+ { "get_size", (PyCFunction)_wrap_xfce_panel_plugin_get_size, METH_NOARGS,
+ NULL },
+ { "get_expand", (PyCFunction)_wrap_xfce_panel_plugin_get_expand, METH_NOARGS,
+ NULL },
+ { "set_expand", (PyCFunction)_wrap_xfce_panel_plugin_set_expand, METH_VARARGS|METH_KEYWORDS,
+ NULL },
+ { "get_orientation", (PyCFunction)_wrap_xfce_panel_plugin_get_orientation, METH_NOARGS,
+ NULL },
+ { "get_screen_position", (PyCFunction)_wrap_xfce_panel_plugin_get_screen_position, METH_NOARGS,
+ NULL },
+ { "take_window", (PyCFunction)_wrap_xfce_panel_plugin_take_window, METH_VARARGS|METH_KEYWORDS,
+ NULL },
+ { "add_action_widget", (PyCFunction)_wrap_xfce_panel_plugin_add_action_widget, METH_VARARGS|METH_KEYWORDS,
+ NULL },
+ { "menu_insert_item", (PyCFunction)_wrap_xfce_panel_plugin_menu_insert_item, METH_VARARGS|METH_KEYWORDS,
+ NULL },
+ { "menu_show_configure", (PyCFunction)_wrap_xfce_panel_plugin_menu_show_configure, METH_NOARGS,
+ NULL },
+ { "menu_show_about", (PyCFunction)_wrap_xfce_panel_plugin_menu_show_about, METH_NOARGS,
+ NULL },
+ { "get_locked", (PyCFunction)_wrap_xfce_panel_plugin_get_locked, METH_NOARGS,
+ NULL },
+ { "remove", (PyCFunction)_wrap_xfce_panel_plugin_remove, METH_NOARGS,
+ NULL },
+ { "block_menu", (PyCFunction)_wrap_xfce_panel_plugin_block_menu, METH_NOARGS,
+ NULL },
+ { "unblock_menu", (PyCFunction)_wrap_xfce_panel_plugin_unblock_menu, METH_NOARGS,
+ NULL },
+ { "register_menu", (PyCFunction)_wrap_xfce_panel_plugin_register_menu, METH_VARARGS|METH_KEYWORDS,
+ NULL },
+ { "arrow_type", (PyCFunction)_wrap_xfce_panel_plugin_arrow_type, METH_NOARGS,
+ NULL },
+ { "focus_widget", (PyCFunction)_wrap_xfce_panel_plugin_focus_widget, METH_VARARGS|METH_KEYWORDS,
+ NULL },
+ { "block_autohide", (PyCFunction)_wrap_xfce_panel_plugin_block_autohide, METH_VARARGS|METH_KEYWORDS,
+ NULL },
+ { "lookup_rc_file", (PyCFunction)_wrap_xfce_panel_plugin_lookup_rc_file, METH_NOARGS,
+ NULL },
+ { "save_location", (PyCFunction)_wrap_xfce_panel_plugin_save_location, METH_VARARGS|METH_KEYWORDS,
+ NULL },
+ { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyXfcePanelPlugin_Type = {
+ PyObject_HEAD_INIT(NULL)
+ 0, /* ob_size */
+ "plugin.PanelPlugin", /* tp_name */
+ sizeof(PyGObject), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ /* methods */
+ (destructor)0, /* tp_dealloc */
+ (printfunc)0, /* tp_print */
+ (getattrfunc)0, /* tp_getattr */
+ (setattrfunc)0, /* tp_setattr */
+ (cmpfunc)0, /* tp_compare */
+ (reprfunc)0, /* tp_repr */
+ (PyNumberMethods*)0, /* tp_as_number */
+ (PySequenceMethods*)0, /* tp_as_sequence */
+ (PyMappingMethods*)0, /* tp_as_mapping */
+ (hashfunc)0, /* tp_hash */
+ (ternaryfunc)0, /* tp_call */
+ (reprfunc)0, /* tp_str */
+ (getattrofunc)0, /* tp_getattro */
+ (setattrofunc)0, /* tp_setattro */
+ (PyBufferProcs*)0, /* tp_as_buffer */
+ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
+ NULL, /* Documentation string */
+ (traverseproc)0, /* tp_traverse */
+ (inquiry)0, /* tp_clear */
+ (richcmpfunc)0, /* tp_richcompare */
+ offsetof(PyGObject, weakreflist), /* tp_weaklistoffset */
+ (getiterfunc)0, /* tp_iter */
+ (iternextfunc)0, /* tp_iternext */
+ (struct PyMethodDef*)_PyXfcePanelPlugin_methods, /* tp_methods */
+ (struct PyMemberDef*)0, /* tp_members */
+ (struct PyGetSetDef*)0, /* tp_getset */
+ NULL, /* tp_base */
+ NULL, /* tp_dict */
+ (descrgetfunc)0, /* tp_descr_get */
+ (descrsetfunc)0, /* tp_descr_set */
+ offsetof(PyGObject, inst_dict), /* tp_dictoffset */
+ (initproc)0, /* tp_init */
+ (allocfunc)0, /* tp_alloc */
+ (newfunc)0, /* tp_new */
+ (freefunc)0, /* tp_free */
+ (inquiry)0 /* tp_is_gc */
+};
+
+
+
+/* ----------- functions ----------- */
+
+const PyMethodDef pyplugin_functions[] = {
+ { NULL, NULL, 0, NULL }
+};
+
+/* initialise stuff extension classes */
+void
+pyplugin_register_classes(PyObject *d)
+{
+ PyObject *module;
+
+ if ((module = PyImport_ImportModule("gobject")) != NULL) {
+ _PyGObject_Type = (PyTypeObject *)PyObject_GetAttrString(module, "GObject");
+ if (_PyGObject_Type == NULL) {
+ PyErr_SetString(PyExc_ImportError,
+ "cannot import name GObject from gobject");
+ return ;
+ }
+ } else {
+ PyErr_SetString(PyExc_ImportError,
+ "could not import gobject");
+ return ;
+ }
+ if ((module = PyImport_ImportModule("gtk")) != NULL) {
+ _PyGtkWidget_Type = (PyTypeObject *)PyObject_GetAttrString(module, "Widget");
+ if (_PyGtkWidget_Type == NULL) {
+ PyErr_SetString(PyExc_ImportError,
+ "cannot import name Widget from gtk");
+ return ;
+ }
+ _PyGtkWindow_Type = (PyTypeObject *)PyObject_GetAttrString(module, "Window");
+ if (_PyGtkWindow_Type == NULL) {
+ PyErr_SetString(PyExc_ImportError,
+ "cannot import name Window from gtk");
+ return ;
+ }
+ _PyGtkToggleButton_Type = (PyTypeObject *)PyObject_GetAttrString(module, "ToggleButton");
+ if (_PyGtkToggleButton_Type == NULL) {
+ PyErr_SetString(PyExc_ImportError,
+ "cannot import name ToggleButton from gtk");
+ return ;
+ }
+ _PyGtkMenuItem_Type = (PyTypeObject *)PyObject_GetAttrString(module, "MenuItem");
+ if (_PyGtkMenuItem_Type == NULL) {
+ PyErr_SetString(PyExc_ImportError,
+ "cannot import name MenuItem from gtk");
+ return ;
+ }
+ _PyGtkMenu_Type = (PyTypeObject *)PyObject_GetAttrString(module, "Menu");
+ if (_PyGtkMenu_Type == NULL) {
+ PyErr_SetString(PyExc_ImportError,
+ "cannot import name Menu from gtk");
+ return ;
+ }
+ _PyGtkEventBox_Type = (PyTypeObject *)PyObject_GetAttrString(module, "EventBox");
+ if (_PyGtkEventBox_Type == NULL) {
+ PyErr_SetString(PyExc_ImportError,
+ "cannot import name EventBox from gtk");
+ return ;
+ }
+ } else {
+ PyErr_SetString(PyExc_ImportError,
+ "could not import gtk");
+ return ;
+ }
+
+
+#line 541 "plugin.c"
+ pygobject_register_class(d, "XfcePanelPlugin", XFCE_TYPE_PANEL_PLUGIN, &PyXfcePanelPlugin_Type, Py_BuildValue("(O)", &PyGtkEventBox_Type));
+}
diff --git a/panel/enums.c b/panel/plugin_provider.c
similarity index 64%
copy from panel/enums.c
copy to panel/plugin_provider.c
index 5665b76..7e330ac 100644
--- a/panel/enums.c
+++ b/panel/plugin_provider.c
@@ -4,14 +4,14 @@
-#line 6 "enums.override"
+#line 6 "plugin_provider.override"
#include "pygobject.h"
#include <gtk/gtk.h>
-#include <libxfce4panel/libxfce4panel-enum-types.h>
+#include <libxfce4panel/libxfce4panel.h>
extern PyTypeObject PyGtkWidget_Type;
-#line 15 "enums.c"
+#line 15 "plugin_provider.c"
/* ---------- types from other modules ---------- */
@@ -19,17 +19,19 @@ static PyTypeObject *_PyGObject_Type;
#define PyGObject_Type (*_PyGObject_Type)
static PyTypeObject *_PyGtkWidget_Type;
#define PyGtkWidget_Type (*_PyGtkWidget_Type)
+static PyTypeObject *_PyGtkToggleButton_Type;
+#define PyGtkToggleButton_Type (*_PyGtkToggleButton_Type)
/* ---------- forward type declarations ---------- */
-#line 27 "enums.c"
+#line 29 "plugin_provider.c"
/* ----------- functions ----------- */
-const PyMethodDef pyenums_functions[] = {
+const PyMethodDef pyplugin_provider_functions[] = {
{ NULL, NULL, 0, NULL }
};
@@ -37,12 +39,13 @@ const PyMethodDef pyenums_functions[] = {
/* ----------- enums and flags ----------- */
void
-pyenums_add_constants(PyObject *module, const gchar *strip_prefix)
+pyplugin_provider_add_constants(PyObject *module, const gchar *strip_prefix)
{
#ifdef VERSION
PyModule_AddStringConstant(module, "__version__", VERSION);
#endif
- pyg_enum_add(module, "ScreenPosition", strip_prefix, XFCE_TYPE_SCREEN_POSITION);
+ pyg_enum_add(module, "PanelPluginProviderSignal", strip_prefix, XFCE_TYPE_PANEL_PLUGIN_PROVIDER_SIGNAL);
+ pyg_enum_add(module, "PanelPluginProviderPropType", strip_prefix, XFCE_TYPE_PANEL_PLUGIN_PROVIDER_PROP_TYPE);
if (PyErr_Occurred())
PyErr_Print();
@@ -50,7 +53,7 @@ pyenums_add_constants(PyObject *module, const gchar *strip_prefix)
/* initialise stuff extension classes */
void
-pyenums_register_classes(PyObject *d)
+pyplugin_provider_register_classes(PyObject *d)
{
PyObject *module;
@@ -73,6 +76,12 @@ pyenums_register_classes(PyObject *d)
"cannot import name Widget from gtk");
return ;
}
+ _PyGtkToggleButton_Type = (PyTypeObject *)PyObject_GetAttrString(module, "ToggleButton");
+ if (_PyGtkToggleButton_Type == NULL) {
+ PyErr_SetString(PyExc_ImportError,
+ "cannot import name ToggleButton from gtk");
+ return ;
+ }
} else {
PyErr_SetString(PyExc_ImportError,
"could not import gtk");
@@ -80,5 +89,5 @@ pyenums_register_classes(PyObject *d)
}
-#line 84 "enums.c"
+#line 93 "plugin_provider.c"
}
diff --git a/xfconf/channel.c b/xfconf/channel.c
new file mode 100644
index 0000000..2e4004a
--- /dev/null
+++ b/xfconf/channel.c
@@ -0,0 +1,501 @@
+/* -- THIS FILE IS GENERATED - DO NOT EDIT *//* -*- Mode: C; c-basic-offset: 4 -*- */
+
+#include <Python.h>
+
+
+
+#line 6 "channel.override"
+#include "pygobject.h"
+#include <glib.h>
+#include <xfconf/xfconf.h>
+
+#line 13 "channel.c"
+
+
+/* ---------- types from other modules ---------- */
+static PyTypeObject *_PyGObject_Type;
+#define PyGObject_Type (*_PyGObject_Type)
+
+
+/* ---------- forward type declarations ---------- */
+PyTypeObject G_GNUC_INTERNAL PyXfconfChannel_Type;
+
+#line 24 "channel.c"
+
+
+
+/* ----------- XfconfChannel ----------- */
+
+static int
+_wrap_xfconf_channel_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+ static char *kwlist[] = { "channel_name", NULL };
+ char *channel_name;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:XfconfChannel.__init__", kwlist, &channel_name))
+ return -1;
+ self->obj = (GObject *)xfconf_channel_new(channel_name);
+
+ if (!self->obj) {
+ PyErr_SetString(PyExc_RuntimeError, "could not create XfconfChannel object");
+ return -1;
+ }
+ pygobject_register_wrapper((PyObject *)self);
+ return 0;
+}
+
+static PyObject *
+_wrap_xfconf_channel_has_property(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+ static char *kwlist[] = { "property", NULL };
+ char *property;
+ int ret;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:XfconfChannel.has_property", kwlist, &property))
+ return NULL;
+
+ ret = xfconf_channel_has_property(XFCONF_CHANNEL(self->obj), property);
+
+ return PyBool_FromLong(ret);
+
+}
+
+static PyObject *
+_wrap_xfconf_channel_is_property_locked(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+ static char *kwlist[] = { "property", NULL };
+ char *property;
+ int ret;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:XfconfChannel.is_property_locked", kwlist, &property))
+ return NULL;
+
+ ret = xfconf_channel_is_property_locked(XFCONF_CHANNEL(self->obj), property);
+
+ return PyBool_FromLong(ret);
+
+}
+
+static PyObject *
+_wrap_xfconf_channel_reset_property(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+ static char *kwlist[] = { "property_base", "recursive", NULL };
+ char *property_base;
+ int recursive;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs,"si:XfconfChannel.reset_property", kwlist, &property_base, &recursive))
+ return NULL;
+
+ xfconf_channel_reset_property(XFCONF_CHANNEL(self->obj), property_base, recursive);
+
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+#line 49 "channel.override"
+static PyObject *
+_wrap_xfconf_channel_get_properties(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+ static char *kwlist[] = { "property_base", NULL };
+ GHashTable *ret;
+ char* path;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s:XfconfChannel.get_properties", kwlist, &path))
+ return NULL;
+ ret = xfconf_channel_get_properties(XFCONF_CHANNEL(self->obj), path);
+ if (ret) {
+ GHashTableIter iter;
+ gpointer key, value;
+ PyObject* py_ret;
+ py_ret = PyDict_New();
+ g_hash_table_iter_init(&iter, ret);
+ while(g_hash_table_iter_next(&iter, &key, &value)) {
+ PyDict_SetItem(py_ret, PyString_FromString((const char*) key), pyg_value_as_pyobject((GValue*) value, TRUE));
+ }
+ g_hash_table_destroy(ret);
+ return py_ret;
+ }
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+#line 122 "channel.c"
+
+
+static PyObject *
+_wrap_xfconf_channel_get_string(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+ static char *kwlist[] = { "property", "default_value", NULL };
+ char *property, *default_value;
+ gchar *ret;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ss:XfconfChannel.get_string", kwlist, &property, &default_value))
+ return NULL;
+
+ ret = xfconf_channel_get_string(XFCONF_CHANNEL(self->obj), property, default_value);
+
+ if (ret) {
+ PyObject *py_ret = PyString_FromString(ret);
+ g_free(ret);
+ return py_ret;
+ }
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+static PyObject *
+_wrap_xfconf_channel_set_string(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+ static char *kwlist[] = { "property", "value", NULL };
+ char *property, *value;
+ int ret;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ss:XfconfChannel.set_string", kwlist, &property, &value))
+ return NULL;
+
+ ret = xfconf_channel_set_string(XFCONF_CHANNEL(self->obj), property, value);
+
+ return PyBool_FromLong(ret);
+
+}
+
+static PyObject *
+_wrap_xfconf_channel_get_int(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+ static char *kwlist[] = { "property", "default_value", NULL };
+ char *property;
+ int default_value, ret;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs,"si:XfconfChannel.get_int", kwlist, &property, &default_value))
+ return NULL;
+
+ ret = xfconf_channel_get_int(XFCONF_CHANNEL(self->obj), property, default_value);
+
+ return PyInt_FromLong(ret);
+}
+
+static PyObject *
+_wrap_xfconf_channel_set_int(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+ static char *kwlist[] = { "property", "value", NULL };
+ char *property;
+ int value, ret;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs,"si:XfconfChannel.set_int", kwlist, &property, &value))
+ return NULL;
+
+ ret = xfconf_channel_set_int(XFCONF_CHANNEL(self->obj), property, value);
+
+ return PyBool_FromLong(ret);
+
+}
+
+static PyObject *
+_wrap_xfconf_channel_get_uint(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+ static char *kwlist[] = { "property", "default_value", NULL };
+ char *property;
+ guint32 ret;
+ unsigned long default_value;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs,"sk:XfconfChannel.get_uint", kwlist, &property, &default_value))
+ return NULL;
+
+ ret = xfconf_channel_get_uint(XFCONF_CHANNEL(self->obj), property, default_value);
+
+ return PyLong_FromUnsignedLong(ret);
+
+}
+
+static PyObject *
+_wrap_xfconf_channel_set_uint(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+ static char *kwlist[] = { "property", "value", NULL };
+ char *property;
+ int ret;
+ unsigned long value;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs,"sk:XfconfChannel.set_uint", kwlist, &property, &value))
+ return NULL;
+
+ ret = xfconf_channel_set_uint(XFCONF_CHANNEL(self->obj), property, value);
+
+ return PyBool_FromLong(ret);
+
+}
+
+static PyObject *
+_wrap_xfconf_channel_get_uint64(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+ static char *kwlist[] = { "property", "default_value", NULL };
+ char *property;
+ PyObject *py_default_value = NULL;
+ guint64 default_value, ret;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs,"sO!:XfconfChannel.get_uint64", kwlist, &property, &PyLong_Type, &py_default_value))
+ return NULL;
+ default_value = PyLong_AsUnsignedLongLong(py_default_value);
+
+ ret = xfconf_channel_get_uint64(XFCONF_CHANNEL(self->obj), property, default_value);
+
+ return PyLong_FromUnsignedLongLong(ret);
+}
+
+static PyObject *
+_wrap_xfconf_channel_set_uint64(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+ static char *kwlist[] = { "property", "value", NULL };
+ char *property;
+ PyObject *py_value = NULL;
+ int ret;
+ guint64 value;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs,"sO!:XfconfChannel.set_uint64", kwlist, &property, &PyLong_Type, &py_value))
+ return NULL;
+ value = PyLong_AsUnsignedLongLong(py_value);
+
+ ret = xfconf_channel_set_uint64(XFCONF_CHANNEL(self->obj), property, value);
+
+ return PyBool_FromLong(ret);
+
+}
+
+static PyObject *
+_wrap_xfconf_channel_get_double(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+ static char *kwlist[] = { "property", "default_value", NULL };
+ char *property;
+ double default_value, ret;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs,"sd:XfconfChannel.get_double", kwlist, &property, &default_value))
+ return NULL;
+
+ ret = xfconf_channel_get_double(XFCONF_CHANNEL(self->obj), property, default_value);
+
+ return PyFloat_FromDouble(ret);
+}
+
+static PyObject *
+_wrap_xfconf_channel_set_double(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+ static char *kwlist[] = { "property", "value", NULL };
+ char *property;
+ double value;
+ int ret;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs,"sd:XfconfChannel.set_double", kwlist, &property, &value))
+ return NULL;
+
+ ret = xfconf_channel_set_double(XFCONF_CHANNEL(self->obj), property, value);
+
+ return PyBool_FromLong(ret);
+
+}
+
+static PyObject *
+_wrap_xfconf_channel_get_bool(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+ static char *kwlist[] = { "property", "default_value", NULL };
+ char *property;
+ int default_value, ret;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs,"si:XfconfChannel.get_bool", kwlist, &property, &default_value))
+ return NULL;
+
+ ret = xfconf_channel_get_bool(XFCONF_CHANNEL(self->obj), property, default_value);
+
+ return PyBool_FromLong(ret);
+
+}
+
+static PyObject *
+_wrap_xfconf_channel_set_bool(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+ static char *kwlist[] = { "property", "value", NULL };
+ char *property;
+ int value, ret;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs,"si:XfconfChannel.set_bool", kwlist, &property, &value))
+ return NULL;
+
+ ret = xfconf_channel_set_bool(XFCONF_CHANNEL(self->obj), property, value);
+
+ return PyBool_FromLong(ret);
+
+}
+
+static const PyMethodDef _PyXfconfChannel_methods[] = {
+ { "has_property", (PyCFunction)_wrap_xfconf_channel_has_property, METH_VARARGS|METH_KEYWORDS,
+ NULL },
+ { "is_property_locked", (PyCFunction)_wrap_xfconf_channel_is_property_locked, METH_VARARGS|METH_KEYWORDS,
+ NULL },
+ { "reset_property", (PyCFunction)_wrap_xfconf_channel_reset_property, METH_VARARGS|METH_KEYWORDS,
+ NULL },
+ { "get_properties", (PyCFunction)_wrap_xfconf_channel_get_properties, METH_VARARGS|METH_KEYWORDS,
+ NULL },
+ { "get_string", (PyCFunction)_wrap_xfconf_channel_get_string, METH_VARARGS|METH_KEYWORDS,
+ NULL },
+ { "set_string", (PyCFunction)_wrap_xfconf_channel_set_string, METH_VARARGS|METH_KEYWORDS,
+ NULL },
+ { "get_int", (PyCFunction)_wrap_xfconf_channel_get_int, METH_VARARGS|METH_KEYWORDS,
+ NULL },
+ { "set_int", (PyCFunction)_wrap_xfconf_channel_set_int, METH_VARARGS|METH_KEYWORDS,
+ NULL },
+ { "get_uint", (PyCFunction)_wrap_xfconf_channel_get_uint, METH_VARARGS|METH_KEYWORDS,
+ NULL },
+ { "set_uint", (PyCFunction)_wrap_xfconf_channel_set_uint, METH_VARARGS|METH_KEYWORDS,
+ NULL },
+ { "get_uint64", (PyCFunction)_wrap_xfconf_channel_get_uint64, METH_VARARGS|METH_KEYWORDS,
+ NULL },
+ { "set_uint64", (PyCFunction)_wrap_xfconf_channel_set_uint64, METH_VARARGS|METH_KEYWORDS,
+ NULL },
+ { "get_double", (PyCFunction)_wrap_xfconf_channel_get_double, METH_VARARGS|METH_KEYWORDS,
+ NULL },
+ { "set_double", (PyCFunction)_wrap_xfconf_channel_set_double, METH_VARARGS|METH_KEYWORDS,
+ NULL },
+ { "get_bool", (PyCFunction)_wrap_xfconf_channel_get_bool, METH_VARARGS|METH_KEYWORDS,
+ NULL },
+ { "set_bool", (PyCFunction)_wrap_xfconf_channel_set_bool, METH_VARARGS|METH_KEYWORDS,
+ NULL },
+ { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyXfconfChannel_Type = {
+ PyObject_HEAD_INIT(NULL)
+ 0, /* ob_size */
+ "classgroup.Channel", /* tp_name */
+ sizeof(PyGObject), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ /* methods */
+ (destructor)0, /* tp_dealloc */
+ (printfunc)0, /* tp_print */
+ (getattrfunc)0, /* tp_getattr */
+ (setattrfunc)0, /* tp_setattr */
+ (cmpfunc)0, /* tp_compare */
+ (reprfunc)0, /* tp_repr */
+ (PyNumberMethods*)0, /* tp_as_number */
+ (PySequenceMethods*)0, /* tp_as_sequence */
+ (PyMappingMethods*)0, /* tp_as_mapping */
+ (hashfunc)0, /* tp_hash */
+ (ternaryfunc)0, /* tp_call */
+ (reprfunc)0, /* tp_str */
+ (getattrofunc)0, /* tp_getattro */
+ (setattrofunc)0, /* tp_setattro */
+ (PyBufferProcs*)0, /* tp_as_buffer */
+ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
+ NULL, /* Documentation string */
+ (traverseproc)0, /* tp_traverse */
+ (inquiry)0, /* tp_clear */
+ (richcmpfunc)0, /* tp_richcompare */
+ offsetof(PyGObject, weakreflist), /* tp_weaklistoffset */
+ (getiterfunc)0, /* tp_iter */
+ (iternextfunc)0, /* tp_iternext */
+ (struct PyMethodDef*)_PyXfconfChannel_methods, /* tp_methods */
+ (struct PyMemberDef*)0, /* tp_members */
+ (struct PyGetSetDef*)0, /* tp_getset */
+ NULL, /* tp_base */
+ NULL, /* tp_dict */
+ (descrgetfunc)0, /* tp_descr_get */
+ (descrsetfunc)0, /* tp_descr_set */
+ offsetof(PyGObject, inst_dict), /* tp_dictoffset */
+ (initproc)_wrap_xfconf_channel_new, /* tp_init */
+ (allocfunc)0, /* tp_alloc */
+ (newfunc)0, /* tp_new */
+ (freefunc)0, /* tp_free */
+ (inquiry)0 /* tp_is_gc */
+};
+
+
+
+/* ----------- functions ----------- */
+
+#line 25 "channel.override"
+static PyObject *
+_wrap_xfconf_list_channels(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+ static char *kwlist[] = { NULL };
+ gchar **ret;
+ int i;
+ int count;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs, ":list_channels", kwlist))
+ return NULL;
+ ret = xfconf_list_channels();
+ if (ret) {
+ count = g_strv_length(ret);
+ PyObject *py_ret = PyList_New(count);
+ for(i = 0; i < count; ++i)
+ PyList_SetItem(py_ret, i, PyString_FromString(ret[i]));
+ g_strfreev(ret);
+ return py_ret;
+ }
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+#line 435 "channel.c"
+
+
+static PyObject *
+_wrap_xfconf_channel_get(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+ static char *kwlist[] = { "channel_name", NULL };
+ char *channel_name;
+ XfconfChannel *ret;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:channel_get", kwlist, &channel_name))
+ return NULL;
+
+ ret = xfconf_channel_get(channel_name);
+
+ /* pygobject_new handles NULL checking */
+ return pygobject_new((GObject *)ret);
+}
+
+static PyObject *
+_wrap_xfconf_channel_new_with_property_base(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+ static char *kwlist[] = { "channel_name", "property_base", NULL };
+ char *channel_name, *property_base;
+ XfconfChannel *ret;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ss:channel_new_with_property_base", kwlist, &channel_name, &property_base))
+ return NULL;
+
+ ret = xfconf_channel_new_with_property_base(channel_name, property_base);
+
+ /* pygobject_new handles NULL checking */
+ return pygobject_new((GObject *)ret);
+}
+
+const PyMethodDef pychannel_functions[] = {
+ { "list_channels", (PyCFunction)_wrap_xfconf_list_channels, METH_VARARGS|METH_KEYWORDS,
+ NULL },
+ { "channel_get", (PyCFunction)_wrap_xfconf_channel_get, METH_VARARGS|METH_KEYWORDS,
+ NULL },
+ { "channel_new_with_property_base", (PyCFunction)_wrap_xfconf_channel_new_with_property_base, METH_VARARGS|METH_KEYWORDS,
+ NULL },
+ { NULL, NULL, 0, NULL }
+};
+
+/* initialise stuff extension classes */
+void
+pychannel_register_classes(PyObject *d)
+{
+ PyObject *module;
+
+ if ((module = PyImport_ImportModule("gobject")) != NULL) {
+ _PyGObject_Type = (PyTypeObject *)PyObject_GetAttrString(module, "GObject");
+ if (_PyGObject_Type == NULL) {
+ PyErr_SetString(PyExc_ImportError,
+ "cannot import name GObject from gobject");
+ return ;
+ }
+ } else {
+ PyErr_SetString(PyExc_ImportError,
+ "could not import gobject");
+ return ;
+ }
+
+
+#line 500 "channel.c"
+ pygobject_register_class(d, "XfconfChannel", XFCONF_TYPE_CHANNEL, &PyXfconfChannel_Type, Py_BuildValue("(O)", &PyGObject_Type));
+}
diff --git a/xfconf/channel.defs b/xfconf/channel.defs
new file mode 100644
index 0000000..9e81c17
--- /dev/null
+++ b/xfconf/channel.defs
@@ -0,0 +1,408 @@
+(define-object Channel
+ (in-module "Xfce")
+ (parent "GObject")
+ (c-name "XfconfChannel")
+ (gtype-id "XFCONF_TYPE_CHANNEL")
+)
+
+(define-function list_channels
+ (c-name "xfconf_list_channels")
+ (return-type "gchar**")
+ (parameters
+ )
+)
+
+;; -*- scheme -*-
+; object definitions ...
+;; Enumerations and flags ...
+
+
+;; From xfconf-channel.h
+
+(define-function channel_get_type
+ (c-name "xfconf_channel_get_type")
+ (return-type "GType")
+ (parameters
+ )
+)
+
+(define-function channel_get
+ (c-name "xfconf_channel_get")
+ (return-type "XfconfChannel*")
+ (parameters
+ '("const-gchar*" "channel_name")
+ )
+)
+
+(define-function channel_new
+ (c-name "xfconf_channel_new")
+ (is-constructor-of "XfconfChannel")
+ (return-type "XfconfChannel*")
+ (parameters
+ '("const-gchar*" "channel_name")
+ )
+)
+
+(define-function channel_new_with_property_base
+ (c-name "xfconf_channel_new_with_property_base")
+ (return-type "XfconfChannel*")
+ (parameters
+ '("const-gchar*" "channel_name")
+ '("const-gchar*" "property_base")
+ )
+)
+
+(define-method has_property
+ (of-object "XfconfChannel")
+ (c-name "xfconf_channel_has_property")
+ (return-type "gboolean")
+ (parameters
+ '("const-gchar*" "property")
+ )
+)
+
+(define-method is_property_locked
+ (of-object "XfconfChannel")
+ (c-name "xfconf_channel_is_property_locked")
+ (return-type "gboolean")
+ (parameters
+ '("const-gchar*" "property")
+ )
+)
+
+(define-method reset_property
+ (of-object "XfconfChannel")
+ (c-name "xfconf_channel_reset_property")
+ (return-type "none")
+ (parameters
+ '("const-gchar*" "property_base")
+ '("gboolean" "recursive")
+ )
+)
+
+(define-method get_properties
+ (of-object "XfconfChannel")
+ (c-name "xfconf_channel_get_properties")
+ (return-type "GHashTable*")
+ (parameters
+ '("const-gchar*" "property_base")
+ )
+)
+
+(define-method get_string
+ (of-object "XfconfChannel")
+ (c-name "xfconf_channel_get_string")
+ (return-type "gchar*")
+ (parameters
+ '("const-gchar*" "property")
+ '("const-gchar*" "default_value")
+ )
+)
+
+(define-method set_string
+ (of-object "XfconfChannel")
+ (c-name "xfconf_channel_set_string")
+ (return-type "gboolean")
+ (parameters
+ '("const-gchar*" "property")
+ '("const-gchar*" "value")
+ )
+)
+
+(define-method get_int
+ (of-object "XfconfChannel")
+ (c-name "xfconf_channel_get_int")
+ (return-type "gint32")
+ (parameters
+ '("const-gchar*" "property")
+ '("gint32" "default_value")
+ )
+)
+
+(define-method set_int
+ (of-object "XfconfChannel")
+ (c-name "xfconf_channel_set_int")
+ (return-type "gboolean")
+ (parameters
+ '("const-gchar*" "property")
+ '("gint32" "value")
+ )
+)
+
+(define-method get_uint
+ (of-object "XfconfChannel")
+ (c-name "xfconf_channel_get_uint")
+ (return-type "guint32")
+ (parameters
+ '("const-gchar*" "property")
+ '("guint32" "default_value")
+ )
+)
+
+(define-method set_uint
+ (of-object "XfconfChannel")
+ (c-name "xfconf_channel_set_uint")
+ (return-type "gboolean")
+ (parameters
+ '("const-gchar*" "property")
+ '("guint32" "value")
+ )
+)
+
+(define-method get_uint64
+ (of-object "XfconfChannel")
+ (c-name "xfconf_channel_get_uint64")
+ (return-type "guint64")
+ (parameters
+ '("const-gchar*" "property")
+ '("guint64" "default_value")
+ )
+)
+
+(define-method set_uint64
+ (of-object "XfconfChannel")
+ (c-name "xfconf_channel_set_uint64")
+ (return-type "gboolean")
+ (parameters
+ '("const-gchar*" "property")
+ '("guint64" "value")
+ )
+)
+
+(define-method get_double
+ (of-object "XfconfChannel")
+ (c-name "xfconf_channel_get_double")
+ (return-type "gdouble")
+ (parameters
+ '("const-gchar*" "property")
+ '("gdouble" "default_value")
+ )
+)
+
+(define-method set_double
+ (of-object "XfconfChannel")
+ (c-name "xfconf_channel_set_double")
+ (return-type "gboolean")
+ (parameters
+ '("const-gchar*" "property")
+ '("gdouble" "value")
+ )
+)
+
+(define-method get_bool
+ (of-object "XfconfChannel")
+ (c-name "xfconf_channel_get_bool")
+ (return-type "gboolean")
+ (parameters
+ '("const-gchar*" "property")
+ '("gboolean" "default_value")
+ )
+)
+
+(define-method set_bool
+ (of-object "XfconfChannel")
+ (c-name "xfconf_channel_set_bool")
+ (return-type "gboolean")
+ (parameters
+ '("const-gchar*" "property")
+ '("gboolean" "value")
+ )
+)
+
+(define-method get_string_list
+ (of-object "XfconfChannel")
+ (c-name "xfconf_channel_get_string_list")
+ (return-type "gchar**")
+ (parameters
+ '("const-gchar*" "property")
+ )
+)
+
+(define-method set_string_list
+ (of-object "XfconfChannel")
+ (c-name "xfconf_channel_set_string_list")
+ (return-type "gboolean")
+ (parameters
+ '("const-gchar*" "property")
+ '("const-gchar*-const*" "values")
+ )
+)
+
+(define-method get_property
+ (of-object "XfconfChannel")
+ (c-name "xfconf_channel_get_property")
+ (return-type "gboolean")
+ (parameters
+ '("const-gchar*" "property")
+ '("GValue*" "value")
+ )
+)
+
+(define-method set_property
+ (of-object "XfconfChannel")
+ (c-name "xfconf_channel_set_property")
+ (return-type "gboolean")
+ (parameters
+ '("const-gchar*" "property")
+ '("const-GValue*" "value")
+ )
+)
+
+(define-method get_array
+ (of-object "XfconfChannel")
+ (c-name "xfconf_channel_get_array")
+ (return-type "gboolean")
+ (parameters
+ '("const-gchar*" "property")
+ '("GType" "first_value_type")
+ )
+ (varargs #t)
+)
+
+(define-method get_array_valist
+ (of-object "XfconfChannel")
+ (c-name "xfconf_channel_get_array_valist")
+ (return-type "gboolean")
+ (parameters
+ '("const-gchar*" "property")
+ '("GType" "first_value_type")
+ '("va_list" "var_args")
+ )
+)
+
+(define-method get_arrayv
+ (of-object "XfconfChannel")
+ (c-name "xfconf_channel_get_arrayv")
+ (return-type "GPtrArray*")
+ (parameters
+ '("const-gchar*" "property")
+ )
+)
+
+(define-method set_array
+ (of-object "XfconfChannel")
+ (c-name "xfconf_channel_set_array")
+ (return-type "gboolean")
+ (parameters
+ '("const-gchar*" "property")
+ '("GType" "first_value_type")
+ )
+ (varargs #t)
+)
+
+(define-method set_array_valist
+ (of-object "XfconfChannel")
+ (c-name "xfconf_channel_set_array_valist")
+ (return-type "gboolean")
+ (parameters
+ '("const-gchar*" "property")
+ '("GType" "first_value_type")
+ '("va_list" "var_args")
+ )
+)
+
+(define-method set_arrayv
+ (of-object "XfconfChannel")
+ (c-name "xfconf_channel_set_arrayv")
+ (return-type "gboolean")
+ (parameters
+ '("const-gchar*" "property")
+ '("GPtrArray*" "values")
+ )
+)
+
+(define-method get_named_struct
+ (of-object "XfconfChannel")
+ (c-name "xfconf_channel_get_named_struct")
+ (return-type "gboolean")
+ (parameters
+ '("const-gchar*" "property")
+ '("const-gchar*" "struct_name")
+ '("gpointer" "value_struct")
+ )
+)
+
+(define-method set_named_struct
+ (of-object "XfconfChannel")
+ (c-name "xfconf_channel_set_named_struct")
+ (return-type "gboolean")
+ (parameters
+ '("const-gchar*" "property")
+ '("const-gchar*" "struct_name")
+ '("gpointer" "value_struct")
+ )
+)
+
+(define-method get_struct
+ (of-object "XfconfChannel")
+ (c-name "xfconf_channel_get_struct")
+ (return-type "gboolean")
+ (parameters
+ '("const-gchar*" "property")
+ '("gpointer" "value_struct")
+ '("GType" "first_member_type")
+ )
+ (varargs #t)
+)
+
+(define-method get_struct_valist
+ (of-object "XfconfChannel")
+ (c-name "xfconf_channel_get_struct_valist")
+ (return-type "gboolean")
+ (parameters
+ '("const-gchar*" "property")
+ '("gpointer" "value_struct")
+ '("GType" "first_member_type")
+ '("va_list" "var_args")
+ )
+)
+
+(define-method get_structv
+ (of-object "XfconfChannel")
+ (c-name "xfconf_channel_get_structv")
+ (return-type "gboolean")
+ (parameters
+ '("const-gchar*" "property")
+ '("gpointer" "value_struct")
+ '("guint" "n_members")
+ '("GType*" "member_types")
+ )
+)
+
+(define-method set_struct
+ (of-object "XfconfChannel")
+ (c-name "xfconf_channel_set_struct")
+ (return-type "gboolean")
+ (parameters
+ '("const-gchar*" "property")
+ '("const-gpointer" "value_struct")
+ '("GType" "first_member_type")
+ )
+ (varargs #t)
+)
+
+(define-method set_struct_valist
+ (of-object "XfconfChannel")
+ (c-name "xfconf_channel_set_struct_valist")
+ (return-type "gboolean")
+ (parameters
+ '("const-gchar*" "property")
+ '("const-gpointer" "value_struct")
+ '("GType" "first_member_type")
+ '("va_list" "var_args")
+ )
+)
+
+(define-method set_structv
+ (of-object "XfconfChannel")
+ (c-name "xfconf_channel_set_structv")
+ (return-type "gboolean")
+ (parameters
+ '("const-gchar*" "property")
+ '("const-gpointer" "value_struct")
+ '("guint" "n_members")
+ '("GType*" "member_types")
+ )
+)
+
+
diff --git a/xfconf/binding.c b/xfconf/errors.c
similarity index 59%
copy from xfconf/binding.c
copy to xfconf/errors.c
index 144c89c..5ff8ac0 100644
--- a/xfconf/binding.c
+++ b/xfconf/errors.c
@@ -4,12 +4,12 @@
-#line 6 "binding.override"
+#line 6 "errors.override"
#include "pygobject.h"
#include <glib.h>
#include <xfconf/xfconf.h>
-#line 13 "binding.c"
+#line 13 "errors.c"
/* ---------- types from other modules ---------- */
@@ -19,36 +19,34 @@ static PyTypeObject *_PyGObject_Type;
/* ---------- forward type declarations ---------- */
-#line 23 "binding.c"
+#line 23 "errors.c"
/* ----------- functions ----------- */
-static PyObject *
-_wrap_xfconf_g_property_unbind(PyObject *self, PyObject *args, PyObject *kwargs)
-{
- static char *kwlist[] = { "id", NULL };
- unsigned long id;
-
- if (!PyArg_ParseTupleAndKeywords(args, kwargs,"k:g_property_unbind", kwlist, &id))
- return NULL;
-
- xfconf_g_property_unbind(id);
-
- Py_INCREF(Py_None);
- return Py_None;
-}
-
-const PyMethodDef pybinding_functions[] = {
- { "g_property_unbind", (PyCFunction)_wrap_xfconf_g_property_unbind, METH_VARARGS|METH_KEYWORDS,
- NULL },
+const PyMethodDef pyerrors_functions[] = {
{ NULL, NULL, 0, NULL }
};
+
+/* ----------- enums and flags ----------- */
+
+void
+pyerrors_add_constants(PyObject *module, const gchar *strip_prefix)
+{
+#ifdef VERSION
+ PyModule_AddStringConstant(module, "__version__", VERSION);
+#endif
+ pyg_enum_add(module, "Error", strip_prefix, XFCONF_TYPE_ERROR);
+
+ if (PyErr_Occurred())
+ PyErr_Print();
+}
+
/* initialise stuff extension classes */
void
-pybinding_register_classes(PyObject *d)
+pyerrors_register_classes(PyObject *d)
{
PyObject *module;
@@ -66,5 +64,5 @@ pybinding_register_classes(PyObject *d)
}
-#line 70 "binding.c"
+#line 68 "errors.c"
}
diff --git a/xfconf/errors.defs b/xfconf/errors.defs
new file mode 100644
index 0000000..9ba36e7
--- /dev/null
+++ b/xfconf/errors.defs
@@ -0,0 +1,40 @@
+;; -*- scheme -*-
+; object definitions ...
+;; Enumerations and flags ...
+
+(define-enum Error
+ (in-module "Xfconf")
+ (c-name "XfconfError")
+ (gtype-id "XFCONF_TYPE_ERROR")
+ (values
+ '("unknown" "XFCONF_ERROR_UNKNOWN")
+ '("channel-not-found" "XFCONF_ERROR_CHANNEL_NOT_FOUND")
+ '("property-not-found" "XFCONF_ERROR_PROPERTY_NOT_FOUND")
+ '("read-failure" "XFCONF_ERROR_READ_FAILURE")
+ '("write-failure" "XFCONF_ERROR_WRITE_FAILURE")
+ '("permission-denied" "XFCONF_ERROR_PERMISSION_DENIED")
+ '("internal-error" "XFCONF_ERROR_INTERNAL_ERROR")
+ '("no-backend" "XFCONF_ERROR_NO_BACKEND")
+ '("invalid-property" "XFCONF_ERROR_INVALID_PROPERTY")
+ '("invalid-channel" "XFCONF_ERROR_INVALID_CHANNEL")
+ )
+)
+
+
+;; From xfconf-errors.h
+
+(define-function error_get_type
+ (c-name "xfconf_error_get_type")
+ (return-type "GType")
+ (parameters
+ )
+)
+
+(define-function get_error_quark
+ (c-name "xfconf_get_error_quark")
+ (return-type "GQuark")
+ (parameters
+ )
+)
+
+
diff --git a/util/rc.c b/xfconf/types.c
similarity index 66%
copy from util/rc.c
copy to xfconf/types.c
index b400e14..45547d0 100644
--- a/util/rc.c
+++ b/xfconf/types.c
@@ -4,12 +4,12 @@
-#line 6 "rc.override"
+#line 6 "types.override"
#include "pygobject.h"
-#include <gtk/gtk.h>
-#include <libxfce4util/libxfce4util.h>
+#include <glib.h>
+#include <xfconf/xfconf.h>
-#line 13 "rc.c"
+#line 13 "types.c"
/* ---------- types from other modules ---------- */
@@ -19,37 +19,35 @@ static PyTypeObject *_PyGObject_Type;
/* ---------- forward type declarations ---------- */
-#line 23 "rc.c"
+#line 23 "types.c"
/* ----------- functions ----------- */
-PyMethodDef pyrc_functions[] = {
- { NULL, NULL, 0 }
+const PyMethodDef pytypes_functions[] = {
+ { NULL, NULL, 0, NULL }
};
/* initialise stuff extension classes */
void
-pyrc_register_classes(PyObject *d)
+pytypes_register_classes(PyObject *d)
{
PyObject *module;
if ((module = PyImport_ImportModule("gobject")) != NULL) {
- PyObject *moddict = PyModule_GetDict(module);
-
- _PyGObject_Type = (PyTypeObject *)PyDict_GetItemString(moddict, "GObject");
+ _PyGObject_Type = (PyTypeObject *)PyObject_GetAttrString(module, "GObject");
if (_PyGObject_Type == NULL) {
PyErr_SetString(PyExc_ImportError,
"cannot import name GObject from gobject");
- return;
+ return ;
}
} else {
PyErr_SetString(PyExc_ImportError,
"could not import gobject");
- return;
+ return ;
}
-#line 55 "rc.c"
+#line 53 "types.c"
}
diff --git a/xfconf/types.defs b/xfconf/types.defs
new file mode 100644
index 0000000..c986923
--- /dev/null
+++ b/xfconf/types.defs
@@ -0,0 +1,56 @@
+;; -*- scheme -*-
+; object definitions ...
+;; Enumerations and flags ...
+
+
+;; From xfconf-types.h
+
+(define-function uint16_get_type
+ (c-name "xfconf_uint16_get_type")
+ (return-type "GType")
+ (parameters
+ )
+)
+
+(define-function g_value_get_uint16
+ (c-name "xfconf_g_value_get_uint16")
+ (return-type "guint16")
+ (parameters
+ '("const-GValue*" "value")
+ )
+)
+
+(define-function g_value_set_uint16
+ (c-name "xfconf_g_value_set_uint16")
+ (return-type "none")
+ (parameters
+ '("GValue*" "value")
+ '("guint16" "v_uint16")
+ )
+)
+
+(define-function int16_get_type
+ (c-name "xfconf_int16_get_type")
+ (return-type "GType")
+ (parameters
+ )
+)
+
+(define-function g_value_get_int16
+ (c-name "xfconf_g_value_get_int16")
+ (return-type "gint16")
+ (parameters
+ '("const-GValue*" "value")
+ )
+)
+
+(define-function g_value_set_int16
+ (c-name "xfconf_g_value_set_int16")
+ (return-type "none")
+ (parameters
+ '("GValue*" "value")
+ '("gint16" "v_int16")
+ )
+)
+
+
More information about the Xfce4-commits
mailing list