PyObject*
pyg_enum_from_gtype (GType gtype, int value)
{
PyObject *pyclass, *values, *retval, *intvalue;
g_return_val_if_fail(gtype != G_TYPE_INVALID, NULL);
/* Get a wrapper class by:
* 1. check for one attached to the gtype
* 2. lookup one in a typelib
* 3. creating a new one
*/
pyclass = (PyObject*)g_type_get_qdata(gtype, pygenum_class_key);
// if (!pyclass)
// pyclass = pygi_type_import_by_g_type(gtype);
if (!pyclass)
pyclass = pyg_enum_add(NULL, g_type_name(gtype), NULL, gtype);
if (!pyclass)
return PYGLIB_PyLong_FromLong(value);
values = PyDict_GetItemString(((PyTypeObject *)pyclass)->tp_dict,
"__enum_values__");
intvalue = PYGLIB_PyLong_FromLong(value);
retval = PyDict_GetItem(values, intvalue);
if (retval) {
Py_INCREF(retval);
}
else {
PyErr_Clear();
retval = pyg_enum_val_new(pyclass, gtype, intvalue);
}
Py_DECREF(intvalue);
return retval;
}
/**
* _pygi_marshal_to_py_basic_type:
* @arg: The argument to convert to an object.
* @type_tag: Type tag for @arg
* @transfer: Transfer annotation
*
* Convert the given argument to a Python object. This function
* is restricted to simple types that only require the GITypeTag
* and GITransfer. For a more complete conversion routine, use:
* _pygi_argument_to_object.
*
* Returns: A PyObject representing @arg or NULL if it cannot convert
* the argument.
*/
PyObject *
_pygi_marshal_to_py_basic_type (GIArgument *arg,
GITypeTag type_tag,
GITransfer transfer)
{
switch (type_tag) {
case GI_TYPE_TAG_BOOLEAN:
return PyBool_FromLong (arg->v_boolean);
case GI_TYPE_TAG_INT8:
return PYGLIB_PyLong_FromLong (arg->v_int8);
case GI_TYPE_TAG_UINT8:
return PYGLIB_PyLong_FromLong (arg->v_uint8);
case GI_TYPE_TAG_INT16:
return PYGLIB_PyLong_FromLong (arg->v_int16);
case GI_TYPE_TAG_UINT16:
return PYGLIB_PyLong_FromLong (arg->v_uint16);
case GI_TYPE_TAG_INT32:
return PYGLIB_PyLong_FromLong (arg->v_int32);
case GI_TYPE_TAG_UINT32:
return PyLong_FromLongLong (arg->v_uint32);
case GI_TYPE_TAG_INT64:
return PyLong_FromLongLong (arg->v_int64);
case GI_TYPE_TAG_UINT64:
return PyLong_FromUnsignedLongLong (arg->v_uint64);
case GI_TYPE_TAG_FLOAT:
return PyFloat_FromDouble (arg->v_float);
case GI_TYPE_TAG_DOUBLE:
return PyFloat_FromDouble (arg->v_double);
case GI_TYPE_TAG_GTYPE:
return pyg_type_wrapper_new ( (GType) arg->v_long);
case GI_TYPE_TAG_UNICHAR:
return _pygi_marshal_to_py_unichar (arg);
case GI_TYPE_TAG_UTF8:
return _pygi_marshal_to_py_utf8 (arg);
case GI_TYPE_TAG_FILENAME:
return _pygi_marshal_to_py_filename (arg);
default:
return NULL;
}
return NULL;
}
/**
* pyglib_error_check:
* @error: a pointer to the GError.
*
* Checks to see if the GError has been set. If the error has been
* set, then the glib.GError Python exception will be raised, and
* the GError cleared.
*
* Returns: True if an error was set.
*/
gboolean
pyglib_error_check(GError **error)
{
PyGILState_STATE state;
PyObject *exc_type;
PyObject *exc_instance;
PyObject *d;
g_return_val_if_fail(error != NULL, FALSE);
if (*error == NULL)
return FALSE;
state = pyglib_gil_state_ensure();
exc_type = _PyGLib_API->gerror_exception;
if (exception_table != NULL)
{
PyObject *item;
item = PyDict_GetItem(exception_table, PYGLIB_PyLong_FromLong((*error)->domain));
if (item != NULL)
exc_type = item;
}
exc_instance = PyObject_CallFunction(exc_type, "z", (*error)->message);
if ((*error)->domain) {
PyObject_SetAttrString(exc_instance, "domain",
d=PYGLIB_PyUnicode_FromString(g_quark_to_string((*error)->domain)));
Py_DECREF(d);
}
else
PyObject_SetAttrString(exc_instance, "domain", Py_None);
PyObject_SetAttrString(exc_instance, "code",
d=PYGLIB_PyLong_FromLong((*error)->code));
Py_DECREF(d);
if ((*error)->message) {
PyObject_SetAttrString(exc_instance, "message",
d=PYGLIB_PyUnicode_FromString((*error)->message));
Py_DECREF(d);
} else {
PyObject_SetAttrString(exc_instance, "message", Py_None);
}
PyErr_SetObject(_PyGLib_API->gerror_exception, exc_instance);
Py_DECREF(exc_instance);
g_clear_error(error);
pyglib_gil_state_release(state);
return TRUE;
}
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 *
_wrap_g_value_info_get_value (PyGIBaseInfo *self)
{
glong value;
value = g_value_info_get_value ( (GIValueInfo *) self->info);
return PYGLIB_PyLong_FromLong (value);
}
PyObject *
_pygi_marshal_to_py_int8 (PyGIInvokeState *state,
PyGICallableCache *callable_cache,
PyGIArgCache *arg_cache,
GIArgument *arg)
{
PyObject *py_obj = PYGLIB_PyLong_FromLong (arg->v_int8);
return py_obj;
}
static PyObject *
_wrap_test_g_object_new (PyObject * self)
{
GObject *obj;
PyObject *rv;
obj = g_object_new(g_type_from_name("PyGObject"), NULL);
rv = PYGLIB_PyLong_FromLong(obj->ref_count); /* should be == 2 at this point */
g_object_unref(obj);
return rv;
}
static PyObject *
_wrap_test_to_unichar_conv (PyObject * self, PyObject *args)
{
PyObject *obj;
gunichar result;
if (!PyArg_ParseTuple(args, "O", &obj))
return NULL;
if (!pyg_pyobj_to_unichar_conv (obj, &result))
return NULL;
return PYGLIB_PyLong_FromLong (result);
}
/**
* pygi_register_exception_for_domain:
* @name: name of the exception
* @error_domain: error domain
*
* Registers a new GLib.Error exception subclass called #name for
* a specific #domain. This exception will be raised when a GError
* of the same domain is passed in to pygi_error_check().
*
* Returns: the new exception
*/
PyObject *
pygi_register_exception_for_domain (gchar *name,
gint error_domain)
{
PyObject *exception;
exception = PyErr_NewException(name, PyGError, NULL);
if (exception_table == NULL)
exception_table = PyDict_New();
PyDict_SetItem(exception_table,
PYGLIB_PyLong_FromLong(error_domain),
exception);
return exception;
}
static PyObject *
_wrap_test_parse_constructor_args (PyObject *self, PyObject *args)
{
char *arg_names[] = {"label", NULL};
char *prop_names[] = {"label", NULL};
GParameter params[1] = {{0}};
PyObject *parsed_args[1];
guint nparams = 0;
if (!PyArg_ParseTuple(args, "O", &(parsed_args[0])))
return NULL;
if (!pyg_parse_constructor_args (
TYPE_TEST, arg_names, prop_names, params, &nparams, parsed_args)) {
return NULL;
}
return PYGLIB_PyLong_FromLong (nparams);
}
/**
* pygi_error_marshal_to_py:
* @error: a pointer to the GError.
*
* Checks to see if @error has been set. If @error has been set, then a
* GLib.GError Python exception object is returned (but not raised).
*
* Returns: a GLib.GError Python exception object, or NULL.
*/
PyObject *
pygi_error_marshal_to_py (GError **error)
{
PyGILState_STATE state;
PyObject *exc_type;
PyObject *exc_instance;
const char *domain = NULL;
g_return_val_if_fail(error != NULL, NULL);
if (*error == NULL)
return NULL;
state = pyglib_gil_state_ensure();
exc_type = PyGError;
if (exception_table != NULL)
{
PyObject *item;
item = PyDict_GetItem(exception_table, PYGLIB_PyLong_FromLong((*error)->domain));
if (item != NULL)
exc_type = item;
}
if ((*error)->domain) {
domain = g_quark_to_string ((*error)->domain);
}
exc_instance = PyObject_CallFunction (exc_type, "ssi",
(*error)->message,
domain,
(*error)->code);
pyglib_gil_state_release(state);
return exc_instance;
}
static PyObject *
_wrap_g_type_wrapper__get_depth(PyGTypeWrapper *self, void *closure)
{
return PYGLIB_PyLong_FromLong(g_type_depth(self->type));
}
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;
}
/**
* 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;
}
