diff options
author | James Henstridge <jamesh@src.gnome.org> | 2002-01-23 14:29:11 +0000 |
---|---|---|
committer | James Henstridge <jamesh@src.gnome.org> | 2002-01-23 14:29:11 +0000 |
commit | 080a3c0b0a41b1a6978583e7bfc80c471479408b (patch) | |
tree | ded4fcc40fcfcc65cf193b1632eba73872b20d25 | |
parent | a8df46b15891900651eda79a178fa17b4f292d45 (diff) | |
download | pygobject-080a3c0b0a41b1a6978583e7bfc80c471479408b.tar.gz pygobject-080a3c0b0a41b1a6978583e7bfc80c471479408b.tar.xz pygobject-080a3c0b0a41b1a6978583e7bfc80c471479408b.zip |
(add_property_docs): fix small bug.
-rw-r--r-- | gobject/pygobject.c | 817 | ||||
-rw-r--r-- | gobject/pygtype.c | 2 |
2 files changed, 818 insertions, 1 deletions
diff --git a/gobject/pygobject.c b/gobject/pygobject.c new file mode 100644 index 0000000..b051b1e --- /dev/null +++ b/gobject/pygobject.c @@ -0,0 +1,817 @@ +#include "pygobject-private.h" + +static const gchar *pygobject_class_id = "PyGObject::class"; +static GQuark pygobject_class_key = 0; +static const gchar *pygobject_wrapper_id = "PyGObject::wrapper"; +static GQuark pygobject_wrapper_key = 0; +static const gchar *pygobject_ownedref_id = "PyGObject::ownedref"; +static GQuark pygobject_ownedref_key = 0; + + +static void pygobject_dealloc(PyGObject *self); +static int pygobject_traverse(PyGObject *self, visitproc visit, void *arg); + +/* -------------- class <-> wrapper manipulation --------------- */ + +void +pygobject_register_class(PyObject *dict, const gchar *type_name, + GType gtype, PyTypeObject *type, + PyObject *bases) +{ + PyObject *o; + const char *class_name, *s; + + if (!pygobject_class_key) + pygobject_class_key = g_quark_from_static_string(pygobject_class_id); + + class_name = type->tp_name; + s = strrchr(class_name, '.'); + if (s != NULL) + class_name = s + 1; + + type->ob_type = &PyType_Type; + if (bases) { + type->tp_bases = bases; + type->tp_base = (PyTypeObject *)PyTuple_GetItem(bases, 0); + } + + type->tp_dealloc = (destructor)pygobject_dealloc; + type->tp_traverse = (traverseproc)pygobject_traverse; + type->tp_flags |= Py_TPFLAGS_HAVE_GC; + type->tp_weaklistoffset = offsetof(PyGObject, weakreflist); + type->tp_dictoffset = offsetof(PyGObject, inst_dict); + + if (PyType_Ready(type) < 0) { + g_warning ("couldn't make the type `%s' ready", type->tp_name); + return; + } + + if (gtype) { + o = pyg_type_wrapper_new(gtype); + PyDict_SetItemString(type->tp_dict, "__gtype__", o); + Py_DECREF(o); + + /* stash a pointer to the python class with the GType */ + Py_INCREF(type); + g_type_set_qdata(gtype, pygobject_class_key, type); + } + + PyDict_SetItemString(dict, (char *)class_name, (PyObject *)type); +} + +void +pygobject_register_wrapper(PyObject *self) +{ + GObject *obj = ((PyGObject *)self)->obj; + + if (!pygobject_wrapper_key) + pygobject_wrapper_key=g_quark_from_static_string(pygobject_wrapper_id); + + /* g_object_ref(obj); -- not needed because no floating reference */ + g_object_set_qdata(obj, pygobject_wrapper_key, self); +} + +PyTypeObject * +pygobject_lookup_class(GType gtype) +{ + PyTypeObject *type = NULL; + + /* find the python type for this object. If not found, use parent. */ + while (gtype != G_TYPE_INVALID && + (type = g_type_get_qdata(gtype, pygobject_class_key)) == NULL) + gtype = g_type_parent(gtype); + g_assert(type != NULL); + return type; +} + +PyObject * +pygobject_new(GObject *obj) +{ + PyGObject *self; + PyTypeObject *tp; + + if (!pygobject_wrapper_key) + pygobject_wrapper_key=g_quark_from_static_string(pygobject_wrapper_id); + if (!pygobject_ownedref_key) + pygobject_ownedref_key = + g_quark_from_static_string(pygobject_ownedref_id); + + if (obj == NULL) { + Py_INCREF(Py_None); + return Py_None; + } + + /* we already have a wrapper for this object -- return it. */ + if ((self = (PyGObject *)g_object_get_qdata(obj, pygobject_wrapper_key))) { + /* if the GObject currently owns the wrapper reference ... */ + if (self->hasref) { + self->hasref = FALSE; + g_object_steal_qdata(obj, pygobject_ownedref_key); + g_object_ref(obj); + } else + Py_INCREF(self); + return (PyObject *)self; + } + + tp = pygobject_lookup_class(G_TYPE_FROM_INSTANCE(obj)); + self = PyObject_GC_New(PyGObject, tp); + + if (self == NULL) + return NULL; + self->obj = g_object_ref(obj); + self->hasref = FALSE; + self->inst_dict = NULL; + self->weakreflist = NULL; + /* save wrapper pointer so we can access it later */ + g_object_set_qdata(obj, pygobject_wrapper_key, self); + + PyObject_GC_Track((PyObject *)self); + + return (PyObject *)self; +} + +/* -------------- PyGObject behaviour ----------------- */ + +static void +pygobject_dealloc(PyGObject *self) +{ + GObject *obj = self->obj; + + if (!pygobject_ownedref_key) + pygobject_ownedref_key = + g_quark_from_static_string(pygobject_ownedref_id); + + /* save reference to python wrapper if there are still + * references to the GObject in such a way that it will be + * freed when the GObject is destroyed, so is the python + * wrapper, but if a python wrapper can be */ + if (obj && obj->ref_count > 1) { + Py_INCREF(self); /* grab a reference on the wrapper */ + self->hasref = TRUE; + g_object_set_qdata_full(obj, pygobject_ownedref_key, + self, pyg_destroy_notify); + g_object_unref(obj); + + /* we ref the type, so subtype_dealloc() doesn't kill off our + * instance's type. */ + if (self->ob_type->tp_flags & Py_TPFLAGS_HEAPTYPE) + Py_INCREF(self->ob_type); + +#ifdef Py_TRACE_REFS + /* if we're tracing refs, set up the reflist again, as it was just + * torn down */ + _Py_NewReference((PyObject *) self); +#endif + + return; + } + if (obj && !self->hasref) /* don't unref the GObject if it owns us */ + g_object_unref(obj); + + PyObject_ClearWeakRefs((PyObject *)self); + + PyObject_GC_UnTrack((PyObject *)self); + + if (self->inst_dict) { + Py_DECREF(self->inst_dict); + } + self->inst_dict = NULL; + + /* the following causes problems with subclassed types */ + /*self->ob_type->tp_free((PyObject *)self); */ + PyObject_GC_Del(self); +} + +static int +pygobject_compare(PyGObject *self, PyGObject *v) +{ + if (self->obj == v->obj) return 0; + if (self->obj > v->obj) return -1; + return 1; +} + +static long +pygobject_hash(PyGObject *self) +{ + return (long)self->obj; +} + +static PyObject * +pygobject_repr(PyGObject *self) +{ + gchar buf[256]; + + g_snprintf(buf, sizeof(buf), + "<%s object (%s) at 0x%lx>", + self->ob_type->tp_name, + self->obj ? G_OBJECT_TYPE_NAME(self->obj) : "uninitialized", + (long)self); + return PyString_FromString(buf); +} + +static int +pygobject_traverse(PyGObject *self, visitproc visit, void *arg) +{ + if (self->inst_dict) + return visit(self->inst_dict, arg); + return 0; +} + +static void +pygobject_free(PyObject *op) +{ + PyObject_GC_Del(op); +} + +/* ---------------- PyGObject methods ----------------- */ + +static int +pygobject_init(PyGObject *self, PyObject *args, PyObject *kwargs) +{ + GType object_type; + + if (!PyArg_ParseTuple(args, ":GObject.__init__", &object_type)) + return -1; + + object_type = pyg_type_from_object((PyObject *)self); + if (!object_type) + return -1; + + self->obj = g_object_new(object_type, NULL); + if (!self->obj) { + PyErr_SetString(PyExc_RuntimeError, "could not create object"); + return -1; + } + pygobject_register_wrapper((PyObject *)self); + + return 0; +} + +static PyObject * +pygobject__gobject_init__(PyGObject *self, PyObject *args, PyObject *kwargs) +{ + if (pygobject_init(self, args, kwargs) < 0) + return NULL; + Py_INCREF(Py_None); + return Py_None; +} + +static PyObject * +pygobject_get_property(PyGObject *self, PyObject *args) +{ + gchar *param_name; + GParamSpec *pspec; + GValue value = { 0, }; + PyObject *ret; + + if (!PyArg_ParseTuple(args, "s:GObject.get_property", ¶m_name)) + return NULL; + pspec = g_object_class_find_property(G_OBJECT_GET_CLASS(self->obj), + param_name); + if (!pspec) { + PyErr_SetString(PyExc_TypeError, + "the object does not support the given parameter"); + return NULL; + } + g_value_init(&value, G_PARAM_SPEC_VALUE_TYPE(pspec)); + g_object_get_property(self->obj, param_name, &value); + ret = pyg_value_as_pyobject(&value); + g_value_unset(&value); + return ret; +} + +static PyObject * +pygobject_set_property(PyGObject *self, PyObject *args) +{ + gchar *param_name; + GParamSpec *pspec; + GValue value = { 0, }; + PyObject *pvalue; + + if (!PyArg_ParseTuple(args, "sO:GObject.set_property", ¶m_name, + &pvalue)) + return NULL; + pspec = g_object_class_find_property(G_OBJECT_GET_CLASS(self->obj), + param_name); + if (!pspec) { + PyErr_SetString(PyExc_TypeError, + "the object does not support the given parameter"); + return NULL; + } + g_value_init(&value, G_PARAM_SPEC_VALUE_TYPE(pspec)); + if (pyg_value_from_pyobject(&value, pvalue) < 0) { + PyErr_SetString(PyExc_TypeError, + "could not convert argument to correct param type"); + return NULL; + } + g_object_set_property(self->obj, param_name, &value); + g_value_unset(&value); + Py_INCREF(Py_None); + return Py_None; +} + +static PyObject * +pygobject_freeze_notify(PyGObject *self, PyObject *args) +{ + if (!PyArg_ParseTuple(args, ":GObject.freeze_notify")) + return NULL; + g_object_freeze_notify(self->obj); + Py_INCREF(Py_None); + return Py_None; +} + +static PyObject * +pygobject_notify(PyGObject *self, PyObject *args) +{ + char *property_name; + + if (!PyArg_ParseTuple(args, "s:GObject.notify", &property_name)) + return NULL; + g_object_notify(self->obj, property_name); + Py_INCREF(Py_None); + return Py_None; +} + +static PyObject * +pygobject_thaw_notify(PyGObject *self, PyObject *args) +{ + if (!PyArg_ParseTuple(args, ":GObject.thaw_notify")) + return NULL; + g_object_thaw_notify(self->obj); + Py_INCREF(Py_None); + return Py_None; +} + +static PyObject * +pygobject_get_data(PyGObject *self, PyObject *args) +{ + char *key; + GQuark quark; + PyObject *data; + + if (!PyArg_ParseTuple(args, "s:GObject.get_data", &key)) + return NULL; + quark = g_quark_from_string(key); + data = g_object_get_qdata(self->obj, quark); + if (!data) data = Py_None; + Py_INCREF(data); + return data; +} + +static PyObject * +pygobject_set_data(PyGObject *self, PyObject *args) +{ + char *key; + GQuark quark; + PyObject *data; + + if (!PyArg_ParseTuple(args, "sO:GObject.get_data", &key, &data)) + return NULL; + quark = g_quark_from_string(key); + Py_INCREF(data); + g_object_set_qdata_full(self->obj, quark, data, pyg_destroy_notify); + Py_INCREF(Py_None); + return Py_None; +} + +static PyObject * +pygobject_connect(PyGObject *self, PyObject *args) +{ + PyObject *first, *callback, *extra_args; + gchar *name; + guint handlerid, sigid, len; + GQuark detail = 0; + + len = PyTuple_Size(args); + if (len < 2) { + PyErr_SetString(PyExc_TypeError, + "GObject.connect requires at least 2 arguments"); + return NULL; + } + first = PySequence_GetSlice(args, 0, 2); + if (!PyArg_ParseTuple(first, "sO:GObject.connect", &name, &callback)) { + Py_DECREF(first); + return NULL; + } + Py_DECREF(first); + if (!PyCallable_Check(callback)) { + PyErr_SetString(PyExc_TypeError, "second argument must be callable"); + return NULL; + } + if (!g_signal_parse_name(name, G_OBJECT_TYPE(self->obj), + &sigid, &detail, TRUE)) { + PyErr_SetString(PyExc_TypeError, "unknown signal name"); + return NULL; + } + extra_args = PySequence_GetSlice(args, 2, len); + if (extra_args == NULL) + return NULL; + handlerid = g_signal_connect_closure_by_id(self->obj, sigid, detail, + pyg_closure_new(callback, extra_args, NULL), FALSE); + return PyInt_FromLong(handlerid); +} + +static PyObject * +pygobject_connect_after(PyGObject *self, PyObject *args) +{ + PyObject *first, *callback, *extra_args; + gchar *name; + guint handlerid, sigid, len; + GQuark detail; + + len = PyTuple_Size(args); + if (len < 2) { + PyErr_SetString(PyExc_TypeError, + "GObject.connect_after requires at least 2 arguments"); + return NULL; + } + first = PySequence_GetSlice(args, 0, 2); + if (!PyArg_ParseTuple(first, "sO:GObject.connect_after", + &name, &callback)) { + Py_DECREF(first); + return NULL; + } + Py_DECREF(first); + if (!PyCallable_Check(callback)) { + PyErr_SetString(PyExc_TypeError, "second argument must be callable"); + return NULL; + } + if (!g_signal_parse_name(name, G_OBJECT_TYPE(self->obj), + &sigid, &detail, TRUE)) { + PyErr_SetString(PyExc_TypeError, "unknown signal name"); + return NULL; + } + extra_args = PySequence_GetSlice(args, 2, len); + if (extra_args == NULL) + return NULL; + handlerid = g_signal_connect_closure_by_id(self->obj, sigid, detail, + pyg_closure_new(callback, extra_args, NULL), TRUE); + return PyInt_FromLong(handlerid); +} + +static PyObject * +pygobject_connect_object(PyGObject *self, PyObject *args) +{ + PyObject *first, *callback, *extra_args, *object; + gchar *name; + guint handlerid, sigid, len; + GQuark detail; + + len = PyTuple_Size(args); + if (len < 3) { + PyErr_SetString(PyExc_TypeError, + "GObject.connect_object requires at least 3 arguments"); + return NULL; + } + first = PySequence_GetSlice(args, 0, 3); + if (!PyArg_ParseTuple(first, "sOO:GObject.connect_object", + &name, &callback, &object)) { + Py_DECREF(first); + return NULL; + } + Py_DECREF(first); + if (!PyCallable_Check(callback)) { + PyErr_SetString(PyExc_TypeError, "second argument must be callable"); + return NULL; + } + if (!g_signal_parse_name(name, G_OBJECT_TYPE(self->obj), + &sigid, &detail, TRUE)) { + PyErr_SetString(PyExc_TypeError, "unknown signal name"); + return NULL; + } + extra_args = PySequence_GetSlice(args, 3, len); + if (extra_args == NULL) + return NULL; + handlerid = g_signal_connect_closure_by_id(self->obj, sigid, detail, + pyg_closure_new(callback, extra_args, object), FALSE); + return PyInt_FromLong(handlerid); +} + +static PyObject * +pygobject_connect_object_after(PyGObject *self, PyObject *args) +{ + PyObject *first, *callback, *extra_args, *object; + gchar *name; + guint handlerid, sigid, len; + GQuark detail; + + len = PyTuple_Size(args); + if (len < 3) { + PyErr_SetString(PyExc_TypeError, + "GObject.connect_object_after requires at least 3 arguments"); + return NULL; + } + first = PySequence_GetSlice(args, 0, 3); + if (!PyArg_ParseTuple(first, "sOO:GObject.connect_object_after", + &name, &callback, &object)) { + Py_DECREF(first); + return NULL; + } + Py_DECREF(first); + if (!PyCallable_Check(callback)) { + PyErr_SetString(PyExc_TypeError, "second argument must be callable"); + return NULL; + } + if (!g_signal_parse_name(name, G_OBJECT_TYPE(self->obj), + &sigid, &detail, TRUE)) { + PyErr_SetString(PyExc_TypeError, "unknown signal name"); + return NULL; + } + extra_args = PySequence_GetSlice(args, 3, len); + if (extra_args == NULL) + return NULL; + handlerid = g_signal_connect_closure_by_id(self->obj, sigid, detail, + pyg_closure_new(callback, extra_args, object), TRUE); + return PyInt_FromLong(handlerid); +} + +static PyObject * +pygobject_disconnect(PyGObject *self, PyObject *args) +{ + guint handler_id; + + if (!PyArg_ParseTuple(args, "i:GObject.disconnect", &handler_id)) + return NULL; + g_signal_handler_disconnect(self->obj, handler_id); + Py_INCREF(Py_None); + return Py_None; +} + +static PyObject * +pygobject_handler_block(PyGObject *self, PyObject *args) +{ + guint handler_id; + + if (!PyArg_ParseTuple(args, "i:GObject.handler_block", &handler_id)) + return NULL; + g_signal_handler_block(self->obj, handler_id); + Py_INCREF(Py_None); + return Py_None; +} + +static PyObject * +pygobject_handler_unblock(PyGObject *self, PyObject *args) +{ + guint handler_id; + + if (!PyArg_ParseTuple(args, "i:GObject.handler_unblock", &handler_id)) + return NULL; + g_signal_handler_unblock(self->obj, handler_id); + Py_INCREF(Py_None); + return Py_None; +} + +static PyObject * +pygobject_emit(PyGObject *self, PyObject *args) +{ + guint signal_id, i, len; + GQuark detail; + PyObject *first, *py_ret; + gchar *name; + GSignalQuery query; + GValue *params, ret = { 0, }; + + len = PyTuple_Size(args); + if (len < 1) { + PyErr_SetString(PyExc_TypeError,"GObject.emit needs at least one arg"); + return NULL; + } + first = PySequence_GetSlice(args, 0, 1); + if (!PyArg_ParseTuple(first, "s:GObject.emit", &name)) { + Py_DECREF(first); + return NULL; + } + Py_DECREF(first); + if (!g_signal_parse_name(name, G_OBJECT_TYPE(self->obj), + &signal_id, &detail, TRUE)) { + PyErr_SetString(PyExc_TypeError, "unknown signal name"); + return NULL; + } + g_signal_query(signal_id, &query); + if (len != query.n_params + 1) { + gchar buf[128]; + + g_snprintf(buf, sizeof(buf), + "%d parameters needed for signal %s; %d given", + query.n_params, name, len - 1); + PyErr_SetString(PyExc_TypeError, buf); + return NULL; + } + params = g_new0(GValue, query.n_params + 1); + g_value_init(¶ms[0], G_OBJECT_TYPE(self->obj)); + g_value_set_object(¶ms[0], G_OBJECT(self->obj)); + + for (i = 0; i < query.n_params; i++) + g_value_init(¶ms[i + 1], + query.param_types[i] & ~G_SIGNAL_TYPE_STATIC_SCOPE); + for (i = 0; i < query.n_params; i++) { + PyObject *item = PyTuple_GetItem(args, i+1); + + if (pyg_value_from_pyobject(¶ms[i+1], item) < 0) { + gchar buf[128]; + + g_snprintf(buf, sizeof(buf), + "could not convert type %s to %s required for parameter %d", + item->ob_type->tp_name, + g_type_name(G_VALUE_TYPE(¶ms[i+1])), i); + PyErr_SetString(PyExc_TypeError, buf); + for (i = 0; i < query.n_params + 1; i++) + g_value_unset(¶ms[i]); + g_free(params); + return NULL; + } + } + if (query.return_type != G_TYPE_NONE) + g_value_init(&ret, query.return_type & ~G_SIGNAL_TYPE_STATIC_SCOPE); + + g_signal_emitv(params, signal_id, detail, &ret); + for (i = 0; i < query.n_params + 1; i++) + g_value_unset(¶ms[i]); + g_free(params); + if ((query.return_type & ~G_SIGNAL_TYPE_STATIC_SCOPE) != G_TYPE_NONE) { + py_ret = pyg_value_as_pyobject(&ret); + g_value_unset(&ret); + } else { + Py_INCREF(Py_None); + py_ret = Py_None; + } + return py_ret; +} + +static PyObject * +pygobject_stop_emission(PyGObject *self, PyObject *args) +{ + gchar *signal; + guint signal_id; + GQuark detail; + + if (!PyArg_ParseTuple(args, "s:GObject.stop_emission", &signal)) + return NULL; + if (!g_signal_parse_name(signal, G_OBJECT_TYPE(self->obj), + &signal_id, &detail, TRUE)) { + PyErr_SetString(PyExc_TypeError, "unknown signal name"); + return NULL; + } + g_signal_stop_emission(self->obj, signal_id, detail); + Py_INCREF(Py_None); + return Py_None; +} + +static PyObject * +pygobject_chain_from_overridden(PyGObject *self, PyObject *args) +{ + GSignalInvocationHint *ihint; + guint signal_id, i, len; + PyObject *py_ret; + const gchar *name; + GSignalQuery query; + GValue *params, ret = { 0, }; + + ihint = g_signal_get_invocation_hint(self->obj); + signal_id = ihint->signal_id; + name = g_signal_name(signal_id); + + len = PyTuple_Size(args); + if (signal_id == 0) { + PyErr_SetString(PyExc_TypeError, "unknown signal name"); + return NULL; + } + g_signal_query(signal_id, &query); + if (len != query.n_params) { + gchar buf[128]; + + g_snprintf(buf, sizeof(buf), + "%d parameters needed for signal %s; %d given", + query.n_params, name, len); + PyErr_SetString(PyExc_TypeError, buf); + return NULL; + } + params = g_new0(GValue, query.n_params + 1); + g_value_init(¶ms[0], G_OBJECT_TYPE(self->obj)); + g_value_set_object(¶ms[0], G_OBJECT(self->obj)); + + for (i = 0; i < query.n_params; i++) + g_value_init(¶ms[i + 1], + query.param_types[i] & ~G_SIGNAL_TYPE_STATIC_SCOPE); + for (i = 0; i < query.n_params; i++) { + PyObject *item = PyTuple_GetItem(args, i); + + if (pyg_value_from_pyobject(¶ms[i+1], item) < 0) { + gchar buf[128]; + + g_snprintf(buf, sizeof(buf), + "could not convert type %s to %s required for parameter %d", + item->ob_type->tp_name, + g_type_name(G_VALUE_TYPE(¶ms[i+1])), i); + PyErr_SetString(PyExc_TypeError, buf); + for (i = 0; i < query.n_params + 1; i++) + g_value_unset(¶ms[i]); + g_free(params); + return NULL; + } + } + if (query.return_type != G_TYPE_NONE) + g_value_init(&ret, query.return_type & ~G_SIGNAL_TYPE_STATIC_SCOPE); + g_signal_chain_from_overridden(params, &ret); + for (i = 0; i < query.n_params + 1; i++) + g_value_unset(¶ms[i]); + g_free(params); + if ((query.return_type & ~G_SIGNAL_TYPE_STATIC_SCOPE) != G_TYPE_NONE) { + py_ret = pyg_value_as_pyobject(&ret); + g_value_unset(&ret); + } else { + Py_INCREF(Py_None); + py_ret = Py_None; + } + return py_ret; +} + +static PyMethodDef pygobject_methods[] = { + { "__gobject_init__", (PyCFunction)pygobject__gobject_init__, + METH_VARARGS|METH_KEYWORDS }, + { "get_property", (PyCFunction)pygobject_get_property, METH_VARARGS }, + { "set_property", (PyCFunction)pygobject_set_property, METH_VARARGS }, + { "freeze_notify", (PyCFunction)pygobject_freeze_notify, METH_VARARGS }, + { "notify", (PyCFunction)pygobject_notify, METH_VARARGS }, + { "thaw_notify", (PyCFunction)pygobject_thaw_notify, METH_VARARGS }, + { "get_data", (PyCFunction)pygobject_get_data, METH_VARARGS }, + { "set_data", (PyCFunction)pygobject_set_data, METH_VARARGS }, + { "connect", (PyCFunction)pygobject_connect, METH_VARARGS }, + { "connect_after", (PyCFunction)pygobject_connect_after, METH_VARARGS }, + { "connect_object", (PyCFunction)pygobject_connect_object, METH_VARARGS }, + { "connect_object_after", (PyCFunction)pygobject_connect_object_after, METH_VARARGS }, + { "disconnect", (PyCFunction)pygobject_disconnect, METH_VARARGS }, + { "handler_disconnect", (PyCFunction)pygobject_disconnect, METH_VARARGS }, + { "handler_block", (PyCFunction)pygobject_handler_block, METH_VARARGS }, + { "handler_unblock", (PyCFunction)pygobject_handler_unblock,METH_VARARGS }, + { "emit", (PyCFunction)pygobject_emit, METH_VARARGS }, + { "stop_emission", (PyCFunction)pygobject_stop_emission, METH_VARARGS }, + { "emit_stop_by_name", (PyCFunction)pygobject_stop_emission,METH_VARARGS }, + { "chain", (PyCFunction)pygobject_chain_from_overridden,METH_VARARGS }, + { NULL, NULL, 0 } +}; + +static PyObject * +pygobject_get_dict(PyGObject *self, void *closure) +{ + if (self->inst_dict == NULL) { + self->inst_dict = PyDict_New(); + if (self->inst_dict == NULL) + return NULL; + } + Py_INCREF(self->inst_dict); + return self->inst_dict; +} + +static PyGetSetDef pygobject_getsets[] = { + { "__dict__", (getter)pygobject_get_dict, (setter)0 }, + { NULL, 0, 0 } +}; + +PyTypeObject PyGObject_Type = { + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ + "gobject.GObject", /* tp_name */ + sizeof(PyGObject), /* tp_basicsize */ + 0, /* tp_itemsize */ + /* methods */ + (destructor)pygobject_dealloc, /* tp_dealloc */ + (printfunc)0, /* tp_print */ + (getattrfunc)0, /* tp_getattr */ + (setattrfunc)0, /* tp_setattr */ + (cmpfunc)pygobject_compare, /* tp_compare */ + (reprfunc)pygobject_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + (hashfunc)pygobject_hash, /* tp_hash */ + (ternaryfunc)0, /* tp_call */ + (reprfunc)0, /* tp_str */ + (getattrofunc)0, /* tp_getattro */ + (setattrofunc)0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | + Py_TPFLAGS_HAVE_GC, /* tp_flags */ + NULL, /* Documentation string */ + (traverseproc)pygobject_traverse, /* tp_traverse */ + (inquiry)0, /* tp_clear */ + (richcmpfunc)0, /* tp_richcompare */ + offsetof(PyGObject, weakreflist), /* tp_weaklistoffset */ + (getiterfunc)0, /* tp_iter */ + (iternextfunc)0, /* tp_iternext */ + pygobject_methods, /* tp_methods */ + 0, /* tp_members */ + pygobject_getsets, /* tp_getset */ + (PyTypeObject *)0, /* tp_base */ + (PyObject *)0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + offsetof(PyGObject, inst_dict), /* tp_dictoffset */ + (initproc)pygobject_init, /* tp_init */ + PyType_GenericAlloc, /* tp_alloc */ + PyType_GenericNew, /* tp_new */ + pygobject_free, /* tp_free */ + (inquiry)0, /* tp_is_gc */ + (PyObject *)0, /* tp_bases */ +}; + diff --git a/gobject/pygtype.c b/gobject/pygtype.c index 33985fd..bb75ca9 100644 --- a/gobject/pygtype.c +++ b/gobject/pygtype.c @@ -816,7 +816,7 @@ add_property_docs(GType gtype, GString *string) { GObjectClass *class; GParamSpec **props; - guint *n_props = 0, i; + guint n_props = 0, i; class = g_type_class_ref(gtype); props = g_object_class_list_properties(class, &n_props); |