static PyObject *
_wrap_value_array_get_nth_type(PyObject *self, PyObject *args)
{
guint n;
GType type;
GValue *nth;
GValueArray *arr;
PyObject *obj;
if (!PyArg_ParseTuple(args, "OI", &obj, &n))
return NULL;
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
if (pyg_boxed_check(obj, G_TYPE_VALUE) &&
G_VALUE_HOLDS(pyg_boxed_get(obj, GValue), G_TYPE_VALUE_ARRAY)) {
arr = g_value_get_boxed(pyg_boxed_get(obj, GValue));
} else if (pyg_boxed_check(obj, G_TYPE_VALUE_ARRAY)) {
arr = pyg_boxed_get(obj, GValueArray);
} else {
PyErr_SetString(PyExc_TypeError, "First argument is not GValueArray");
return NULL;
}
if (n >= arr->n_values) {
PyErr_SetString(PyExc_TypeError, "Index is out of bounds");
return NULL;
}
nth = g_value_array_get_nth(arr, n);
type = G_VALUE_TYPE(nth);
G_GNUC_END_IGNORE_DEPRECATIONS
return pyg_type_wrapper_new(type);
}
static int
pygtk_rc_style_helper_setitem(PyGtkRcStyleHelper_Object *self, Py_ssize_t pos,
PyObject *value)
{
extern PyTypeObject PyGdkGC_Type;
extern PyTypeObject PyGdkPixmap_Type;
if (pos < 0) pos += NUM_STATES;
if (pos < 0 || pos >= NUM_STATES) {
PyErr_SetString(PyExc_IndexError, "index out of range");
return -1;
}
switch (self->type) {
case RC_STYLE_STRING_ARRAY:
{
gchar **array = (gchar **)self->array;
gchar *string;
PyObject *as_string;
if (value == Py_None)
string = NULL;
else if ((as_string = PyObject_Str(value)) != NULL) {
string = g_strdup(PyString_AsString(as_string));
Py_DECREF(as_string);
}
else
return -1;
g_free(array[pos]);
array[pos] = string;
return 0;
}
case RC_STYLE_COLOUR_ARRAY:
if (value == Py_None) {
self->rc_style->color_flags[pos] &= ~self->is_set_flag;
return 0;
}
if (pyg_boxed_check(value, GDK_TYPE_COLOR)) {
GdkColor *array = (GdkColor *)self->array;
array[pos] = *pyg_boxed_get(value, GdkColor);
self->rc_style->color_flags[pos] |= self->is_set_flag;
return 0;
}
else {
PyErr_SetString(PyExc_TypeError, "can only assign a gtk.gdk.Color or None");
return -1;
}
}
g_assert_not_reached();
return -1;
}
gboolean
pygdk_rectangle_from_pyobject(PyObject *object, GdkRectangle *rectangle)
{
g_return_val_if_fail(rectangle != NULL, FALSE);
if (pyg_boxed_check(object, GDK_TYPE_RECTANGLE)) {
*rectangle = *pyg_boxed_get(object, GdkRectangle);
return TRUE;
}
if (PyArg_ParseTuple(object, "iiii", &rectangle->x, &rectangle->y,
&rectangle->width, &rectangle->height)) {
return TRUE;
}
PyErr_Clear();
PyErr_SetString(PyExc_TypeError, "could not convert to GdkRectangle");
return FALSE;
}
static PyObject *
_wrap_gst_vorbis_tag_add(PyObject *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = { "list", "tag", "value", NULL };
GstTagList *list = NULL;
PyObject *py_list;
char *tag, *value;
if (!PyArg_ParseTupleAndKeywords(args, kwargs,"Oss:gst_vorbis_tag_add", kwlist, &py_list, &tag, &value))
return NULL;
if (pyg_boxed_check(py_list, GST_TYPE_TAG_LIST))
list = pyg_boxed_get(py_list, GstTagList);
else {
PyErr_SetString(PyExc_TypeError, "list should be a GstTagList");
return NULL;
}
pyg_begin_allow_threads;
gst_vorbis_tag_add(list, tag, value);
pyg_end_allow_threads;
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
_wrap_gst_tag_list_to_xmp_buffer(PyObject *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = { "taglist", "readonly", NULL };
GstTagList *taglist = NULL;
PyObject *py_taglist;
int readonly;
GstBuffer *ret;
if (!PyArg_ParseTupleAndKeywords(args, kwargs,"Oi:tag_list_to_xmp_buffer", kwlist, &py_taglist, &readonly))
return NULL;
if (pyg_boxed_check(py_taglist, GST_TYPE_TAG_LIST))
taglist = pyg_boxed_get(py_taglist, GstTagList);
else {
PyErr_SetString(PyExc_TypeError, "taglist should be a GstTagList");
return NULL;
}
pyg_begin_allow_threads;
ret = gst_tag_list_to_xmp_buffer(taglist, readonly);
pyg_end_allow_threads;
/* pygobject_new handles NULL checking */
return pygstminiobject_new((GstMiniObject *)ret);
}
static PyObject *
_wrap_gst_tag_to_vorbis_comments(PyObject *self, PyObject *args, PyObject *kwargs)
{
PyObject *py_taglist;
const GstTagList *taglist;
const gchar *tag;
const GList *list;
const GList *l;
PyObject *py_list;
if (!PyArg_ParseTuple(args, "Os", &py_taglist, &tag))
return NULL;
if (pyg_boxed_check(py_taglist, GST_TYPE_TAG_LIST))
taglist = pyg_boxed_get(py_taglist, GstTagList);
else {
PyErr_SetString(PyExc_TypeError, "list should be a GstTagList");
return NULL;
}
pyg_begin_allow_threads;
list = gst_tag_to_vorbis_comments (taglist, tag);
pyg_end_allow_threads;
py_list = PyList_New(0);
for (l = list; l; l = l->next) {
gchar *pair = (gchar *)l->data;
PyObject *py_pair = PyString_FromString(pair);
PyList_Append(py_list, py_pair);
Py_DECREF(py_pair);
}
return py_list;
}
GimpParam *
pygimp_param_from_tuple(PyObject *args, const GimpParamDef *ptype, int nparams)
{
PyObject *tuple, *item, *r, *g, *b, *x, *y, *w, *h;
GimpParam *ret;
int i, j, len;
gint32 *i32a; gint16 *i16a; guint8 *i8a; gdouble *fa; gchar **sa;
if (nparams == 0)
tuple = PyTuple_New(0);
else if (!PyTuple_Check(args) && nparams == 1)
tuple = Py_BuildValue("(O)", args);
else {
Py_INCREF(args);
tuple = args;
}
if (!PyTuple_Check(tuple)) {
PyErr_SetString(PyExc_TypeError, "wrong type of parameter");
Py_DECREF(tuple);
return NULL;
}
if (PyTuple_Size(tuple) != nparams) {
PyErr_SetString(PyExc_TypeError, "wrong number of parameters");
Py_DECREF(tuple);
return NULL;
}
ret = g_new(GimpParam, nparams+1);
for (i = 0; i <= nparams; i++)
ret[i].type = GIMP_PDB_STATUS;
#define check(expr) if (expr) { \
PyErr_SetString(PyExc_TypeError, "wrong parameter type"); \
Py_DECREF(tuple); \
gimp_destroy_params(ret, nparams); \
return NULL; \
}
#define arraycheck(expr, ar) if (expr) { \
PyErr_SetString(PyExc_TypeError, "subscript of wrong type"); \
Py_DECREF(tuple); \
gimp_destroy_params(ret, nparams); \
g_free(ar); \
return NULL; \
}
for (i = 1; i <= nparams; i++) {
item = PyTuple_GetItem(tuple, i-1);
switch (ptype[i-1].type) {
case GIMP_PDB_INT32:
check((x = PyNumber_Int(item)) == NULL);
ret[i].data.d_int32 = (gint32)PyInt_AsLong(x);
Py_DECREF(x);
break;
case GIMP_PDB_INT16:
check((x = PyNumber_Int(item)) == NULL);
ret[i].data.d_int16 = (gint16)PyInt_AsLong(x);
Py_DECREF(x);
break;
case GIMP_PDB_INT8:
check((x = PyNumber_Int(item)) == NULL);
ret[i].data.d_int8 = (guint8)PyInt_AsLong(x);
Py_DECREF(x);
break;
case GIMP_PDB_FLOAT:
check((x = PyNumber_Float(item)) == NULL);
ret[i].data.d_float = PyFloat_AsDouble(x);
Py_DECREF(x);
break;
case GIMP_PDB_STRING:
if (item == Py_None) {
ret[i].data.d_string = NULL;
break;
}
check((x = PyObject_Str(item)) == NULL);
ret[i].data.d_string = g_strdup(PyString_AsString(x));
Py_DECREF(x);
break;
case GIMP_PDB_INT32ARRAY:
check(!PySequence_Check(item));
len = PySequence_Length(item);
i32a = g_new(gint32, len);
for (j = 0; j < len; j++) {
x = PySequence_GetItem(item, j);
arraycheck((y=PyNumber_Int(x))==NULL,
i32a);
i32a[j] = PyInt_AsLong(y);
Py_DECREF(y);
}
ret[i].data.d_int32array = i32a;
break;
case GIMP_PDB_INT16ARRAY:
check(!PySequence_Check(item));
len = PySequence_Length(item);
i16a = g_new(gint16, len);
for (j = 0; j < len; j++) {
x = PySequence_GetItem(item, j);
arraycheck((y=PyNumber_Int(x))==NULL,
i16a);
i16a[j] = PyInt_AsLong(y);
Py_DECREF(y);
}
ret[i].data.d_int16array = i16a;
break;
case GIMP_PDB_INT8ARRAY:
check(!PySequence_Check(item));
len = PySequence_Length(item);
i8a = g_new(guint8, len);
for (j = 0; j < len; j++) {
x = PySequence_GetItem(item, j);
arraycheck((y=PyNumber_Int(x))==NULL,
i8a);
i8a[j] = PyInt_AsLong(y);
Py_DECREF(y);
}
ret[i].data.d_int8array = i8a;
break;
case GIMP_PDB_FLOATARRAY:
check(!PySequence_Check(item));
len = PySequence_Length(item);
fa = g_new(gdouble, len);
for (j = 0; j < len; j++) {
x = PySequence_GetItem(item, j);
arraycheck((y=PyNumber_Float(x))==NULL,
fa);
fa[j] = PyFloat_AsDouble(y);
Py_DECREF(y);
}
ret[i].data.d_floatarray = fa;
break;
case GIMP_PDB_STRINGARRAY:
check(!PySequence_Check(item));
len = PySequence_Length(item);
sa = g_new(gchar *, len);
for (j = 0; j < len; j++) {
x = PySequence_GetItem(item, j);
if (x == Py_None) {
sa[j] = NULL;
continue;
}
arraycheck((y=PyObject_Str(x))==NULL,
sa);
sa[j] = g_strdup(PyString_AsString(y));
Py_DECREF(y);
}
ret[i].data.d_stringarray = sa;
break;
case GIMP_PDB_COLOR:
{
GimpRGB *rgb, tmprgb;
if (!pygimp_rgb_check(item)) {
check(!PySequence_Check(item) ||
PySequence_Length(item) < 3);
r = PySequence_GetItem(item, 0);
g = PySequence_GetItem(item, 1);
b = PySequence_GetItem(item, 2);
check(!PyInt_Check(r) || !PyInt_Check(g) ||
!PyInt_Check(b));
gimp_rgba_set_uchar(&tmprgb, PyInt_AsLong(r),
PyInt_AsLong(g), PyInt_AsLong(b), 255);
rgb = &tmprgb;
} else {
rgb = pyg_boxed_get(item, GimpRGB);
}
ret[i].data.d_color = *rgb;
}
break;
case GIMP_PDB_REGION:
check(!PySequence_Check(item) ||
PySequence_Length(item) < 4);
x = PySequence_GetItem(item, 0);
y = PySequence_GetItem(item, 1);
w = PySequence_GetItem(item, 2);
h = PySequence_GetItem(item, 3);
check(!PyInt_Check(x) || !PyInt_Check(y) ||
!PyInt_Check(w) || !PyInt_Check(h));
ret[i].data.d_region.x = PyInt_AsLong(x);
ret[i].data.d_region.y = PyInt_AsLong(y);
ret[i].data.d_region.width = PyInt_AsLong(w);
ret[i].data.d_region.height = PyInt_AsLong(h);
break;
case GIMP_PDB_DISPLAY:
check(!pygimp_display_check(item));
ret[i].data.d_display = ((PyGimpDisplay *)item)->ID;
break;
case GIMP_PDB_IMAGE:
if (item == Py_None) {
ret[i].data.d_image = -1;
break;
}
check(!pygimp_image_check(item));
ret[i].data.d_image = ((PyGimpImage *)item)->ID;
break;
case GIMP_PDB_LAYER:
if (item == Py_None) {
ret[i].data.d_layer = -1;
break;
}
check(!pygimp_layer_check(item));
ret[i].data.d_layer = ((PyGimpLayer *)item)->ID;
break;
case GIMP_PDB_CHANNEL:
if (item == Py_None) {
ret[i].data.d_channel = -1;
break;
}
check(!pygimp_channel_check(item));
ret[i].data.d_channel = ((PyGimpChannel *)item)->ID;
break;
case GIMP_PDB_DRAWABLE:
if (item == Py_None) {
ret[i].data.d_channel = -1;
break;
}
check(!pygimp_drawable_check(item));
ret[i].data.d_channel = ((PyGimpDrawable *)item)->ID;
break;
case GIMP_PDB_SELECTION:
check(!pygimp_layer_check(item));
ret[i].data.d_selection = ((PyGimpLayer *)item)->ID;
break;
case GIMP_PDB_BOUNDARY:
check(!PyInt_Check(item));
ret[i].data.d_boundary = PyInt_AsLong(item);
break;
case GIMP_PDB_VECTORS:
check(!pygimp_vectors_check(item));
ret[i].data.d_vectors = ((PyGimpVectors *)item)->ID;
break;
case GIMP_PDB_PARASITE:
/* can't do anything, since size of GimpParasite is not known */
break;
case GIMP_PDB_STATUS:
check(!PyInt_Check(item));
ret[i].data.d_status = PyInt_AsLong(item);
break;
case GIMP_PDB_END:
break;
}
#undef check
#undef arraycheck
ret[i].type = ptype[i-1].type;
}
Py_DECREF(tuple);
return ret;
}
static int
pygtk_style_helper_setitem(PyGtkStyleHelper_Object *self, Py_ssize_t pos,
PyObject *value)
{
extern PyTypeObject PyGdkGC_Type;
extern PyTypeObject PyGdkPixmap_Type;
if (pos < 0) pos += NUM_STATES;
if (pos < 0 || pos >= NUM_STATES) {
PyErr_SetString(PyExc_IndexError, "index out of range");
return -1;
}
switch (self->type) {
case STYLE_COLOUR_ARRAY:
{
GdkColor *array = (GdkColor *)self->array;
if (!pyg_boxed_check(value, GDK_TYPE_COLOR)) {
PyErr_SetString(PyExc_TypeError, "can only assign a GdkColor");
return -1;
}
array[pos] = *pyg_boxed_get(value, GdkColor);
return 0;
}
case STYLE_GC_ARRAY:
{
GdkGC **array = (GdkGC **)self->array;
if (!pygobject_check(value, &PyGdkGC_Type)) {
PyErr_SetString(PyExc_TypeError, "can only assign a GdkGC");
return -1;
}
if (array[pos]) {
g_object_unref(array[pos]);
}
array[pos] = GDK_GC(g_object_ref(pygobject_get(value)));
return 0;
}
case STYLE_PIXMAP_ARRAY:
{
GdkPixmap **array = (GdkPixmap **)self->array;
GdkPixmap *cvalue = NULL;
if (pygobject_check(value, &PyGdkPixmap_Type))
cvalue = GDK_PIXMAP(g_object_ref(pygobject_get(value)));
else if (PyLong_Check(value)) {
if (PyLong_AsLong(value) != GDK_PARENT_RELATIVE) {
PyErr_SetString(PyExc_TypeError,
"can only assign a GdkPixmap, None or "
"GDK_PARENT_RELATIVE");
return -1;
}
cvalue = (GdkPixmap*)GDK_PARENT_RELATIVE;
} else if (value != Py_None) {
PyErr_SetString(PyExc_TypeError,
"can only assign a GdkPixmap, None or "
"GDK_PARENT_RELATIVE");
return -1;
}
if (array[pos] && (long)array[pos] != GDK_PARENT_RELATIVE) {
g_object_unref(array[pos]);
}
array[pos] = cvalue;
return 0;
}
}
g_assert_not_reached();
return -1;
}
/**
* 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;
}
