PyObject *
_pygi_marshal_to_py_interface_struct (PyGIInvokeState *state,
PyGICallableCache *callable_cache,
PyGIArgCache *arg_cache,
GIArgument *arg)
{
PyObject *py_obj = NULL;
PyGIInterfaceCache *iface_cache = (PyGIInterfaceCache *)arg_cache;
GType type = iface_cache->g_type;
if (arg->v_pointer == NULL) {
py_obj = Py_None;
Py_INCREF (py_obj);
return py_obj;
}
if (g_type_is_a (type, G_TYPE_VALUE)) {
py_obj = pyg_value_as_pyobject (arg->v_pointer, FALSE);
} else if (iface_cache->is_foreign) {
py_obj = pygi_struct_foreign_convert_from_g_argument (iface_cache->interface_info,
arg->v_pointer);
} else if (g_type_is_a (type, G_TYPE_BOXED)) {
py_obj = _pygi_boxed_new ( (PyTypeObject *)iface_cache->py_type, arg->v_pointer,
arg_cache->transfer == GI_TRANSFER_EVERYTHING);
} else if (g_type_is_a (type, G_TYPE_POINTER)) {
if (iface_cache->py_type == NULL ||
!PyType_IsSubtype ( (PyTypeObject *)iface_cache->py_type, &PyGIStruct_Type)) {
g_warn_if_fail(arg_cache->transfer == GI_TRANSFER_NOTHING);
py_obj = pyg_pointer_new (type, arg->v_pointer);
} else {
py_obj = _pygi_struct_new ( (PyTypeObject *)iface_cache->py_type, arg->v_pointer,
arg_cache->transfer == GI_TRANSFER_EVERYTHING);
}
} else if (g_type_is_a (type, G_TYPE_VARIANT)) {
g_variant_ref_sink (arg->v_pointer);
py_obj = _pygi_struct_new ( (PyTypeObject *)iface_cache->py_type, arg->v_pointer,
FALSE);
} else if (type == G_TYPE_NONE && iface_cache->is_foreign) {
py_obj = pygi_struct_foreign_convert_from_g_argument (iface_cache->interface_info, arg->v_pointer);
} else if (type == G_TYPE_NONE) {
py_obj = _pygi_struct_new ( (PyTypeObject *) iface_cache->py_type, arg->v_pointer,
arg_cache->transfer == GI_TRANSFER_EVERYTHING);
} else {
PyErr_Format (PyExc_NotImplementedError,
"structure type '%s' is not supported yet",
g_type_name (type));
}
return py_obj;
}
PyObject *
_helper_wrap_pointer_glist (const GList *list, GType boxed_type)
{
PyObject *py_list;
const GList *tmp;
if ((py_list = PyList_New(0)) == NULL) {
return NULL;
}
for (tmp = list; tmp != NULL; tmp = tmp->next) {
PyObject *py_obj = pyg_pointer_new(boxed_type, tmp->data);
if (py_obj == NULL) {
Py_DECREF(py_list);
return NULL;
}
PyList_Append(py_list, py_obj);
Py_DECREF(py_obj);
}
return py_list;
}
PyObject *
_pygi_marshal_to_py_interface_struct (GIArgument *arg,
GIInterfaceInfo *interface_info,
GType g_type,
PyObject *py_type,
GITransfer transfer,
gboolean is_allocated,
gboolean is_foreign)
{
PyObject *py_obj = NULL;
if (arg->v_pointer == NULL) {
Py_RETURN_NONE;
}
if (g_type_is_a (g_type, G_TYPE_VALUE)) {
py_obj = pyg_value_as_pyobject (arg->v_pointer, FALSE);
} else if (is_foreign) {
py_obj = pygi_struct_foreign_convert_from_g_argument (interface_info,
arg->v_pointer);
} else if (g_type_is_a (g_type, G_TYPE_BOXED)) {
if (py_type) {
py_obj = _pygi_boxed_new ((PyTypeObject *) py_type,
arg->v_pointer,
transfer == GI_TRANSFER_EVERYTHING || is_allocated,
is_allocated ?
g_struct_info_get_size(interface_info) : 0);
}
} else if (g_type_is_a (g_type, G_TYPE_POINTER)) {
if (py_type == NULL ||
!PyType_IsSubtype ((PyTypeObject *) py_type, &PyGIStruct_Type)) {
g_warn_if_fail (transfer == GI_TRANSFER_NOTHING);
py_obj = pyg_pointer_new (g_type, arg->v_pointer);
} else {
py_obj = _pygi_struct_new ( (PyTypeObject *) py_type,
arg->v_pointer,
transfer == GI_TRANSFER_EVERYTHING);
}
} else if (g_type_is_a (g_type, G_TYPE_VARIANT)) {
/* Note: sink the variant (add a ref) only if we are not transfered ownership.
* GLib.Variant overrides __del__ which will then call "g_variant_unref" for
* cleanup in either case. */
if (py_type) {
if (transfer == GI_TRANSFER_NOTHING) {
g_variant_ref_sink (arg->v_pointer);
}
py_obj = _pygi_struct_new ((PyTypeObject *) py_type,
arg->v_pointer,
FALSE);
}
} else if (g_type == G_TYPE_NONE) {
if (py_type) {
py_obj = _pygi_struct_new ((PyTypeObject *) py_type,
arg->v_pointer,
transfer == GI_TRANSFER_EVERYTHING);
}
} else {
PyErr_Format (PyExc_NotImplementedError,
"structure type '%s' is not supported yet",
g_type_name (g_type));
}
return py_obj;
}
/**
* pyg_value_as_pyobject:
* @value: the GValue object.
* @copy_boxed: true if boxed values should be copied.
*
* This function creates/returns a Python wrapper object that
* represents the GValue passed as an argument.
*
* Returns: a PyObject representing the value.
*/
PyObject *
pyg_value_as_pyobject(const GValue *value, gboolean copy_boxed)
{
gchar buf[128];
switch (G_TYPE_FUNDAMENTAL(G_VALUE_TYPE(value))) {
case G_TYPE_INTERFACE:
if (g_type_is_a(G_VALUE_TYPE(value), G_TYPE_OBJECT))
return pygobject_new(g_value_get_object(value));
else
break;
case G_TYPE_CHAR: {
gint8 val = g_value_get_char(value);
return PYGLIB_PyUnicode_FromStringAndSize((char *)&val, 1);
}
case G_TYPE_UCHAR: {
guint8 val = g_value_get_uchar(value);
return PYGLIB_PyBytes_FromStringAndSize((char *)&val, 1);
}
case G_TYPE_BOOLEAN: {
return PyBool_FromLong(g_value_get_boolean(value));
}
case G_TYPE_INT:
return PYGLIB_PyLong_FromLong(g_value_get_int(value));
case G_TYPE_UINT:
{
/* in Python, the Int object is backed by a long. If a
long can hold the whole value of an unsigned int, use
an Int. Otherwise, use a Long object to avoid overflow.
This matches the ULongArg behavior in codegen/argtypes.h */
#if (G_MAXUINT <= G_MAXLONG)
return PYGLIB_PyLong_FromLong((glong) g_value_get_uint(value));
#else
return PyLong_FromUnsignedLong((gulong) g_value_get_uint(value));
#endif
}
case G_TYPE_LONG:
return PYGLIB_PyLong_FromLong(g_value_get_long(value));
case G_TYPE_ULONG:
{
gulong val = g_value_get_ulong(value);
if (val <= G_MAXLONG)
return PYGLIB_PyLong_FromLong((glong) val);
else
return PyLong_FromUnsignedLong(val);
}
case G_TYPE_INT64:
{
gint64 val = g_value_get_int64(value);
if (G_MINLONG <= val && val <= G_MAXLONG)
return PYGLIB_PyLong_FromLong((glong) val);
else
return PyLong_FromLongLong(val);
}
case G_TYPE_UINT64:
{
guint64 val = g_value_get_uint64(value);
if (val <= G_MAXLONG)
return PYGLIB_PyLong_FromLong((glong) val);
else
return PyLong_FromUnsignedLongLong(val);
}
case G_TYPE_ENUM:
return pyg_enum_from_gtype(G_VALUE_TYPE(value), g_value_get_enum(value));
case G_TYPE_FLAGS:
return pyg_flags_from_gtype(G_VALUE_TYPE(value), g_value_get_flags(value));
case G_TYPE_FLOAT:
return PyFloat_FromDouble(g_value_get_float(value));
case G_TYPE_DOUBLE:
return PyFloat_FromDouble(g_value_get_double(value));
case G_TYPE_STRING:
{
const gchar *str = g_value_get_string(value);
if (str)
return PYGLIB_PyUnicode_FromString(str);
Py_INCREF(Py_None);
return Py_None;
}
case G_TYPE_POINTER:
return pyg_pointer_new(G_VALUE_TYPE(value),
g_value_get_pointer(value));
case G_TYPE_BOXED: {
PyGTypeMarshal *bm;
if (G_VALUE_HOLDS(value, PY_TYPE_OBJECT)) {
PyObject *ret = (PyObject *)g_value_dup_boxed(value);
if (ret == NULL) {
Py_INCREF(Py_None);
return Py_None;
}
return ret;
} else if (G_VALUE_HOLDS(value, G_TYPE_VALUE)) {
GValue *n_value = g_value_get_boxed (value);
return pyg_value_as_pyobject(n_value, copy_boxed);
} else if (G_VALUE_HOLDS(value, G_TYPE_VALUE_ARRAY)) {
GValueArray *array = (GValueArray *) g_value_get_boxed(value);
PyObject *ret = PyList_New(array->n_values);
int i;
for (i = 0; i < array->n_values; ++i)
PyList_SET_ITEM(ret, i, pyg_value_as_pyobject
(array->values + i, copy_boxed));
return ret;
} else if (G_VALUE_HOLDS(value, G_TYPE_GSTRING)) {
GString *string = (GString *) g_value_get_boxed(value);
PyObject *ret = PYGLIB_PyUnicode_FromStringAndSize(string->str, string->len);
return ret;
}
bm = pyg_type_lookup(G_VALUE_TYPE(value));
if (bm) {
return bm->fromvalue(value);
} else {
if (copy_boxed)
return pyg_boxed_new(G_VALUE_TYPE(value),
g_value_get_boxed(value), TRUE, TRUE);
else
return pyg_boxed_new(G_VALUE_TYPE(value),
g_value_get_boxed(value),FALSE,FALSE);
}
}
case G_TYPE_PARAM:
return pyg_param_spec_new(g_value_get_param(value));
case G_TYPE_OBJECT:
return pygobject_new(g_value_get_object(value));
default:
{
PyGTypeMarshal *bm;
if ((bm = pyg_type_lookup(G_VALUE_TYPE(value))))
return bm->fromvalue(value);
break;
}
}
g_snprintf(buf, sizeof(buf), "unknown type %s",
g_type_name(G_VALUE_TYPE(value)));
PyErr_SetString(PyExc_TypeError, buf);
return NULL;
}
