diff options
Diffstat (limited to '')
| -rw-r--r-- | plug-ins/pygimp/pygimp-tile.c | 1046 |
1 files changed, 1046 insertions, 0 deletions
diff --git a/plug-ins/pygimp/pygimp-tile.c b/plug-ins/pygimp/pygimp-tile.c new file mode 100644 index 0000000..b4f3722 --- /dev/null +++ b/plug-ins/pygimp/pygimp-tile.c @@ -0,0 +1,1046 @@ +/* -*- Mode: C; c-basic-offset: 4 -*- + * Gimp-Python - allows the writing of Gimp plugins in Python. + * Copyright (C) 1997-2002 James Henstridge <james@daa.com.au> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <https://www.gnu.org/licenses/>. + */ + +#ifdef HAVE_CONFIG_H +# include <config.h> +#endif + +#define GIMP_DISABLE_DEPRECATION_WARNINGS + +#include "pygimp.h" + +#define NO_IMPORT_PYGIMPCOLOR +#include "pygimpcolor-api.h" + +#include <structmember.h> + +static PyObject * +tile_flush(PyGimpTile *self, PyObject *args) +{ + if (!PyArg_ParseTuple(args, ":flush")) + return NULL; + + gimp_tile_flush(self->tile); + + Py_INCREF(Py_None); + return Py_None; +} + + +static PyMethodDef tile_methods[] = { + {"flush", (PyCFunction)tile_flush, METH_VARARGS}, + {NULL, NULL} /* sentinel */ +}; + +/* ---------- */ + + +PyObject * +pygimp_tile_new(GimpTile *t, PyGimpDrawable *drw) +{ + PyGimpTile *self; + + self = PyObject_NEW(PyGimpTile, &PyGimpTile_Type); + + if (self == NULL) + return NULL; + + gimp_tile_ref(t); + + self->tile = t; + + Py_INCREF(drw); + self->drawable = drw; + + return (PyObject *)self; +} + + +static void +tile_dealloc(PyGimpTile *self) +{ + gimp_tile_unref(self->tile, FALSE); + + Py_DECREF(self->drawable); + PyObject_DEL(self); +} + +static PyObject * +tile_get_uint_field(PyGimpTile *self, void *closure) +{ + gint offset = GPOINTER_TO_INT(closure); + guint value; + gchar *addr; + + addr = (gchar *)self->tile; + addr += offset; + value = *(guint *)addr; + + return PyInt_FromLong(value); +} + +static PyObject * +tile_get_dirty(PyGimpTile *self, void *closure) +{ + return PyBool_FromLong(self->tile->dirty); +} + +static PyObject * +tile_get_shadow(PyGimpTile *self, void *closure) +{ + return PyBool_FromLong(self->tile->shadow); +} + +static PyObject * +tile_get_drawable(PyGimpTile *self, void *closure) +{ + return pygimp_drawable_new(self->tile->drawable, 0); +} + + +#define OFF(x) GINT_TO_POINTER(offsetof(GimpTile, x)) +static PyGetSetDef tile_getsets[] = { + { "ewidth", (getter)tile_get_uint_field, 0, NULL, OFF(ewidth) }, + { "eheight", (getter)tile_get_uint_field, 0, NULL, OFF(eheight) }, + { "bpp", (getter)tile_get_uint_field, 0, NULL, OFF(bpp) }, + { "tile_num", (getter)tile_get_uint_field, 0, NULL, OFF(tile_num) }, + { "dirty", (getter)tile_get_dirty, 0, NULL }, + { "shadow", (getter)tile_get_shadow, 0, NULL }, + { "drawable", (getter)tile_get_drawable, 0, NULL }, + { NULL, (getter)0, (setter)0 } +}; +#undef OFF + +static PyObject * +tile_repr(PyGimpTile *self) +{ + PyObject *s; + gchar *name; + + name = gimp_item_get_name(self->tile->drawable->drawable_id); + + if (self->tile->shadow) + s = PyString_FromFormat("<gimp.Tile for drawable '%s' (shadow)>", name); + else + s = PyString_FromFormat("<gimp.Tile for drawable '%s'>", name); + + g_free(name); + + return s; +} + +static Py_ssize_t +tile_length(PyObject *self) +{ + return ((PyGimpTile*)self)->tile->ewidth * ((PyGimpTile*)self)->tile->eheight; +} + +static PyObject * +tile_subscript(PyGimpTile *self, PyObject *sub) +{ + GimpTile *tile = self->tile; + int bpp = tile->bpp; + long x, y; + + if (PyInt_Check(sub)) { + x = PyInt_AsLong(sub); + + if (x < 0 || x >= tile->ewidth * tile->eheight) { + PyErr_SetString(PyExc_IndexError, "index out of range"); + return NULL; + } + + return PyString_FromStringAndSize + ((char *)tile->data + bpp * x, bpp); + } + + if (PyTuple_Check(sub)) { + if (!PyArg_ParseTuple(sub, "ll", &x, &y)) + return NULL; + + if (x < 0 || y < 0 || x >= tile->ewidth || y>=tile->eheight) { + PyErr_SetString(PyExc_IndexError, "index out of range"); + return NULL; + } + + return PyString_FromStringAndSize + ((char *)tile->data + bpp * (x + y * tile->ewidth), bpp); + } + + PyErr_SetString(PyExc_TypeError, "tile subscript not int or 2-tuple"); + return NULL; +} + +static int +tile_ass_sub(PyGimpTile *self, PyObject *v, PyObject *w) +{ + GimpTile *tile = self->tile; + int bpp = tile->bpp, i; + long x, y; + guchar *pix, *data; + + if (w == NULL) { + PyErr_SetString(PyExc_TypeError, + "can not delete pixels in tile"); + return -1; + } + + if (!PyString_Check(w) && PyString_Size(w) == bpp) { + PyErr_SetString(PyExc_TypeError, "invalid subscript"); + return -1; + } + + pix = (guchar *)PyString_AsString(w); + + if (PyInt_Check(v)) { + x = PyInt_AsLong(v); + + if (x < 0 || x >= tile->ewidth * tile->eheight) { + PyErr_SetString(PyExc_IndexError, "index out of range"); + return -1; + } + + data = tile->data + x * bpp; + + for (i = 0; i < bpp; i++) + data[i] = pix[i]; + + tile->dirty = TRUE; + + return 0; + } + + if (PyTuple_Check(v)) { + if (!PyArg_ParseTuple(v, "ll", &x, &y)) + return -1; + + if (x < 0 || y < 0 || x >= tile->ewidth || y>=tile->eheight) { + PyErr_SetString(PyExc_IndexError, "index out of range"); + return -1; + } + + data = tile->data + bpp * (x + y * tile->ewidth); + + for (i = 0; i < bpp; i++) + data[i] = pix[i]; + + tile->dirty = TRUE; + + return 0; + } + + PyErr_SetString(PyExc_TypeError, "tile subscript not int or 2-tuple"); + return -1; +} + +static PyMappingMethods tile_as_mapping = { + tile_length, /*length*/ + (binaryfunc)tile_subscript, /*subscript*/ + (objobjargproc)tile_ass_sub, /*ass_sub*/ +}; + +PyTypeObject PyGimpTile_Type = { + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ + "gimp.Tile", /* tp_name */ + sizeof(PyGimpTile), /* tp_basicsize */ + 0, /* tp_itemsize */ + /* methods */ + (destructor)tile_dealloc, /* tp_dealloc */ + (printfunc)0, /* tp_print */ + (getattrfunc)0, /* tp_getattr */ + (setattrfunc)0, /* tp_setattr */ + (cmpfunc)0, /* tp_compare */ + (reprfunc)tile_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + &tile_as_mapping, /* tp_as_mapping */ + (hashfunc)0, /* tp_hash */ + (ternaryfunc)0, /* tp_call */ + (reprfunc)0, /* tp_str */ + (getattrofunc)0, /* tp_getattro */ + (setattrofunc)0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT, /* tp_flags */ + NULL, /* Documentation string */ + (traverseproc)0, /* tp_traverse */ + (inquiry)0, /* tp_clear */ + (richcmpfunc)0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + (getiterfunc)0, /* tp_iter */ + (iternextfunc)0, /* tp_iternext */ + tile_methods, /* tp_methods */ + 0, /* tp_members */ + tile_getsets, /* tp_getset */ + (PyTypeObject *)0, /* tp_base */ + (PyObject *)0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc)0, /* tp_init */ + (allocfunc)0, /* tp_alloc */ + (newfunc)0, /* tp_new */ +}; + +/* End of code for Tile objects */ +/* -------------------------------------------------------- */ + + +static PyObject * +pr_resize(PyGimpPixelRgn *self, PyObject *args) +{ + int x, y, w, h; + + if (!PyArg_ParseTuple(args, "iiii:resize", &x, &y, &w, &h)) + return NULL; + + gimp_pixel_rgn_resize(&(self->pr), x, y, w, h); + + Py_INCREF(Py_None); + return Py_None; +} + + + +static PyMethodDef pr_methods[] = { + {"resize", (PyCFunction)pr_resize, METH_VARARGS}, + + {NULL, NULL} /* sentinel */ +}; + +/* ---------- */ + + +PyObject * +pygimp_pixel_rgn_new(PyGimpDrawable *drawable, int x, int y, + int width, int height, int dirty, int shadow) +{ + PyGimpPixelRgn *self; + int drw_width; + int drw_height; + + self = PyObject_NEW(PyGimpPixelRgn, &PyGimpPixelRgn_Type); + + if (self == NULL || drawable == NULL) + return NULL; + + drw_width = gimp_drawable_width(drawable->ID); + drw_height = gimp_drawable_height(drawable->ID); + + if(x < 0) x = 0; + if(y < 0) y = 0; + if(width < 0) width = drw_width - x; + if(height < 0) height = drw_height - y; + if(x >= drw_width) x = drw_width - 1; + if(y >= drw_height) y = drw_height - 1; + if(x + width > drw_width) width = drw_width - x; + if(y + height > drw_height) height = drw_height - y; + + gimp_pixel_rgn_init(&(self->pr), drawable->drawable, x, y, width, height, + dirty, shadow); + + self->drawable = drawable; + Py_INCREF(drawable); + + return (PyObject *)self; +} + + +static void +pr_dealloc(PyGimpPixelRgn *self) +{ + Py_DECREF(self->drawable); + PyObject_DEL(self); +} + +/* Code to access pr objects as mappings */ + +static Py_ssize_t +pr_length(PyObject *self) +{ + PyErr_SetString(pygimp_error, "Can't get size of pixel region"); + return -1; +} + +static PyObject * +pr_subscript(PyGimpPixelRgn *self, PyObject *key) +{ + GimpPixelRgn *pr = &(self->pr); + PyObject *x, *y; + Py_ssize_t x1, y1, x2, y2, xs, ys; + PyObject *ret; + + if (!PyTuple_Check(key) || PyTuple_Size(key) != 2) { + PyErr_SetString(PyExc_TypeError, "subscript must be a 2-tuple"); + return NULL; + } + + if (!PyArg_ParseTuple(key, "OO", &x, &y)) + return NULL; + + if (PyInt_Check(x)) { + x1 = PyInt_AsSsize_t(x); + + if (x1 < pr->x || x1 >= pr->x + pr->w) { + PyErr_SetString(PyExc_IndexError, "x subscript out of range"); + return NULL; + } + + if (PyInt_Check(y)) { + y1 = PyInt_AsSsize_t(y); + + if (y1 < pr->y || y1 >= pr->y + pr->h) { + PyErr_SetString(PyExc_IndexError, "y subscript out of range"); + return NULL; + } + + ret = PyString_FromStringAndSize(NULL, pr->bpp); + gimp_pixel_rgn_get_pixel(pr, (guchar*)PyString_AS_STRING(ret), + x1, y1); + + } else if (PySlice_Check(y)) { + if (PySlice_GetIndices((PySliceObject*)y, pr->y + pr->h, + &y1, &y2, &ys) || + y1 >= y2 || ys != 1) { + PyErr_SetString(PyExc_IndexError, "invalid y slice"); + return NULL; + } + + if(y1 == 0) + y1 = pr->y; + + if(y1 < pr->y || y2 < pr->y) { + PyErr_SetString(PyExc_IndexError, "y subscript out of range"); + return NULL; + } + + ret = PyString_FromStringAndSize(NULL, pr->bpp * (y2 - y1)); + gimp_pixel_rgn_get_col(pr, (guchar*)PyString_AS_STRING(ret), + x1, y1, y2-y1); + } + else { + PyErr_SetString(PyExc_TypeError, "invalid y subscript"); + return NULL; + } + } else if (PySlice_Check(x)) { + if (PySlice_GetIndices((PySliceObject *)x, pr->x + pr->w, + &x1, &x2, &xs) || + x1 >= x2 || xs != 1) { + PyErr_SetString(PyExc_IndexError, "invalid x slice"); + return NULL; + } + if (x1 == 0) + x1 = pr->x; + if(x1 < pr->x || x2 < pr->x) { + PyErr_SetString(PyExc_IndexError, "x subscript out of range"); + return NULL; + } + + if (PyInt_Check(y)) { + y1 = PyInt_AsSsize_t(y); + if (y1 < pr->y || y1 >= pr->y + pr->h) { + PyErr_SetString(PyExc_IndexError, "y subscript out of range"); + return NULL; + } + ret = PyString_FromStringAndSize(NULL, pr->bpp * (x2 - x1)); + gimp_pixel_rgn_get_row(pr, (guchar*)PyString_AS_STRING(ret), + x1, y1, x2 - x1); + + } else if (PySlice_Check(y)) { + if (PySlice_GetIndices((PySliceObject*)y, pr->y + pr->h, + &y1, &y2, &ys) || + y1 >= y2 || ys != 1) { + PyErr_SetString(PyExc_IndexError, "invalid y slice"); + return NULL; + } + + if(y1 == 0) + y1 = pr->y; + if(y1 < pr->y || y2 < pr->y) { + PyErr_SetString(PyExc_IndexError, "y subscript out of range"); + return NULL; + } + + ret = PyString_FromStringAndSize(NULL, + pr->bpp * (x2 - x1) * (y2 - y1)); + gimp_pixel_rgn_get_rect(pr, (guchar*)PyString_AS_STRING(ret), + x1, y1, x2 - x1, y2 - y1); + } + else { + PyErr_SetString(PyExc_TypeError, "invalid y subscript"); + return NULL; + } + + } else { + PyErr_SetString(PyExc_TypeError, "invalid x subscript"); + return NULL; + } + return ret; +} + +static int +pr_ass_sub(PyGimpPixelRgn *self, PyObject *v, PyObject *w) +{ + GimpPixelRgn *pr = &(self->pr); + PyObject *x, *y; + const guchar *buf; + Py_ssize_t len, x1, x2, xs, y1, y2, ys; + + if (w == NULL) { + PyErr_SetString(PyExc_TypeError, "can't delete subscripts"); + return -1; + } + + if (!PyString_Check(w)) { + PyErr_SetString(PyExc_TypeError, "must assign string to subscript"); + return -1; + } + + if (!PyTuple_Check(v) || PyTuple_Size(v) != 2) { + PyErr_SetString(PyExc_TypeError, "subscript must be a 2-tuple"); + return -1; + } + + if (!PyArg_ParseTuple(v, "OO", &x, &y)) + return -1; + + buf = (const guchar *)PyString_AsString(w); + len = PyString_Size(w); + if (!buf || len > INT_MAX) { + return -1; + } + + if (PyInt_Check(x)) { + x1 = PyInt_AsSsize_t(x); + if (x1 < pr->x || x1 >= pr->x + pr->w) { + PyErr_SetString(PyExc_IndexError, "x subscript out of range"); + return -1; + } + + if (PyInt_Check(y)) { + y1 = PyInt_AsSsize_t(y); + + if (y1 < pr->y || y1 >= pr->y + pr->h) { + PyErr_SetString(PyExc_IndexError, "y subscript out of range"); + return -1; + } + + if (len != pr->bpp) { + PyErr_SetString(PyExc_TypeError, "string is wrong length"); + return -1; + } + gimp_pixel_rgn_set_pixel(pr, buf, x1, y1); + + } else if (PySlice_Check(y)) { + if (PySlice_GetIndices((PySliceObject *)y, pr->y + pr->h, + &y1, &y2, &ys) || + y1 >= y2 || ys != 1) { + PyErr_SetString(PyExc_IndexError, "invalid y slice"); + return -1; + } + if (y1 == 0) + y1 = pr->y; + + if(y1 < pr->y || y2 < pr->y) { + PyErr_SetString(PyExc_IndexError, "y subscript out of range"); + return -1; + } + if (len != pr->bpp * (y2 - y1)) { + PyErr_SetString(PyExc_TypeError, "string is wrong length"); + return -1; + } + gimp_pixel_rgn_set_col(pr, buf, x1, y1, y2 - y1); + + } else { + PyErr_SetString(PyExc_IndexError,"invalid y subscript"); + return -1; + } + } else if (PySlice_Check(x)) { + if (PySlice_GetIndices((PySliceObject *)x, pr->x + pr->w, + &x1, &x2, &xs) || + x1 >= x2 || xs != 1) { + PyErr_SetString(PyExc_IndexError, "invalid x slice"); + return -1; + } + if(x1 == 0) + x1 = pr->x; + + if(x1 < pr->x || x2 < pr->x) { + PyErr_SetString(PyExc_IndexError, "x subscript out of range"); + return -1; + } + + if (PyInt_Check(y)) { + y1 = PyInt_AsSsize_t(y); + + if (y1 < pr->y || y1 >= pr->y + pr->h) { + PyErr_SetString(PyExc_IndexError, "y subscript out of range"); + return -1; + } + + if (len != pr->bpp * (x2 - x1)) { + PyErr_SetString(PyExc_TypeError, "string is wrong length"); + return -1; + } + gimp_pixel_rgn_set_row(pr, buf, x1, y1, x2 - x1); + + } else if (PySlice_Check(y)) { + if (PySlice_GetIndices((PySliceObject *)y, pr->y + pr->h, + &y1, &y2, &ys) || + y1 >= y2 || ys != 1) { + PyErr_SetString(PyExc_IndexError, "invalid y slice"); + return -1; + } + if (y1 == 0) + y1 = pr->y; + + if(y1 < pr->y || y2 < pr->y) { + PyErr_SetString(PyExc_IndexError, "y subscript out of range"); + return -1; + } + if (len != pr->bpp * (x2 - x1) * (y2 - y1)) { + PyErr_SetString(PyExc_TypeError, "string is wrong length"); + return -1; + } + gimp_pixel_rgn_set_rect(pr, buf, x1, y1, x2 - x1, y2 - y1); + + } else { + PyErr_SetString(PyExc_IndexError,"invalid y subscript"); + return -1; + } + } else { + PyErr_SetString(PyExc_TypeError, "invalid x subscript"); + return -1; + } + return 0; +} + +static PyMappingMethods pr_as_mapping = { + pr_length, /*mp_length*/ + (binaryfunc)pr_subscript, /*mp_subscript*/ + (objobjargproc)pr_ass_sub, /*mp_ass_subscript*/ +}; + +/* -------------------------------------------------------- */ + +static PyObject * +pr_get_drawable(PyGimpPixelRgn *self, void *closure) +{ + return pygimp_drawable_new(self->pr.drawable, 0); +} + +static PyObject * +pr_get_uint_field(PyGimpPixelRgn *self, void *closure) +{ + gint offset = GPOINTER_TO_INT(closure); + guint value; + gchar *addr; + + addr = (gchar *)&self->pr; + addr += offset; + value = *(guint *)addr; + + return PyInt_FromLong(value); +} + +static PyObject * +pr_get_dirty(PyGimpPixelRgn *self, void *closure) +{ + return PyBool_FromLong(self->pr.dirty); +} + +static PyObject * +pr_get_shadow(PyGimpPixelRgn *self, void *closure) +{ + return PyBool_FromLong(self->pr.shadow); +} + +#define OFF(x) GINT_TO_POINTER(offsetof(GimpPixelRgn, x)) +static PyGetSetDef pr_getsets[] = { + { "drawable", (getter)pr_get_drawable, 0, NULL }, + { "bpp", (getter)pr_get_uint_field, 0, NULL, OFF(bpp) }, + { "rowstride", (getter)pr_get_uint_field, 0, NULL, OFF(rowstride) }, + { "x", (getter)pr_get_uint_field, 0, NULL, OFF(x) }, + { "y", (getter)pr_get_uint_field, 0, NULL, OFF(y) }, + { "w", (getter)pr_get_uint_field, 0, NULL, OFF(w) }, + { "h", (getter)pr_get_uint_field, 0, NULL, OFF(h) }, + { "dirty", (getter)pr_get_dirty, 0, NULL }, + { "shadow", (getter)pr_get_shadow, 0, NULL }, + { NULL, (getter)0, (setter)0 }, +}; +#undef OFF + +static PyObject * +pr_repr(PyGimpPixelRgn *self) +{ + PyObject *s; + gchar *name; + + name = gimp_item_get_name(self->drawable->drawable->drawable_id); + s = PyString_FromFormat("<gimp.PixelRgn for drawable '%s'>", name); + g_free(name); + + return s; +} + +PyTypeObject PyGimpPixelRgn_Type = { + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ + "gimp.PixelRgn", /* tp_name */ + sizeof(PyGimpPixelRgn), /* tp_basicsize */ + 0, /* tp_itemsize */ + /* methods */ + (destructor)pr_dealloc, /* tp_dealloc */ + (printfunc)0, /* tp_print */ + (getattrfunc)0, /* tp_getattr */ + (setattrfunc)0, /* tp_setattr */ + (cmpfunc)0, /* tp_compare */ + (reprfunc)pr_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + &pr_as_mapping, /* tp_as_mapping */ + (hashfunc)0, /* tp_hash */ + (ternaryfunc)0, /* tp_call */ + (reprfunc)0, /* tp_str */ + (getattrofunc)0, /* tp_getattro */ + (setattrofunc)0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT, /* tp_flags */ + NULL, /* Documentation string */ + (traverseproc)0, /* tp_traverse */ + (inquiry)0, /* tp_clear */ + (richcmpfunc)0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + (getiterfunc)0, /* tp_iter */ + (iternextfunc)0, /* tp_iternext */ + pr_methods, /* tp_methods */ + 0, /* tp_members */ + pr_getsets, /* tp_getset */ + (PyTypeObject *)0, /* tp_base */ + (PyObject *)0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc)0, /* tp_init */ + (allocfunc)0, /* tp_alloc */ + (newfunc)0, /* tp_new */ +}; + +static PyObject * +pf_get_pixel(PyGimpPixelFetcher *self, PyObject *args, PyObject *kwargs) +{ + int x, y; + guchar pixel[4]; + static char *kwlist[] = { "x", "y", NULL }; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, + "ii:get_pixel", kwlist, + &x, &y)) + return NULL; + + gimp_pixel_fetcher_get_pixel(self->pf, x, y, pixel); + + return PyString_FromStringAndSize((char *)pixel, self->bpp); +} + +static PyObject * +pf_put_pixel(PyGimpPixelFetcher *self, PyObject *args, PyObject *kwargs) +{ + int x, y, len; + guchar *pixel; + static char *kwlist[] = { "x", "y", "pixel", NULL }; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, + "iis#:put_pixel", kwlist, + &x, &y, &pixel, &len)) + return NULL; + + if (len != self->bpp) { + PyErr_Format(PyExc_TypeError, "pixel must be %d bpp", self->bpp); + return NULL; + } + + gimp_pixel_fetcher_put_pixel(self->pf, x, y, pixel); + + Py_INCREF(Py_None); + return Py_None; +} + +static PyMethodDef pf_methods[] = { + {"get_pixel", (PyCFunction)pf_get_pixel, METH_VARARGS | METH_KEYWORDS}, + {"put_pixel", (PyCFunction)pf_put_pixel, METH_VARARGS | METH_KEYWORDS}, + {NULL, NULL} +}; + +static int +pf_length(PyGimpPixelFetcher *self) +{ + PyErr_SetString(pygimp_error, "Can't get size of pixel fetcher"); + return -1; +} + +static PyObject * +pf_subscript(PyGimpPixelFetcher *self, PyObject *key) +{ + PyObject *py_x, *py_y; + int x, y; + guchar pixel[4]; + + if (!PyTuple_Check(key) || PyTuple_Size(key) != 2) { + PyErr_SetString(PyExc_TypeError, "subscript must be a 2-tuple"); + return NULL; + } + + if (!PyArg_ParseTuple(key, "OO", &py_x, &py_y)) + return NULL; + + if (PyInt_Check(py_x)) { + if (PyInt_Check(py_y)) { + x = PyInt_AsLong(py_x); + y = PyInt_AsLong(py_y); + + gimp_pixel_fetcher_get_pixel(self->pf, x, y, pixel); + return PyString_FromStringAndSize((char *)pixel, self->bpp); + } else { + PyErr_SetString(PyExc_TypeError, "invalid y subscript"); + return NULL; + } + } else { + PyErr_SetString(PyExc_TypeError, "invalid x subscript"); + return NULL; + } +} + +static int +pf_ass_sub(PyGimpPixelFetcher *self, PyObject *v, PyObject *w) +{ + PyObject *py_x, *py_y; + int x, y, len; + guchar *pixel; + + if (w == NULL) { + PyErr_SetString(PyExc_TypeError, "can't delete subscripts"); + return -1; + } + + if (!PyString_Check(w)) { + PyErr_SetString(PyExc_TypeError, "must assign string to subscript"); + return -1; + } + + if (!PyTuple_Check(v) || PyTuple_Size(v) != 2) { + PyErr_SetString(PyExc_TypeError, "subscript must be a 2-tuple"); + return -1; + } + + if (!PyArg_ParseTuple(v, "OO", &py_x, &py_y)) + return -1; + + pixel = (guchar *)PyString_AsString(w); + len = PyString_Size(w); + + if (len != self->bpp) { + PyErr_Format(PyExc_TypeError, "pixel must be %d bpp", self->bpp); + return -1; + } + + if (PyInt_Check(py_x)) { + if (PyInt_Check(py_y)) { + x = PyInt_AsLong(py_x); + y = PyInt_AsLong(py_y); + + gimp_pixel_fetcher_put_pixel(self->pf, x, y, pixel); + return 0; + } else { + PyErr_SetString(PyExc_TypeError, "invalid y subscript"); + return -1; + } + } else { + PyErr_SetString(PyExc_TypeError, "invalid x subscript"); + return -1; + } +} + +static PyMappingMethods pf_as_mapping = { + (lenfunc)pf_length, + (binaryfunc)pf_subscript, + (objobjargproc)pf_ass_sub, +}; + +static PyObject * +pf_get_bg_color(PyGimpPixelFetcher *self, void *closure) +{ + return pygimp_rgb_new(&self->bg_color); +} + +static int +pf_set_bg_color(PyGimpPixelFetcher *self, PyObject *value, void *closure) +{ + if (value == NULL) { + PyErr_SetString(PyExc_TypeError, "cannot delete bg_color"); + return -1; + } + + if (!pygimp_rgb_from_pyobject(value, &self->bg_color)) + return -1; + + gimp_pixel_fetcher_set_bg_color(self->pf, &self->bg_color); + + return 0; +} + +static PyObject * +pf_get_edge_mode(PyGimpPixelFetcher *self, void *closure) +{ + return PyInt_FromLong(self->edge_mode); +} + +static int +pf_set_edge_mode(PyGimpPixelFetcher *self, PyObject *value, void *closure) +{ + if (value == NULL) { + PyErr_SetString(PyExc_TypeError, "cannot delete edge_mode"); + return -1; + } + + if (!PyInt_Check(value)) { + PyErr_SetString(PyExc_TypeError, "type mismatch"); + return -1; + } + + self->edge_mode = PyInt_AsLong(value); + + gimp_pixel_fetcher_set_edge_mode(self->pf, self->edge_mode); + + return 0; +} + +static PyGetSetDef pf_getsets[] = { + { "bg_color", (getter)pf_get_bg_color, (setter)pf_set_bg_color }, + { "edge_mode", (getter)pf_get_edge_mode, (setter)pf_set_edge_mode }, + { NULL, (getter)0, (setter)0 } +}; + +static void +pf_dealloc(PyGimpPixelFetcher *self) +{ + gimp_pixel_fetcher_destroy(self->pf); + + Py_XDECREF(self->drawable); + + PyObject_DEL(self); +} + +static PyObject * +pf_repr(PyGimpPixelFetcher *self) +{ + PyObject *s; + char *name; + + name = gimp_item_get_name(self->drawable->drawable->drawable_id); + + if (self->shadow) + s = PyString_FromFormat("<gimp.PixelFetcher for drawable '%s' (shadow)>", name); + else + s = PyString_FromFormat("<gimp.PixelFetcher for drawable '%s'>", name); + + g_free(name); + + return s; +} + +static int +pf_init(PyGimpPixelFetcher *self, PyObject *args, PyObject *kwargs) +{ + PyGimpDrawable *drw; + gboolean shadow = FALSE; + GimpRGB bg_color = { 0.0, 0.0, 0.0, 1.0 }; + GimpPixelFetcherEdgeMode edge_mode = GIMP_PIXEL_FETCHER_EDGE_NONE; + static char *kwlist[] = { "drawable", "shadow", "bg_color", "edge_mode", + NULL }; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, + "O!|iO&i:gimp.PixelFetcher.__init__", + kwlist, + &PyGimpDrawable_Type, &drw, &shadow, + pygimp_rgb_from_pyobject, &bg_color, + &edge_mode)) + return -1; + + if(!drw->drawable) + drw->drawable = gimp_drawable_get(drw->ID); + + self->pf = gimp_pixel_fetcher_new(drw->drawable, shadow); + + Py_INCREF(drw); + self->drawable = drw; + + self->shadow = shadow; + self->bg_color = bg_color; + self->edge_mode = edge_mode; + + self->bpp = gimp_drawable_bpp(drw->drawable->drawable_id); + + gimp_pixel_fetcher_set_bg_color(self->pf, &bg_color); + gimp_pixel_fetcher_set_edge_mode(self->pf, edge_mode); + + return 0; +} + +PyTypeObject PyGimpPixelFetcher_Type = { + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ + "gimp.PixelFetcher", /* tp_name */ + sizeof(PyGimpPixelFetcher), /* tp_basicsize */ + 0, /* tp_itemsize */ + /* methods */ + (destructor)pf_dealloc, /* tp_dealloc */ + (printfunc)0, /* tp_print */ + (getattrfunc)0, /* tp_getattr */ + (setattrfunc)0, /* tp_setattr */ + (cmpfunc)0, /* tp_compare */ + (reprfunc)pf_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + &pf_as_mapping, /* tp_as_mapping */ + (hashfunc)0, /* tp_hash */ + (ternaryfunc)0, /* tp_call */ + (reprfunc)0, /* tp_str */ + (getattrofunc)0, /* tp_getattro */ + (setattrofunc)0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT, /* tp_flags */ + NULL, /* Documentation string */ + (traverseproc)0, /* tp_traverse */ + (inquiry)0, /* tp_clear */ + (richcmpfunc)0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + (getiterfunc)0, /* tp_iter */ + (iternextfunc)0, /* tp_iternext */ + pf_methods, /* tp_methods */ + 0, /* tp_members */ + pf_getsets, /* tp_getset */ + (PyTypeObject *)0, /* tp_base */ + (PyObject *)0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc)pf_init, /* tp_init */ + (allocfunc)0, /* tp_alloc */ + (newfunc)0, /* tp_new */ +}; |