static PyObject *
_wrap_pyg_set_object_has_new_constructor (PyObject *self,
PyObject *args,
PyObject *kwargs)
{
static char *kwlist[] = { "g_type", NULL };
PyObject *py_g_type;
GType g_type;
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
"O!:set_object_has_new_constructor",
kwlist, &PyGTypeWrapper_Type, &py_g_type)) {
return NULL;
}
g_type = pyg_type_from_object(py_g_type);
if (!g_type_is_a(g_type, G_TYPE_OBJECT)) {
PyErr_SetString(PyExc_TypeError, "must be a subtype of GObject");
return NULL;
}
pyg_set_object_has_new_constructor(g_type);
Py_RETURN_NONE;
}
static GType
find_python_extension_type (GType exten_type,
PyObject *pymodule)
{
PyObject *pyexten_type, *pytype;
GType the_type = G_TYPE_INVALID;
pyexten_type = pyg_type_wrapper_new (exten_type);
pytype = peas_python_internal_call ("find_extension_type",
&PyType_Type, "(OO)",
pyexten_type, pymodule);
Py_DECREF (pyexten_type);
if (pytype != NULL)
{
the_type = pyg_type_from_object (pytype);
Py_DECREF (pytype);
g_return_val_if_fail (g_type_is_a (the_type, exten_type),
G_TYPE_INVALID);
}
return the_type;
}
static PyObject *
_wrap_pyg_register_interface_info(PyObject *self, PyObject *args)
{
PyObject *py_g_type;
GType g_type;
GInterfaceInfo *info;
if (!PyArg_ParseTuple(args, "O!:register_interface_info",
&PyGTypeWrapper_Type, &py_g_type)) {
return NULL;
}
g_type = pyg_type_from_object(py_g_type);
if (!g_type_is_a(g_type, G_TYPE_INTERFACE)) {
PyErr_SetString(PyExc_TypeError, "must be an interface");
return NULL;
}
info = g_new0(GInterfaceInfo, 1);
info->interface_init = (GInterfaceInitFunc) initialize_interface;
pyg_register_interface_info(g_type, info);
Py_RETURN_NONE;
}
PyObject *
_pygi_boxed_new (PyTypeObject *type,
gpointer boxed,
gboolean free_on_dealloc)
{
PyGIBoxed *self;
if (!boxed) {
Py_RETURN_NONE;
}
if (!PyType_IsSubtype (type, &PyGIBoxed_Type)) {
PyErr_SetString (PyExc_TypeError, "must be a subtype of gi.Boxed");
return NULL;
}
self = (PyGIBoxed *) type->tp_alloc (type, 0);
if (self == NULL) {
return NULL;
}
( (PyGBoxed *) self)->gtype = pyg_type_from_object ( (PyObject *) type);
( (PyGBoxed *) self)->boxed = boxed;
( (PyGBoxed *) self)->free_on_dealloc = free_on_dealloc;
self->size = 0;
self->slice_allocated = FALSE;
return (PyObject *) self;
}
void
_moo_pyobject_to_gvalue (PyObject *object,
GValue *value)
{
GType type;
g_return_if_fail (value != NULL && !G_IS_VALUE (value));
g_return_if_fail (object != NULL);
type = pyg_type_from_object (object);
if (type != 0 && type != G_TYPE_NONE)
{
g_value_init (value, type);
if (pyg_value_from_pyobject (value, object) == 0)
return;
g_critical ("oops");
g_value_unset (value);
}
PyErr_Clear ();
g_value_init (value, MOO_TYPE_PY_OBJECT);
if (object != Py_None)
g_value_set_boxed (value, object);
else
g_value_set_boxed (value, NULL);
}
static PyObject *
pyg_remove_emission_hook(PyGObject *self, PyObject *args)
{
PyObject *pygtype;
char *name;
guint signal_id;
gulong hook_id;
GType gtype;
if (!PyArg_ParseTuple(args, "Osk:gobject.remove_emission_hook",
&pygtype, &name, &hook_id))
return NULL;
if ((gtype = pyg_type_from_object(pygtype)) == 0) {
return NULL;
}
if (!g_signal_parse_name(name, gtype, &signal_id, NULL, TRUE)) {
PyErr_Format(PyExc_TypeError, "%s: unknown signal name: %s",
PyString_AsString(PyObject_Repr((PyObject*)self)),
name);
return NULL;
}
g_signal_remove_emission_hook(signal_id, hook_id);
Py_INCREF(Py_None);
return Py_None;
}
PyObject *
_pygi_struct_new (PyTypeObject *type,
gpointer pointer,
gboolean free_on_dealloc)
{
PyGIStruct *self;
GType g_type;
if (!PyType_IsSubtype (type, &PyGIStruct_Type)) {
PyErr_SetString (PyExc_TypeError, "must be a subtype of gi.Struct");
return NULL;
}
self = (PyGIStruct *) type->tp_alloc (type, 0);
if (self == NULL) {
return NULL;
}
g_type = pyg_type_from_object ( (PyObject *) type);
( (PyGPointer *) self)->gtype = g_type;
( (PyGPointer *) self)->pointer = pointer;
self->free_on_dealloc = free_on_dealloc;
return (PyObject *) self;
}
static PyObject *
pyg_flags_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = { "value", NULL };
long value;
PyObject *pytc, *values, *ret, *pyint;
GType gtype;
GFlagsClass *eclass;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "l", kwlist, &value))
return NULL;
pytc = PyObject_GetAttrString((PyObject *)type, "__gtype__");
if (!pytc)
return NULL;
if (!PyObject_TypeCheck(pytc, &PyGTypeWrapper_Type)) {
Py_DECREF(pytc);
PyErr_SetString(PyExc_TypeError,
"__gtype__ attribute not a typecode");
return NULL;
}
gtype = pyg_type_from_object(pytc);
Py_DECREF(pytc);
eclass = G_FLAGS_CLASS(g_type_class_ref(gtype));
values = PyObject_GetAttrString((PyObject *)type, "__flags_values__");
if (!values) {
g_type_class_unref(eclass);
return NULL;
}
if (!PyDict_Check(values)) {
PyErr_SetString(PyExc_TypeError, "__flags_values__ badly formed");
Py_DECREF(values);
g_type_class_unref(eclass);
return NULL;
}
g_type_class_unref(eclass);
pyint = PYGLIB_PyLong_FromLong(value);
ret = PyDict_GetItem(values, pyint);
if (!ret) {
PyErr_Clear();
ret = pyg_flags_val_new((PyObject *)type, gtype, pyint);
g_assert(ret != NULL);
} else {
Py_INCREF(ret);
}
Py_DECREF(pyint);
Py_DECREF(values);
return ret;
}
static PyObject *
nautilus_python_boxed_new (PyTypeObject *type, gpointer boxed, gboolean free_on_dealloc) {
PyGBoxed *self = (PyGBoxed *) type->tp_alloc (type, 0);
self->gtype = pyg_type_from_object ( (PyObject *) type);
self->boxed = boxed;
self->free_on_dealloc = free_on_dealloc;
return (PyObject *) self;
}
static PyObject *
pyg_add_emission_hook(PyGObject *self, PyObject *args)
{
PyObject *first, *callback, *extra_args, *data;
gchar *name;
gulong hook_id;
guint sigid;
Py_ssize_t len;
GQuark detail = 0;
GType gtype;
PyObject *pygtype;
len = PyTuple_Size(args);
if (len < 3) {
PyErr_SetString(PyExc_TypeError,
"gobject.add_emission_hook requires at least 3 arguments");
return NULL;
}
first = PySequence_GetSlice(args, 0, 3);
if (!PyArg_ParseTuple(first, "OsO:add_emission_hook",
&pygtype, &name, &callback)) {
Py_DECREF(first);
return NULL;
}
Py_DECREF(first);
if ((gtype = pyg_type_from_object(pygtype)) == 0) {
return NULL;
}
if (!PyCallable_Check(callback)) {
PyErr_SetString(PyExc_TypeError, "third argument must be callable");
return NULL;
}
if (!g_signal_parse_name(name, gtype, &sigid, &detail, TRUE)) {
PyErr_Format(PyExc_TypeError, "%s: unknown signal name: %s",
PyString_AsString(PyObject_Repr((PyObject*)self)),
name);
return NULL;
}
extra_args = PySequence_GetSlice(args, 3, len);
if (extra_args == NULL)
return NULL;
data = Py_BuildValue("(ON)", callback, extra_args);
if (data == NULL)
return NULL;
hook_id = g_signal_add_emission_hook(sigid, detail,
marshal_emission_hook,
data,
(GDestroyNotify)pyg_destroy_notify);
return PyLong_FromUnsignedLong(hook_id);
}
static PyObject*
_wrap_g_type_is_a(PyGTypeWrapper *self, PyObject *args)
{
PyObject *gparent;
GType parent;
if (!PyArg_ParseTuple(args, "O:GType.is_a", &gparent))
return NULL;
else if ((parent = pyg_type_from_object(gparent)) == 0)
return NULL;
return PyBool_FromLong(g_type_is_a(self->type, parent));
}
static gboolean
_pygi_marshal_from_py_gtype (PyObject *py_arg,
GIArgument *arg)
{
long type_ = pyg_type_from_object (py_arg);
if (type_ == 0) {
PyErr_Format (PyExc_TypeError, "Must be gobject.GType, not %s",
py_arg->ob_type->tp_name);
return FALSE;
}
arg->v_long = type_;
return TRUE;
}
static int
pyg_type_wrapper_init(PyGTypeWrapper *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = { "object", NULL };
PyObject *py_object;
GType type;
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
"O:GType.__init__",
kwlist, &py_object))
return -1;
if (!(type = pyg_type_from_object(py_object)))
return -1;
self->type = type;
return 0;
}
static int
gi_gst_list_to_value (GValue * value, PyObject * object)
{
gint len, i;
len = PySequence_Length (object);
for (i = 0; i < len; i++) {
GValue v = G_VALUE_INIT;
GType type;
PyObject *item;
item = PySequence_GetItem (object, i);
if (item == Py_None)
type = G_TYPE_POINTER;
else
type = pyg_type_from_object ((PyObject *) Py_TYPE (item));
if (type == G_TYPE_NONE) {
Py_DECREF (item);
goto fail;
}
g_value_init (&v, type);
if (pyg_value_from_pyobject (&v, item) < 0) {
Py_DECREF (item);
goto fail;
}
gst_value_list_append_and_take_value (value, &v);
Py_DECREF (item);
}
return 0;
fail:
PyErr_SetString (PyExc_KeyError,
"Object is not compatible with Gst.ValueList");
return -1;
}
static void
_boxed_dealloc (PyGIBoxed *self)
{
GType g_type;
PyObject_GC_UnTrack ( (PyObject *) self);
PyObject_ClearWeakRefs ( (PyObject *) self);
if ( ( (PyGBoxed *) self)->free_on_dealloc) {
if (self->slice_allocated) {
g_slice_free1 (self->size, ( (PyGBoxed *) self)->boxed);
} else {
g_type = pyg_type_from_object ( (PyObject *) self);
g_boxed_free (g_type, ( (PyGBoxed *) self)->boxed);
}
}
Py_TYPE( (PyGObject *) self)->tp_free ( (PyObject *) self);
}
static PyObject *
_wrap_pyg_flags_add (PyObject *self,
PyObject *args,
PyObject *kwargs)
{
static char *kwlist[] = { "g_type", NULL };
PyObject *py_g_type;
GType g_type;
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
"O!:flags_add",
kwlist, &PyGTypeWrapper_Type, &py_g_type)) {
return NULL;
}
g_type = pyg_type_from_object(py_g_type);
if (g_type == G_TYPE_INVALID) {
return NULL;
}
return pyg_flags_add(NULL, g_type_name(g_type), NULL, g_type);
}
static PyObject *
_wrap_TestInterface__do_iface_method(PyObject *cls, PyObject *args, PyObject *kwargs)
{
TestInterfaceIface *iface;
static char *kwlist[] = { "self", NULL };
PyGObject *self;
if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:TestInterface.iface_method", kwlist, &PyTestInterface_Type, &self))
return NULL;
iface = g_type_interface_peek(g_type_class_peek(pyg_type_from_object(cls)),
TEST_TYPE_INTERFACE);
if (iface->iface_method)
iface->iface_method(TEST_INTERFACE(self->obj));
else {
PyErr_SetString(PyExc_NotImplementedError,
"interface method TestInterface.iface_method not implemented");
return NULL;
}
Py_INCREF(Py_None);
return Py_None;
}
gint
pygi_set_property_value_real (PyGObject *instance,
const gchar *attr_name,
PyObject *py_value)
{
GType g_type;
GIPropertyInfo *property_info = NULL;
char *property_name = g_strdup (attr_name);
GITypeInfo *type_info = NULL;
GITypeTag type_tag;
GITransfer transfer;
GValue value = { 0, };
GIArgument arg = { 0, };
GParamSpec *pspec = NULL;
gint ret_value = -1;
canonicalize_key (property_name);
g_type = pyg_type_from_object ((PyObject *)instance);
property_info = _pygi_lookup_property_from_g_type (g_type, property_name);
if (property_info == NULL)
goto out;
pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (instance->obj),
attr_name);
if (pspec == NULL)
goto out;
if (! (pspec->flags & G_PARAM_WRITABLE))
goto out;
type_info = g_property_info_get_type (property_info);
transfer = g_property_info_get_ownership_transfer (property_info);
arg = _pygi_argument_from_object (py_value, type_info, transfer);
if (PyErr_Occurred())
goto out;
g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));
// FIXME: Lots of types still unhandled
type_tag = g_type_info_get_tag (type_info);
switch (type_tag) {
case GI_TYPE_TAG_INTERFACE:
{
GIBaseInfo *info;
GIInfoType info_type;
GType type;
info = g_type_info_get_interface (type_info);
type = g_registered_type_info_get_g_type (info);
info_type = g_base_info_get_type (info);
g_base_info_unref (info);
switch (info_type) {
case GI_INFO_TYPE_ENUM:
g_value_set_enum (&value, arg.v_int32);
break;
case GI_INFO_TYPE_INTERFACE:
case GI_INFO_TYPE_OBJECT:
g_value_set_object (&value, arg.v_pointer);
break;
case GI_INFO_TYPE_BOXED:
case GI_INFO_TYPE_STRUCT:
case GI_INFO_TYPE_UNION:
if (g_type_is_a (type, G_TYPE_BOXED)) {
g_value_set_boxed (&value, arg.v_pointer);
} else {
PyErr_Format (PyExc_NotImplementedError,
"Setting properties of type '%s' is not implemented",
g_type_name (type));
}
break;
default:
PyErr_Format (PyExc_NotImplementedError,
"Setting properties of type '%s' is not implemented",
g_type_name (type));
goto out;
}
break;
}
case GI_TYPE_TAG_BOOLEAN:
g_value_set_boolean (&value, arg.v_boolean);
break;
case GI_TYPE_TAG_INT8:
g_value_set_schar (&value, arg.v_int8);
break;
case GI_TYPE_TAG_INT16:
case GI_TYPE_TAG_INT32:
if (G_VALUE_HOLDS_LONG (&value))
g_value_set_long (&value, arg.v_long);
else
g_value_set_int (&value, arg.v_int);
break;
case GI_TYPE_TAG_INT64:
if (G_VALUE_HOLDS_LONG (&value))
g_value_set_long (&value, arg.v_long);
else
g_value_set_int64 (&value, arg.v_int64);
break;
case GI_TYPE_TAG_UINT8:
g_value_set_uchar (&value, arg.v_uint8);
break;
case GI_TYPE_TAG_UINT16:
case GI_TYPE_TAG_UINT32:
if (G_VALUE_HOLDS_ULONG (&value))
g_value_set_ulong (&value, arg.v_ulong);
else
g_value_set_uint (&value, arg.v_uint);
break;
case GI_TYPE_TAG_UINT64:
if (G_VALUE_HOLDS_ULONG (&value))
g_value_set_ulong (&value, arg.v_ulong);
else
g_value_set_uint64 (&value, arg.v_uint64);
break;
case GI_TYPE_TAG_FLOAT:
g_value_set_float (&value, arg.v_float);
break;
case GI_TYPE_TAG_DOUBLE:
g_value_set_double (&value, arg.v_double);
break;
case GI_TYPE_TAG_GTYPE:
g_value_set_gtype (&value, arg.v_size);
break;
case GI_TYPE_TAG_UTF8:
case GI_TYPE_TAG_FILENAME:
g_value_set_string (&value, arg.v_string);
break;
case GI_TYPE_TAG_GHASH:
g_value_set_boxed (&value, arg.v_pointer);
break;
case GI_TYPE_TAG_GLIST:
g_value_set_pointer (&value, arg.v_pointer);
break;
case GI_TYPE_TAG_ARRAY:
{
GArray *arg_items = (GArray*) arg.v_pointer;
gchar** strings;
int i;
if (arg_items == NULL)
goto out;
strings = g_new0 (char*, arg_items->len);
for (i = 0; i < arg_items->len; ++i) {
strings[i] = g_array_index (arg_items, GIArgument, i).v_string;
}
g_array_free (arg_items, TRUE);
g_value_set_boxed (&value, strings);
break;
}
default:
PyErr_Format (PyExc_NotImplementedError,
"Setting properties of type %s is not implemented",
g_type_tag_to_string (g_type_info_get_tag (type_info)));
goto out;
}
g_object_set_property (instance->obj, attr_name, &value);
ret_value = 0;
out:
g_free (property_name);
if (property_info != NULL)
g_base_info_unref (property_info);
if (type_info != NULL)
g_base_info_unref (type_info);
return ret_value;
}
static int
pyg_value_array_from_pyobject(GValue *value,
PyObject *obj,
const GParamSpecValueArray *pspec)
{
int len;
GValueArray *value_array;
int i;
len = PySequence_Length(obj);
if (len == -1) {
PyErr_Clear();
return -1;
}
if (pspec && pspec->fixed_n_elements > 0 && len != pspec->fixed_n_elements)
return -1;
value_array = g_value_array_new(len);
for (i = 0; i < len; ++i) {
PyObject *item = PySequence_GetItem(obj, i);
GType type;
GValue item_value = { 0, };
int status;
if (! item) {
PyErr_Clear();
g_value_array_free(value_array);
return -1;
}
if (pspec && pspec->element_spec)
type = G_PARAM_SPEC_VALUE_TYPE(pspec->element_spec);
else if (item == Py_None)
type = G_TYPE_POINTER; /* store None as NULL */
else {
type = pyg_type_from_object((PyObject*)Py_TYPE(item));
if (! type) {
PyErr_Clear();
g_value_array_free(value_array);
Py_DECREF(item);
return -1;
}
}
g_value_init(&item_value, type);
status = (pspec && pspec->element_spec)
? pyg_param_gvalue_from_pyobject(&item_value, item, pspec->element_spec)
: pyg_value_from_pyobject(&item_value, item);
Py_DECREF(item);
if (status == -1) {
g_value_array_free(value_array);
g_value_unset(&item_value);
return -1;
}
g_value_array_append(value_array, &item_value);
g_value_unset(&item_value);
}
g_value_take_boxed(value, value_array);
return 0;
}
/**
* pyg_value_from_pyobject:
* @value: the GValue object to store the converted value in.
* @obj: the Python object to convert.
*
* This function converts a Python object and stores the result in a
* GValue. The GValue must be initialised in advance with
* g_value_init(). If the Python object can't be converted to the
* type of the GValue, then an error is returned.
*
* Returns: 0 on success, -1 on error.
*/
int
pyg_value_from_pyobject(GValue *value, PyObject *obj)
{
PyObject *tmp;
switch (G_TYPE_FUNDAMENTAL(G_VALUE_TYPE(value))) {
case G_TYPE_INTERFACE:
/* we only handle interface types that have a GObject prereq */
if (g_type_is_a(G_VALUE_TYPE(value), G_TYPE_OBJECT)) {
if (obj == Py_None)
g_value_set_object(value, NULL);
else {
if (!PyObject_TypeCheck(obj, &PyGObject_Type)) {
return -1;
}
if (!G_TYPE_CHECK_INSTANCE_TYPE(pygobject_get(obj),
G_VALUE_TYPE(value))) {
return -1;
}
g_value_set_object(value, pygobject_get(obj));
}
} else {
return -1;
}
break;
case G_TYPE_CHAR:
#if PY_VERSION_HEX < 0x03000000
if (PyString_Check(obj)) {
g_value_set_char(value, PyString_AsString(obj)[0]);
} else
#endif
if (PyUnicode_Check(obj)) {
tmp = PyUnicode_AsUTF8String(obj);
g_value_set_char(value, PYGLIB_PyBytes_AsString(tmp)[0]);
Py_DECREF(tmp);
} else {
PyErr_Clear();
return -1;
}
break;
case G_TYPE_UCHAR:
if (PYGLIB_PyLong_Check(obj)) {
glong val;
val = PYGLIB_PyLong_AsLong(obj);
if (val >= 0 && val <= 255)
g_value_set_uchar(value, (guchar)PYGLIB_PyLong_AsLong (obj));
else
return -1;
#if PY_VERSION_HEX < 0x03000000
} else if (PyString_Check(obj)) {
g_value_set_uchar(value, PyString_AsString(obj)[0]);
#endif
} else if (PyUnicode_Check(obj)) {
tmp = PyUnicode_AsUTF8String(obj);
g_value_set_uchar(value, PYGLIB_PyBytes_AsString(tmp)[0]);
Py_DECREF(tmp);
} else {
PyErr_Clear();
return -1;
}
break;
case G_TYPE_BOOLEAN:
g_value_set_boolean(value, PyObject_IsTrue(obj));
break;
case G_TYPE_INT:
g_value_set_int(value, PYGLIB_PyLong_AsLong(obj));
break;
case G_TYPE_UINT:
{
if (PYGLIB_PyLong_Check(obj)) {
glong val;
val = PYGLIB_PyLong_AsLong(obj);
if (val >= 0 && val <= G_MAXUINT)
g_value_set_uint(value, (guint)val);
else
return -1;
} else {
g_value_set_uint(value, PyLong_AsUnsignedLong(obj));
}
}
break;
case G_TYPE_LONG:
g_value_set_long(value, PYGLIB_PyLong_AsLong(obj));
break;
case G_TYPE_ULONG:
#if PY_VERSION_HEX < 0x03000000
if (PyInt_Check(obj)) {
long val;
val = PYGLIB_PyLong_AsLong(obj);
if (val < 0) {
PyErr_SetString(PyExc_OverflowError, "negative value not allowed for uint64 property");
return -1;
}
g_value_set_ulong(value, (gulong)val);
} else
#endif
if (PyLong_Check(obj))
g_value_set_ulong(value, PyLong_AsUnsignedLong(obj));
else
return -1;
break;
case G_TYPE_INT64:
g_value_set_int64(value, PyLong_AsLongLong(obj));
break;
case G_TYPE_UINT64:
#if PY_VERSION_HEX < 0x03000000
if (PyInt_Check(obj)) {
long v = PyInt_AsLong(obj);
if (v < 0) {
PyErr_SetString(PyExc_OverflowError, "negative value not allowed for uint64 property");
return -1;
}
g_value_set_uint64(value, v);
} else
#endif
if (PyLong_Check(obj))
g_value_set_uint64(value, PyLong_AsUnsignedLongLong(obj));
else
return -1;
break;
case G_TYPE_ENUM:
{
gint val = 0;
if (pyg_enum_get_value(G_VALUE_TYPE(value), obj, &val) < 0) {
PyErr_Clear();
return -1;
}
g_value_set_enum(value, val);
}
break;
case G_TYPE_FLAGS:
{
gint val = 0;
if (pyg_flags_get_value(G_VALUE_TYPE(value), obj, &val) < 0) {
PyErr_Clear();
return -1;
}
g_value_set_flags(value, val);
}
break;
case G_TYPE_FLOAT:
g_value_set_float(value, PyFloat_AsDouble(obj));
break;
case G_TYPE_DOUBLE:
g_value_set_double(value, PyFloat_AsDouble(obj));
break;
case G_TYPE_STRING:
if (obj == Py_None) {
g_value_set_string(value, NULL);
#if PY_VERSION_HEX < 0x03000000
} else if (PyString_Check(obj)) {
g_value_set_string(value, PyString_AsString(obj));
#endif
} else if (PyUnicode_Check(obj)) {
tmp = PyUnicode_AsUTF8String(obj);
g_value_set_string(value, PYGLIB_PyBytes_AsString(tmp));
Py_DECREF(tmp);
} else {
PyErr_Clear();
return -1;
}
break;
case G_TYPE_POINTER:
if (obj == Py_None)
g_value_set_pointer(value, NULL);
else if (PyObject_TypeCheck(obj, &PyGPointer_Type) &&
G_VALUE_HOLDS(value, ((PyGPointer *)obj)->gtype))
g_value_set_pointer(value, pyg_pointer_get(obj, gpointer));
else if (PYGLIB_CPointer_Check(obj))
g_value_set_pointer(value, PYGLIB_CPointer_GetPointer(obj, NULL));
else
return -1;
break;
case G_TYPE_BOXED: {
PyGTypeMarshal *bm;
if (obj == Py_None)
g_value_set_boxed(value, NULL);
else if (G_VALUE_HOLDS(value, PY_TYPE_OBJECT))
g_value_set_boxed(value, obj);
else if (PyObject_TypeCheck(obj, &PyGBoxed_Type) &&
G_VALUE_HOLDS(value, ((PyGBoxed *)obj)->gtype))
g_value_set_boxed(value, pyg_boxed_get(obj, gpointer));
else if (G_VALUE_HOLDS(value, G_TYPE_VALUE)) {
GType type;
GValue *n_value;
type = pyg_type_from_object((PyObject*)Py_TYPE(obj));
if (G_UNLIKELY (! type)) {
PyErr_Clear();
return -1;
}
n_value = g_new0 (GValue, 1);
g_value_init (n_value, type);
g_value_take_boxed (value, n_value);
return pyg_value_from_pyobject (n_value, obj);
}
else if (PySequence_Check(obj) &&
G_VALUE_HOLDS(value, G_TYPE_VALUE_ARRAY))
return pyg_value_array_from_pyobject(value, obj, NULL);
else if (PYGLIB_PyUnicode_Check(obj) &&
G_VALUE_HOLDS(value, G_TYPE_GSTRING)) {
GString *string;
char *buffer;
Py_ssize_t len;
if (PYGLIB_PyUnicode_AsStringAndSize(obj, &buffer, &len))
return -1;
string = g_string_new_len(buffer, len);
g_value_set_boxed(value, string);
g_string_free (string, TRUE);
break;
}
else if ((bm = pyg_type_lookup(G_VALUE_TYPE(value))) != NULL)
return bm->tovalue(value, obj);
else if (PYGLIB_CPointer_Check(obj))
g_value_set_boxed(value, PYGLIB_CPointer_GetPointer(obj, NULL));
else
return -1;
break;
}
case G_TYPE_PARAM:
if (PyGParamSpec_Check(obj))
g_value_set_param(value, PYGLIB_CPointer_GetPointer(obj, NULL));
else
return -1;
break;
case G_TYPE_OBJECT:
if (obj == Py_None) {
g_value_set_object(value, NULL);
} else if (PyObject_TypeCheck(obj, &PyGObject_Type) &&
G_TYPE_CHECK_INSTANCE_TYPE(pygobject_get(obj),
G_VALUE_TYPE(value))) {
g_value_set_object(value, pygobject_get(obj));
} else
return -1;
break;
default:
{
PyGTypeMarshal *bm;
if ((bm = pyg_type_lookup(G_VALUE_TYPE(value))) != NULL)
return bm->tovalue(value, obj);
break;
}
}
if (PyErr_Occurred()) {
g_value_unset(value);
PyErr_Clear();
return -1;
}
return 0;
}
static PyObject *
pyg_enum_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = { "value", NULL };
long value;
PyObject *pytc, *values, *ret, *intvalue;
GType gtype;
GEnumClass *eclass;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "l", kwlist, &value))
return NULL;
pytc = PyObject_GetAttrString((PyObject *)type, "__gtype__");
if (!pytc)
return NULL;
if (!PyObject_TypeCheck(pytc, &PyGTypeWrapper_Type)) {
Py_DECREF(pytc);
PyErr_SetString(PyExc_TypeError,
"__gtype__ attribute not a typecode");
return NULL;
}
gtype = pyg_type_from_object(pytc);
Py_DECREF(pytc);
eclass = G_ENUM_CLASS(g_type_class_ref(gtype));
/* A check that 0 < value < eclass->n_values was here but got
* removed: enumeration values do not need to be consequitive,
* e.g. GtkPathPriorityType values are not.
*/
values = PyObject_GetAttrString((PyObject *)type, "__enum_values__");
if (!values) {
g_type_class_unref(eclass);
return NULL;
}
/* Note that size of __enum_values__ dictionary can easily be less
* than 'n_values'. This happens if some values of the enum are
* numerically equal, e.g. gtk.ANCHOR_N == gtk.ANCHOR_NORTH.
* Johan said that "In retrospect, using a dictionary to store the
* values might not have been that good", but we need to keep
* backward compatibility.
*/
if (!PyDict_Check(values) || PyDict_Size(values) > eclass->n_values) {
PyErr_SetString(PyExc_TypeError, "__enum_values__ badly formed");
Py_DECREF(values);
g_type_class_unref(eclass);
return NULL;
}
g_type_class_unref(eclass);
intvalue = PYGLIB_PyLong_FromLong(value);
ret = PyDict_GetItem(values, intvalue);
Py_DECREF(intvalue);
Py_DECREF(values);
if (ret)
Py_INCREF(ret);
else
PyErr_Format(PyExc_ValueError, "invalid enum value: %ld", value);
return ret;
}
PyObject *
pygi_get_property_value_real (PyGObject *instance,
const gchar *attr_name)
{
GType g_type;
GIPropertyInfo *property_info = NULL;
char *property_name = g_strdup (attr_name);
GParamSpec *pspec = NULL;
GValue value = { 0, };
GIArgument arg = { 0, };
PyObject *py_value = NULL;
GITypeInfo *type_info = NULL;
GITransfer transfer;
canonicalize_key (property_name);
g_type = pyg_type_from_object ((PyObject *)instance);
property_info = _pygi_lookup_property_from_g_type (g_type, property_name);
if (property_info == NULL)
goto out;
pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (instance->obj),
attr_name);
if (pspec == NULL)
goto out;
g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));
g_object_get_property (instance->obj, attr_name, &value);
type_info = g_property_info_get_type (property_info);
transfer = g_property_info_get_ownership_transfer (property_info);
GITypeTag type_tag = g_type_info_get_tag (type_info);
switch (type_tag) {
case GI_TYPE_TAG_BOOLEAN:
arg.v_boolean = g_value_get_boolean (&value);
break;
case GI_TYPE_TAG_INT8:
arg.v_int8 = g_value_get_schar (&value);
break;
case GI_TYPE_TAG_INT16:
case GI_TYPE_TAG_INT32:
if (G_VALUE_HOLDS_LONG (&value))
arg.v_long = g_value_get_long (&value);
else
arg.v_int = g_value_get_int (&value);
break;
case GI_TYPE_TAG_INT64:
if (G_VALUE_HOLDS_LONG (&value))
arg.v_long = g_value_get_long (&value);
else
arg.v_int64 = g_value_get_int64 (&value);
break;
case GI_TYPE_TAG_UINT8:
arg.v_uint8 = g_value_get_uchar (&value);
break;
case GI_TYPE_TAG_UINT16:
case GI_TYPE_TAG_UINT32:
if (G_VALUE_HOLDS_ULONG (&value))
arg.v_ulong = g_value_get_ulong (&value);
else
arg.v_uint = g_value_get_uint (&value);
break;
case GI_TYPE_TAG_UINT64:
if (G_VALUE_HOLDS_ULONG (&value))
arg.v_ulong = g_value_get_ulong (&value);
else
arg.v_uint64 = g_value_get_uint64 (&value);
break;
case GI_TYPE_TAG_FLOAT:
arg.v_float = g_value_get_float (&value);
break;
case GI_TYPE_TAG_DOUBLE:
arg.v_double = g_value_get_double (&value);
break;
case GI_TYPE_TAG_GTYPE:
arg.v_size = g_value_get_gtype (&value);
break;
case GI_TYPE_TAG_UTF8:
case GI_TYPE_TAG_FILENAME:
arg.v_string = g_value_dup_string (&value);
break;
case GI_TYPE_TAG_INTERFACE:
{
GIBaseInfo *info;
GIInfoType info_type;
GType type;
info = g_type_info_get_interface (type_info);
type = g_registered_type_info_get_g_type (info);
info_type = g_base_info_get_type (info);
g_base_info_unref (info);
switch (info_type) {
case GI_INFO_TYPE_ENUM:
arg.v_int32 = g_value_get_enum (&value);
break;
case GI_INFO_TYPE_INTERFACE:
case GI_INFO_TYPE_OBJECT:
arg.v_pointer = g_value_get_object (&value);
break;
case GI_INFO_TYPE_BOXED:
case GI_INFO_TYPE_STRUCT:
case GI_INFO_TYPE_UNION:
if (g_type_is_a (type, G_TYPE_BOXED)) {
arg.v_pointer = g_value_get_boxed (&value);
} else if (g_type_is_a (type, G_TYPE_POINTER)) {
arg.v_pointer = g_value_get_pointer (&value);
} else {
PyErr_Format (PyExc_NotImplementedError,
"Retrieving properties of type '%s' is not implemented",
g_type_name (type));
}
break;
default:
PyErr_Format (PyExc_NotImplementedError,
"Retrieving properties of type '%s' is not implemented",
g_type_name (type));
goto out;
}
break;
}
case GI_TYPE_TAG_GHASH:
arg.v_pointer = g_value_get_boxed (&value);
break;
case GI_TYPE_TAG_GLIST:
arg.v_pointer = g_value_get_pointer (&value);
break;
case GI_TYPE_TAG_ARRAY:
{
gchar** strings;
GArray *arg_items;
int i;
strings = g_value_get_boxed (&value);
if (strings == NULL)
arg.v_pointer = NULL;
else {
arg_items = g_array_sized_new (TRUE, TRUE, sizeof (GIArgument), g_strv_length (strings));
g_array_set_size (arg_items, g_strv_length (strings));
for (i = 0; strings[i] != NULL; ++i) {
g_array_index (arg_items, GIArgument, i).v_string = strings[i];
}
arg.v_pointer = arg_items;
}
break;
}
default:
PyErr_Format (PyExc_NotImplementedError,
"Retrieving properties of type %s is not implemented",
g_type_tag_to_string (g_type_info_get_tag (type_info)));
goto out;
}
py_value = _pygi_argument_to_object (&arg, type_info, transfer);
out:
g_free (property_name);
if (property_info != NULL)
g_base_info_unref (property_info);
if (type_info != NULL)
g_base_info_unref (type_info);
return py_value;
}
