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; }