static PyObject *
_wrap_gimp_thumb_find_thumb(PyGObject *self, PyObject *args, PyObject *kwargs)
{
gchar *uri, *ret;
PyObject *py_size, *py_ret;
GimpThumbSize size;
static char *kwlist[] = { "uri", NULL };
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "sO:find_thumb", kwlist,
&uri, &py_size))
return NULL;
if (pyg_enum_get_value(GIMP_TYPE_THUMB_SIZE, py_size, (gint *)&size))
return NULL;
ret = gimp_thumb_find_thumb(uri, &size);
if (ret == NULL) {
Py_INCREF(Py_None);
return Py_None;
}
py_ret = Py_BuildValue("sN", ret,
pyg_enum_from_gtype(GIMP_TYPE_THUMB_SIZE, size));
g_free(ret);
return py_ret;
}
static PyObject *
_wrap_gimp_thumbnail_delete_others(PyGObject *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = { "size", NULL };
PyObject *py_size = NULL;
GimpThumbSize size;
if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Gimp.Thumbnail.delete_others", kwlist, &py_size))
return NULL;
if (pyg_enum_get_value(GIMP_TYPE_THUMB_SIZE, py_size, (gpointer)&size))
return NULL;
gimp_thumbnail_delete_others(GIMP_THUMBNAIL(self->obj), size);
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
_wrap_gimp_thumbnail_check_thumb(PyGObject *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = { "size", NULL };
PyObject *py_size = NULL;
gint ret;
GimpThumbSize size;
if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Gimp.Thumbnail.check_thumb", kwlist, &py_size))
return NULL;
if (pyg_enum_get_value(GIMP_TYPE_THUMB_SIZE, py_size, (gpointer)&size))
return NULL;
ret = gimp_thumbnail_check_thumb(GIMP_THUMBNAIL(self->obj), size);
return pyg_enum_from_gtype(GIMP_TYPE_THUMB_STATE, ret);
}
static PyObject *
_wrap_gimp_thumb_get_thumb_dir(PyObject *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = { "size", NULL };
PyObject *py_size = NULL;
const gchar *ret;
GimpThumbSize size;
if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:get_thumb_dir", kwlist, &py_size))
return NULL;
if (pyg_enum_get_value(GIMP_TYPE_THUMB_SIZE, py_size, (gpointer)&size))
return NULL;
ret = gimp_thumb_get_thumb_dir(size);
if (ret)
return PyString_FromString(ret);
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
_wrap_gimp_thumb_ensure_thumb_dir(PyObject *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = { "size", NULL };
PyObject *py_size = NULL;
int ret;
GError *error = NULL;
GimpThumbSize size;
if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:ensure_thumb_dir", kwlist, &py_size))
return NULL;
if (pyg_enum_get_value(GIMP_TYPE_THUMB_SIZE, py_size, (gpointer)&size))
return NULL;
ret = gimp_thumb_ensure_thumb_dir(size, &error);
if (pyg_error_check(&error))
return NULL;
return PyBool_FromLong(ret);
}
static PyObject *
_wrap_gimp_thumbnail_load_thumb(PyGObject *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = { "size", NULL };
PyObject *py_size = NULL;
GdkPixbuf *ret;
GError *error = NULL;
GimpThumbSize size;
if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Gimp.Thumbnail.load_thumb", kwlist, &py_size))
return NULL;
if (pyg_enum_get_value(GIMP_TYPE_THUMB_SIZE, py_size, (gpointer)&size))
return NULL;
ret = gimp_thumbnail_load_thumb(GIMP_THUMBNAIL(self->obj), size, &error);
if (pyg_error_check(&error))
return NULL;
/* pygobject_new handles NULL checking */
return pygobject_new((GObject *)ret);
}
static PyObject *
_wrap_gimp_thumb_get_thumb_dir_local(PyObject *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = { "dirname", "size", NULL };
char *dirname;
PyObject *py_size = NULL;
gchar *ret;
GimpThumbSize size;
if (!PyArg_ParseTupleAndKeywords(args, kwargs,"sO:get_thumb_dir_local", kwlist, &dirname, &py_size))
return NULL;
if (pyg_enum_get_value(GIMP_TYPE_THUMB_SIZE, py_size, (gpointer)&size))
return NULL;
ret = gimp_thumb_get_thumb_dir_local(dirname, size);
if (ret) {
PyObject *py_ret = PyString_FromString(ret);
g_free(ret);
return py_ret;
}
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
pf_call(PyGimpPDBFunction *self, PyObject *args, PyObject *kwargs)
{
GimpParam *params, *ret;
int nret;
PyObject *t = NULL, *r;
GimpRunMode run_mode = GIMP_RUN_NONINTERACTIVE;
#if PG_DEBUG > 0
g_printerr("--- %s --- ", PyString_AsString(self->proc_name));
#endif
if (kwargs) {
int len, pos;
PyObject *key, *val;
len = PyDict_Size(kwargs);
if (len == 1) {
pos = 0;
PyDict_Next(kwargs, &pos, &key, &val);
if (!PyString_Check(key)) {
PyErr_SetString(PyExc_TypeError,
"keyword argument name is not a string");
return NULL;
}
if (strcmp(PyString_AsString(key), "run_mode") != 0) {
PyErr_SetString(PyExc_TypeError,
"only 'run_mode' keyword argument accepted");
return NULL;
}
if (pyg_enum_get_value(GIMP_TYPE_RUN_MODE, val, (gpointer)&run_mode))
return NULL;
} else if (len != 0) {
PyErr_SetString(PyExc_TypeError,
"expecting at most one keyword argument");
return NULL;
}
}
if (self->nparams > 0 && !strcmp(self->params[0].name, "run-mode")) {
params = pygimp_param_from_tuple(args, self->params + 1,
self->nparams - 1);
if (params == NULL)
return NULL;
params[0].type = self->params[0].type;
params[0].data.d_int32 = run_mode;
#if PG_DEBUG > 1
pygimp_param_print(self->nparams, params);
#endif
ret = gimp_run_procedure2(self->name, &nret, self->nparams, params);
} else {
params = pygimp_param_from_tuple(args, self->params, self->nparams);
if (params == NULL)
return NULL;
#if PG_DEBUG > 1
pygimp_param_print(self->nparams, params+1);
#endif
ret = gimp_run_procedure2(self->name, &nret, self->nparams, params + 1);
}
gimp_destroy_params(params, self->nparams);
if (!ret) {
PyErr_SetString(pygimp_error, "no status returned");
#if PG_DEBUG >= 1
g_printerr("ret == NULL\n");
#endif
return NULL;
}
switch(ret[0].data.d_status) {
case GIMP_PDB_EXECUTION_ERROR:
#if PG_DEBUG > 0
g_printerr("execution error\n");
#endif
gimp_destroy_params(ret, nret);
PyErr_SetString(PyExc_RuntimeError, "execution error");
return NULL;
break;
case GIMP_PDB_CALLING_ERROR:
#if PG_DEBUG > 0
g_printerr("calling error\n");
#endif
gimp_destroy_params(ret, nret);
PyErr_SetString(PyExc_TypeError, "invalid arguments");
return NULL;
break;
case GIMP_PDB_SUCCESS:
#if PG_DEBUG > 0
g_printerr("success\n");
#endif
t = pygimp_param_to_tuple(nret-1, ret+1);
gimp_destroy_params(ret, nret);
if (t == NULL) {
PyErr_SetString(pygimp_error, "could not make return value");
return NULL;
}
break;
default:
#if PG_DEBUG > 0
g_printerr("unknown - %i (type %i)\n",
ret[0].data.d_status, ret[0].type);
#endif
PyErr_SetString(pygimp_error, "unknown return code");
return NULL;
break;
}
if (PyTuple_Size(t) == 1) {
r = PyTuple_GetItem(t, 0);
Py_INCREF(r);
Py_DECREF(t);
return r;
}
if (PyTuple_Size(t) == 0) {
r = Py_None;
Py_INCREF(r);
Py_DECREF(t);
return r;
}
return t;
}
/**
* 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;
}