From 5ded9cba8563f336939400303d6a841d5089b107 Mon Sep 17 00:00:00 2001 From: Perberos Date: Mon, 7 Nov 2011 19:52:18 -0300 Subject: renaming from gedit to pluma --- .../python/bindings/plumamessage.override | 556 +++++++++++++++++++++ 1 file changed, 556 insertions(+) create mode 100755 plugin-loaders/python/bindings/plumamessage.override (limited to 'plugin-loaders/python/bindings/plumamessage.override') diff --git a/plugin-loaders/python/bindings/plumamessage.override b/plugin-loaders/python/bindings/plumamessage.override new file mode 100755 index 00000000..be1090a0 --- /dev/null +++ b/plugin-loaders/python/bindings/plumamessage.override @@ -0,0 +1,556 @@ +%% +headers + +#include +#include + +static GType +_helper_wrap_get_gtype_from_pytype (PyObject *pytype) +{ + PyTypeObject *type = (PyTypeObject *)pytype; + + if (type == &PyList_Type || type == &PyTuple_Type) + return G_TYPE_STRV; + + return pyg_type_from_object (pytype); +} + +static gchar * +_helper_wrap_get_string (PyObject *obj) +{ + PyObject *str; + gchar *result; + + str = PyObject_Str (obj); + + if (!str) + return NULL; + + result = g_strdup (PyString_AsString (str)); + Py_DECREF (str); + + return result; +} + +static int +_helper_wrap_list_to_gvalue (GValue *gvalue, PyObject *pyvalue) +{ + int num; + gchar **lst; + gint i; + + num = PySequence_Size (pyvalue); + lst = g_new0 (gchar *, num + 1); + + for (i = 0; i < num; i++) + { + lst[i] = _helper_wrap_get_string (PySequence_GetItem (pyvalue, i)); + + if (lst[i] == NULL) + { + g_strfreev (lst); + return 1; + } + } + + g_value_set_boxed (gvalue, lst); + g_strfreev (lst); + + return 0; +} + +static int +_helper_wrap_get_gvalue_from_pyobject (GValue *gvalue, PyObject *pyvalue) +{ + if (pyvalue->ob_type == &PyList_Type || pyvalue->ob_type == &PyTuple_Type) + return _helper_wrap_list_to_gvalue (gvalue, pyvalue); + + return pyg_value_from_pyobject(gvalue, pyvalue); +} + +static int +_helper_wrap_message_set_value(PlumaMessage *message, PyObject *pykey, PyObject *pyvalue) +{ + gchar *key; + GType gtype; + GValue value = {0,}; + + key = _helper_wrap_get_string(pykey); + + if (key == NULL) + return 0; + + gtype = pluma_message_get_key_type(message, key); + + if (gtype == 0) { + PyErr_SetString(PyExc_TypeError, "invalid key"); + g_free (key); + return 0; + } + + g_value_init(&value, gtype); + + if (_helper_wrap_get_gvalue_from_pyobject (&value, pyvalue)) { + PyErr_SetString(PyExc_TypeError, + "value is of the wrong type for this key"); + g_free (key); + return 0; + } + + pluma_message_set_value(message, key, &value); + g_value_unset(&value); + g_free (key); + + return 1; +} + +typedef void (*ParsePairFunc)(PyObject *key, PyObject *value, gpointer user_data); + +static void +_helper_parse_pairs_dict (PyObject *dict, ParsePairFunc func, gpointer user_data) +{ + if (!dict) + return; + + PyObject *key, *value; + Py_ssize_t i = 0; + + while (PyDict_Next(dict, &i, &key, &value)) + { + func(key, value, user_data); + } +} + +static void +_helper_parse_pairs(PyObject *args, PyObject *kwargs, ParsePairFunc func, gpointer user_data) +{ + guint len; + guint i; + + len = PyTuple_Size(args); + + for (i = 0; i < len; ++i) + { + PyObject *d = PyTuple_GetItem(args, i); + + if (PyDict_Check(d)) + _helper_parse_pairs_dict(d, func, user_data); + } + + _helper_parse_pairs_dict(kwargs, func, user_data); +} + +static void +_helper_message_set(PyObject *key, PyObject *value, PlumaMessage *message) +{ + _helper_wrap_message_set_value(message, key, value); +} + +static void +_helper_message_set_values(PlumaMessage *message, PyObject *args, PyObject *kwargs) +{ + _helper_parse_pairs(args, kwargs, (ParsePairFunc)_helper_message_set, message); +} + +static PlumaMessage * +_helper_wrap_create_message(PlumaMessageBus *bus, PyObject *args, PyObject *kwargs) +{ + PyObject *pypath, *pymethod, *pydict; + + if (!PyArg_ParseTuple(args, "OO|O:PlumaMessage.create", &pypath, &pymethod, &pydict)) + return NULL; + + gchar *object_path = _helper_wrap_get_string(pypath); + gchar *method = _helper_wrap_get_string(pymethod); + + PlumaMessageType *message_type = pluma_message_bus_lookup (bus, object_path, method); + PlumaMessage *message; + + if (message_type) + { + message = pluma_message_type_instantiate(message_type, NULL); + _helper_message_set_values(message, args, kwargs); + } + else + { + PyErr_SetString(PyExc_StandardError, "Message type does not exist"); + message = NULL; + } + + g_free(object_path); + g_free(method); + + return message; +} + +typedef struct { + PyObject *func; + PyObject *data; +} PyPlumaCustomNotify; + +static void +pypluma_custom_destroy_notify(gpointer user_data) +{ + PyPlumaCustomNotify *cunote = user_data; + PyGILState_STATE state; + + g_return_if_fail(user_data); + state = pyg_gil_state_ensure(); + Py_XDECREF(cunote->func); + Py_XDECREF(cunote->data); + pyg_gil_state_release(state); + + g_free(cunote); +} +%% +ignore-glob + *_get_type + pluma_message_type_foreach + pluma_message_type_instantiate_valist + pluma_message_type_new_valist + pluma_message_get_valist + pluma_message_set_valist + pluma_message_set_valuesv + pluma_message_bus_disconnect_by_func + pluma_message_bus_block_by_func + pluma_message_bus_unblock_by_func +%% +override pluma_message_type_new kwargs + +typedef struct +{ + PlumaMessageType *message_type; + PyObject *optional; +} MessageTypeSetInfo; + +static void +_message_type_set(PyObject *key, PyObject *value, MessageTypeSetInfo *info) +{ + GType gtype; + + gchar *k = _helper_wrap_get_string(key); + + if (!k) + return; + + gtype = _helper_wrap_get_gtype_from_pytype(value); + + gboolean optional = info->optional && PySequence_Contains(info->optional, key); + + pluma_message_type_set(info->message_type, optional, k, gtype, NULL); + g_free(k); +} + +static int +_wrap_pluma_message_type_new(PyGObject *self, PyObject *args, PyObject *kwargs) +{ + PyObject *pypath, *pymethod, *optional = NULL, *pydict; + + if (!PyArg_ParseTuple(args, "OO|OO:PlumaMessageType.new", &pypath, &pymethod, &optional, &pydict)) + return -1; + + PlumaMessageType *message_type = PLUMA_MESSAGE_TYPE(g_object_new(pyg_type_from_object((PyObject *) self), NULL)); + + MessageTypeSetInfo info = {message_type, optional && PySequence_Check(optional) ? optional : NULL}; + _helper_parse_pairs (args, kwargs, (ParsePairFunc)_message_type_set, &info); + + self->obj = (GObject *)message_type; + pygobject_register_wrapper((PyObject *) self); + + return 0; +} +%% +override pluma_message_type_instantiate kwargs +static PyObject * +_wrap_pluma_message_type_instantiate(PyGObject *self, PyObject *args, PyObject *kwargs) +{ + PlumaMessageType *message_type = PLUMA_MESSAGE_TYPE (self->obj); + PlumaMessage *message = pluma_message_type_instantiate(message_type, NULL); + + _helper_message_set_values(message, args, kwargs); + + return pygobject_new((GObject *)message); +} +%% +override pluma_message_get args +static PyObject * +_wrap_pluma_message_get(PyGObject *self, PyObject *args) +{ + guint len, i; + PyObject *ret; + + len = PyTuple_Size(args); + + ret = PyTuple_New(len); + + for (i = 0; i < len; i++) { + GValue value = { 0, }; + PyObject *py_key = PyTuple_GetItem(args, i); + gchar *key = _helper_wrap_get_string(py_key); + + if (!key) { + PyErr_SetString(PyExc_TypeError, "keys must be strings"); + Py_DECREF(ret); + return NULL; + } + + pluma_message_get_value (PLUMA_MESSAGE (self->obj), key, &value); + g_free (key); + + PyTuple_SetItem(ret, i, pyg_value_as_pyobject(&value, TRUE)); + g_value_unset(&value); + } + + return ret; +} +%% +override pluma_message_get_value kwargs +static PyObject * +_wrap_pluma_message_get_value(PyGObject *self, PyObject *args, PyObject *kwargs) +{ + static char *kwlist[] = { "key", NULL }; + const gchar *key; + PyObject *ret; + GValue value = { 0, }; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s:PlumaMessage.get_value", kwlist, &key)) + return NULL; + + pluma_message_get_value(PLUMA_MESSAGE(self->obj), key, &value); + ret = pyg_value_as_pyobject(&value, TRUE); + g_value_unset(&value); + + return ret; +} +%% +override pluma_message_set_value kwargs +static PyObject * +_wrap_pluma_message_set_value(PyGObject *self, PyObject *args, PyObject *kwargs) +{ + static char *kwlist[] = { "key", "value", NULL }; + PyObject *pykey, *pyvalue; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:PlumaMessage.set_value", kwlist, &pykey, &pyvalue)) + return NULL; + + if (!_helper_wrap_message_set_value(PLUMA_MESSAGE(self->obj), pykey, pyvalue)) + return NULL; + + Py_INCREF(Py_None); + return Py_None; +} +%% +override pluma_message_set kwargs +static PyObject * +_wrap_pluma_message_set (PyGObject *self, PyObject *args, PyObject *kwargs) { + _helper_message_set_values(PLUMA_MESSAGE(self->obj), args, kwargs); + + Py_INCREF(Py_None); + return Py_None; +} +%% +override pluma_message_bus_new +static int +_wrap_pluma_message_bus_new(PyGObject *self) +{ + pygobject_construct (self, NULL); + + if (!self->obj) { + PyErr_SetString (PyExc_RuntimeError, "could not create pluma.MessageBus object"); + return -1; + } + + return 0; +} +%% +new-constructor PLUMA_TYPE_MESSAGE_BUS +%% +override pluma_message_bus_register kwargs +static PyObject * +_wrap_pluma_message_bus_register(PyGObject *self, PyObject *args, PyObject *kwargs) +{ + PyObject *pypath, *pymethod, *optional = NULL, *pydict; + PlumaMessageBus *bus = PLUMA_MESSAGE_BUS(self->obj); + + if (!PyArg_ParseTuple(args, "OO|OO:PlumaMessageBus.register", &pypath, &pymethod, &optional, &pydict)) + return NULL; + + gchar *object_path = _helper_wrap_get_string(pypath); + gchar *method = _helper_wrap_get_string(pymethod); + + PlumaMessageType *message_type = pluma_message_bus_register(bus, object_path, method, 0, NULL); + + g_free(object_path); + g_free(method); + + if (!message_type) + { + PyErr_SetString(PyExc_StandardError, "Message type already exists"); + return NULL; + } + + MessageTypeSetInfo info = {message_type, optional && PySequence_Check(optional) ? optional : NULL}; + _helper_parse_pairs (args, kwargs, (ParsePairFunc)_message_type_set, &info); + + return pyg_boxed_new(PLUMA_TYPE_MESSAGE_TYPE, message_type, TRUE, TRUE); +} +%% +override pluma_message_bus_connect kwargs +static void +pypluma_message_bus_connect_cb(PlumaMessageBus *bus, PlumaMessage *message, gpointer data) +{ + PyGILState_STATE state; + PyPlumaCustomNotify *cunote = data; + PyObject *pybus, *pymessage, *retobj; + + g_assert(cunote->func); + + state = pyg_gil_state_ensure(); + + pybus = pygobject_new((GObject *)bus); + pymessage = pygobject_new((GObject *)message); + + if (cunote->data) { + retobj = PyEval_CallFunction(cunote->func, "(NNO)", pybus, pymessage, cunote->data); + } else { + retobj = PyEval_CallFunction(cunote->func, "(NN)", pybus, pymessage); + } + + if (PyErr_Occurred()) { + PyErr_Print(); + } + + Py_XDECREF(retobj); + + pyg_gil_state_release(state); +} + +static PyObject * +_wrap_pluma_message_bus_connect(PyGObject *self, PyObject *args, PyObject *kwargs) +{ + static char *kwlist[] = { "domain", "name", "func", "data", NULL }; + PyObject *pyfunc, *pyarg = NULL; + const gchar *domain; + const gchar *name; + PyPlumaCustomNotify *cunote; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, + "ssO|O:PlumaMessageBus.connect", + kwlist, &domain, &name, &pyfunc, &pyarg)) + return NULL; + + if (!PyCallable_Check(pyfunc)) { + PyErr_SetString(PyExc_TypeError, "func must be a callable object"); + return NULL; + } + cunote = g_new(PyPlumaCustomNotify, 1); + Py_INCREF(pyfunc); + cunote->func = pyfunc; + Py_XINCREF(pyarg); + cunote->data = pyarg; + + guint id = pluma_message_bus_connect(PLUMA_MESSAGE_BUS(self->obj), + domain, + name, + pypluma_message_bus_connect_cb, + (gpointer)cunote, + pypluma_custom_destroy_notify); + return PyLong_FromUnsignedLong(id); +} +%% +override pluma_message_bus_send kwargs +static PyObject * +_wrap_pluma_message_bus_send(PyGObject *self, PyObject *args, PyObject *kwargs) +{ + /* create a new message object */ + PlumaMessage *message; + PlumaMessageBus *bus = PLUMA_MESSAGE_BUS(self->obj); + message = _helper_wrap_create_message(bus, args, kwargs); + + if (!message) + return NULL; + + pluma_message_bus_send_message(bus, message); + g_object_unref (message); + + Py_INCREF(Py_None); + return Py_None; +} +%% +override pluma_message_bus_send_sync kwargs +static PyObject * +_wrap_pluma_message_bus_send_sync(PyGObject *self, PyObject *args, PyObject *kwargs) +{ + /* create a new message object */ + PlumaMessage *message; + PlumaMessageBus *bus = PLUMA_MESSAGE_BUS(self->obj); + + message = _helper_wrap_create_message(bus, args, kwargs); + + if (!message) + return NULL; + + pluma_message_bus_send_message_sync(bus, message); + return pygobject_new((GObject *)message); +} +%% +override-slot PlumaMessage.tp_getattro +static PyObject * +_wrap_pluma_message_tp_getattro(PyObject *self, PyObject *attrname) +{ + PlumaMessage *message = PLUMA_MESSAGE(((PyGObject *)self)->obj); + PlumaMessageType *type; + + gchar *name = _helper_wrap_get_string (attrname); + gboolean exists; + gboolean intype; + PyObject *ret; + + if (name == NULL) + { + PyErr_SetString(PyExc_TypeError, "attr name somehow not a string"); + return NULL; + } + + g_object_get (message, "type", &type, NULL); + intype = pluma_message_type_lookup (type, name) != G_TYPE_INVALID; + pluma_message_type_unref (type); + + exists = pluma_message_has_key (message, name); + + if (!intype) + { + ret = PyObject_GenericGetAttr(self, attrname); + } + else if (exists) + { + GValue value = { 0, }; + pluma_message_get_value (message, name, &value); + ret = pyg_value_as_pyobject(&value, TRUE); + g_value_unset (&value); + } + else + { + Py_INCREF(Py_None); + ret = Py_None; + } + + g_free (name); + return ret; +} +%% +override-slot PlumaMessage.tp_setattro +static int +_wrap_pluma_message_tp_setattro(PyObject *self, PyObject *attrname, PyObject *value) +{ + PlumaMessage *message = PLUMA_MESSAGE(((PyGObject *)self)->obj); + + if (!_helper_wrap_message_set_value(message, attrname, value)) + { + return PyObject_GenericSetAttr(self, attrname, value); + } + else + { + return 1; + } +} -- cgit v1.2.1