p96705831
/
gimp
forked from openkylin/gimp
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
gimp/plug-ins/pygimp/pygimp-vectors.c

993 lines
30 KiB
C
Raw Permalink Blame History

/* -*- Mode: C; c-basic-offset: 4 -*-
* Gimp-Python - allows the writing of Gimp plugins in Python.
* Copyright (C) 2006 Manish Singh <yosh@gimp.org>
*
* 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
#include "pygimp.h"
static PyObject *vectors_bezier_stroke_new(PyGimpVectors *vectors, int stroke);
typedef struct {
PyObject_HEAD
gint32 vectors_ID;
int stroke;
} PyGimpVectorsStroke;
static PyObject *
vs_get_length(PyGimpVectorsStroke *self, PyObject *args, PyObject *kwargs)
{
double precision;
double length;
static char *kwlist[] = { "precision", NULL };
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "d:get_length", kwlist,
&precision))
return NULL;
length = gimp_vectors_stroke_get_length(self->vectors_ID, self->stroke,
precision);
return PyFloat_FromDouble(length);
}
static PyObject *
vs_get_point_at_dist(PyGimpVectorsStroke *self, PyObject *args, PyObject *kwargs)
{
double dist, precision;
double x, y, slope;
gboolean valid;
PyObject *ret;
static char *kwlist[] = { "dist", "precision", NULL };
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
"dd:get_point_at_dist", kwlist,
&dist, &precision))
return NULL;
gimp_vectors_stroke_get_point_at_dist(self->vectors_ID, self->stroke,
dist, precision,
&x, &y, &slope, &valid);
ret = PyTuple_New(4);
if (ret == NULL)
return NULL;
PyTuple_SetItem(ret, 0, PyFloat_FromDouble(x));
PyTuple_SetItem(ret, 1, PyFloat_FromDouble(y));
PyTuple_SetItem(ret, 2, PyFloat_FromDouble(slope));
PyTuple_SetItem(ret, 3, PyBool_FromLong(valid));
return ret;
}
static PyObject *
vs_close(PyGimpVectorsStroke *self)
{
gimp_vectors_stroke_close(self->vectors_ID, self->stroke);
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
vs_translate(PyGimpVectorsStroke *self, PyObject *args, PyObject *kwargs)
{
double off_x, off_y;
static char *kwlist[] = { "off_x", "off_y", NULL };
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "dd:translate", kwlist,
&off_x, &off_y))
return NULL;
gimp_vectors_stroke_translate(self->vectors_ID, self->stroke, off_x, off_y);
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
vs_scale(PyGimpVectorsStroke *self, PyObject *args, PyObject *kwargs)
{
double scale_x, scale_y;
static char *kwlist[] = { "scale_x", "scale_y", NULL };
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "dd:scale", kwlist,
&scale_x, &scale_y))
return NULL;
gimp_vectors_stroke_scale(self->vectors_ID, self->stroke, scale_x, scale_y);
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
vs_rotate(PyGimpVectorsStroke *self, PyObject *args, PyObject *kwargs)
{
double center_x, center_y, angle;
static char *kwlist[] = { "center_x", "center_y", "angle", NULL };
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ddd:rotate", kwlist,
&center_x, &center_y, &angle))
return NULL;
gimp_vectors_stroke_rotate(self->vectors_ID, self->stroke, center_x,
center_y, angle);
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
vs_flip(PyGimpVectorsStroke *self, PyObject *args, PyObject *kwargs)
{
int flip_type;
double axis;
static char *kwlist[] = { "flip_type", "axis", NULL };
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "id:flip", kwlist,
&flip_type, &axis))
return NULL;
gimp_vectors_stroke_flip(self->vectors_ID, self->stroke, flip_type, axis);
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
vs_flip_free(PyGimpVectorsStroke *self, PyObject *args, PyObject *kwargs)
{
double x1,y1,x2,y2;
static char *kwlist[] = { "x1", "y1", "x2", "y2", NULL };
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "dddd:flip_free", kwlist,
&x1, &y1, &x2, &y2))
return NULL;
gimp_vectors_stroke_flip_free(self->vectors_ID, self->stroke,
x1, y1, x2, y2);
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
vs_interpolate(PyGimpVectorsStroke *self, PyObject *args, PyObject *kwargs)
{
double precision;
double *coords;
int i, num_coords;
gboolean closed;
PyObject *ret, *ret_coords;
static char *kwlist[] = { "precision", NULL };
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "d:interpolate", kwlist,
&precision))
return NULL;
coords = gimp_vectors_stroke_interpolate(self->vectors_ID, self->stroke,
precision, &num_coords, &closed);
ret = PyTuple_New(2);
if (ret == NULL)
return NULL;
ret_coords = PyList_New(num_coords);
if (ret_coords == NULL) {
Py_DECREF(ret);
return NULL;
}
for (i = 0; i < num_coords; i++)
PyList_SetItem(ret_coords, i, PyFloat_FromDouble(coords[i]));
PyTuple_SetItem(ret, 0, ret_coords);
PyTuple_SetItem(ret, 1, PyBool_FromLong(closed));
return ret;
}
static PyMethodDef vs_methods[] = {
{ "get_length", (PyCFunction)vs_get_length, METH_VARARGS | METH_KEYWORDS },
{ "get_point_at_dist", (PyCFunction)vs_get_point_at_dist, METH_VARARGS | METH_KEYWORDS },
{ "close", (PyCFunction)vs_close, METH_NOARGS },
{ "translate", (PyCFunction)vs_translate, METH_VARARGS | METH_KEYWORDS },
{ "scale", (PyCFunction)vs_scale, METH_VARARGS | METH_KEYWORDS },
{ "rotate", (PyCFunction)vs_rotate, METH_VARARGS | METH_KEYWORDS },
{ "flip", (PyCFunction)vs_flip, METH_VARARGS | METH_KEYWORDS },
{ "flip_free", (PyCFunction)vs_flip_free, METH_VARARGS | METH_KEYWORDS },
{ "interpolate", (PyCFunction)vs_interpolate, METH_VARARGS | METH_KEYWORDS },
{ NULL, NULL, 0 }
};
static PyObject *
vs_get_ID(PyGimpVectorsStroke *self, void *closure)
{
return PyInt_FromLong(self->stroke);
}
static PyObject *
vs_get_vectors_ID(PyGimpVectorsStroke *self, void *closure)
{
return PyInt_FromLong(self->vectors_ID);
}
static PyObject *
vs_get_points(PyGimpVectorsStroke *self, void *closure)
{
double *controlpoints;
int i, num_points;
gboolean closed;
PyObject *ret, *ret_points;
gimp_vectors_stroke_get_points(self->vectors_ID, self->stroke,
&num_points, &controlpoints, &closed);
ret = PyTuple_New(2);
if (ret == NULL)
return NULL;
ret_points = PyList_New(num_points);
if (ret_points == NULL) {
Py_DECREF(ret);
return NULL;
}
for (i = 0; i < num_points; i++)
PyList_SetItem(ret_points, i, PyFloat_FromDouble(controlpoints[i]));
PyTuple_SetItem(ret, 0, ret_points);
PyTuple_SetItem(ret, 1, PyBool_FromLong(closed));
return ret;
}
static PyGetSetDef vs_getsets[] = {
{ "ID", (getter)vs_get_ID, (setter)0 },
{ "vectors_ID", (getter)vs_get_vectors_ID, (setter)0 },
{ "points", (getter)vs_get_points, (setter)0 },
{ NULL, (getter)0, (setter)0 }
};
static void
vs_dealloc(PyGimpVectorsStroke *self)
{
PyObject_DEL(self);
}
static PyObject *
vs_repr(PyGimpVectorsStroke *self)
{
PyObject *s;
char *name;
name = gimp_item_get_name(self->vectors_ID);
s = PyString_FromFormat("<gimp.VectorsStroke %d of gimp.Vectors '%s'>",
self->stroke, name ? name : "(null)");
g_free(name);
return s;
}
static int
vs_cmp(PyGimpVectorsStroke *self, PyGimpVectorsStroke *other)
{
if (self->vectors_ID == other->vectors_ID) {
if (self->stroke == other->stroke)
return 0;
if (self->stroke > other->stroke)
return -1;
return 1;
}
if (self->vectors_ID > other->vectors_ID)
return -1;
return 1;
}
PyTypeObject PyGimpVectorsStroke_Type = {
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
"gimp.VectorsStroke", /* tp_name */
sizeof(PyGimpVectorsStroke), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
(destructor)vs_dealloc, /* tp_dealloc */
(printfunc)0, /* tp_print */
(getattrfunc)0, /* tp_getattr */
(setattrfunc)0, /* tp_setattr */
(cmpfunc)vs_cmp, /* tp_compare */
(reprfunc)vs_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* 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 | Py_TPFLAGS_BASETYPE, /* 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 */
vs_methods, /* tp_methods */
0, /* tp_members */
vs_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 *
vbs_new_moveto(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
PyGimpVectors *vectors;
double x0, y0;
int stroke;
static char *kwlist[] = { "vectors", "x0", "y0", NULL };
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
"O!dd:new_moveto", kwlist,
&PyGimpVectors_Type, &vectors,
&x0, &y0))
return NULL;
stroke = gimp_vectors_bezier_stroke_new_moveto(vectors->ID, x0, y0);
return vectors_bezier_stroke_new(vectors, stroke);
}
static PyObject *
vbs_new_ellipse(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
PyGimpVectors *vectors;
double x0, y0, radius_x, radius_y, angle;
int stroke;
static char *kwlist[] = { "vectors", "x0", "y0", "radius_x", "radius_y",
"angle", NULL };
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
"O!ddddd:new_ellipse", kwlist,
&PyGimpVectors_Type, &vectors,
&x0, &y0, &radius_x, &radius_y, &angle))
return NULL;
stroke = gimp_vectors_bezier_stroke_new_ellipse(vectors->ID, x0, y0,
radius_x, radius_y, angle);
return vectors_bezier_stroke_new(vectors, stroke);
}
static PyObject *
vbs_lineto(PyGimpVectorsStroke *self, PyObject *args, PyObject *kwargs)
{
double x0, y0;
static char *kwlist[] = { "x0", "y0", NULL };
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
"dd:lineto", kwlist,
&x0, &y0))
return NULL;
gimp_vectors_bezier_stroke_lineto(self->vectors_ID, self->stroke, x0, y0);
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
vbs_conicto(PyGimpVectorsStroke *self, PyObject *args, PyObject *kwargs)
{
double x0, y0, x1, y1;
static char *kwlist[] = { "x0", "y0", "x1", "y1", NULL };
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
"dddd:conicto", kwlist,
&x0, &y0, &x1, &y1))
return NULL;
gimp_vectors_bezier_stroke_conicto(self->vectors_ID, self->stroke,
x0, y0, x1, y1);
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
vbs_cubicto(PyGimpVectorsStroke *self, PyObject *args, PyObject *kwargs)
{
double x0, y0, x1, y1, x2, y2;
static char *kwlist[] = { "x0", "y0", "x1", "y1", "x2", "y2", NULL };
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
"dddddd:cubicto", kwlist,
&x0, &y0, &x1, &y1, &x2, &y2))
return NULL;
gimp_vectors_bezier_stroke_cubicto(self->vectors_ID, self->stroke,
x0, y0, x1, y1, x2, y2);
Py_INCREF(Py_None);
return Py_None;
}
static PyMethodDef vbs_methods[] = {
{ "new_moveto", (PyCFunction)vbs_new_moveto, METH_VARARGS | METH_KEYWORDS | METH_CLASS },
{ "new_ellipse", (PyCFunction)vbs_new_ellipse, METH_VARARGS | METH_KEYWORDS | METH_CLASS },
{ "lineto", (PyCFunction)vbs_lineto, METH_VARARGS | METH_KEYWORDS },
{ "conicto", (PyCFunction)vbs_conicto, METH_VARARGS | METH_KEYWORDS },
{ "cubicto", (PyCFunction)vbs_cubicto, METH_VARARGS | METH_KEYWORDS },
{ NULL, NULL, 0 }
};
static PyObject *
vbs_repr(PyGimpVectorsStroke *self)
{
PyObject *s;
char *name;
name = gimp_item_get_name(self->vectors_ID);
s = PyString_FromFormat("<gimp.VectorsBezierStroke %d of gimp.Vectors '%s'>",
self->stroke, name ? name : "(null)");
g_free(name);
return s;
}
static int
vbs_init(PyGimpVectorsStroke *self, PyObject *args, PyObject *kwargs)
{
PyGimpVectors *vectors;
double *controlpoints;
gboolean closed = FALSE;
PyObject *py_controlpoints, *item;
int i, num_points;
static char *kwlist[] = { "vectors", "controlpoints", "closed", NULL };
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
"O!O|i:gimp.VectorsBezierStroke.__init__",
kwlist,
&PyGimpVectors_Type, &vectors,
&py_controlpoints, &closed))
return -1;
if (!PySequence_Check(py_controlpoints)) {
PyErr_SetString(PyExc_TypeError,
"controlpoints must be a sequence");
return -1;
}
num_points = PySequence_Length(py_controlpoints);
controlpoints = g_new(gdouble, num_points);
for (i = 0; i < num_points; i++) {
item = PySequence_GetItem(py_controlpoints, i);
if (!PyFloat_Check(item)) {
PyErr_SetString(PyExc_TypeError,
"controlpoints must be a sequence of floats");
g_free(controlpoints);
return -1;
}
controlpoints[i] = PyFloat_AsDouble(item);
}
self->vectors_ID = vectors->ID;
self->stroke =
gimp_vectors_stroke_new_from_points(self->vectors_ID,
GIMP_VECTORS_STROKE_TYPE_BEZIER,
num_points, controlpoints, closed);
g_free(controlpoints);
return 0;
}
PyTypeObject PyGimpVectorsBezierStroke_Type = {
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
"gimp.VectorsBezierStroke", /* tp_name */
sizeof(PyGimpVectorsStroke), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
(destructor)vs_dealloc, /* tp_dealloc */
(printfunc)0, /* tp_print */
(getattrfunc)0, /* tp_getattr */
(setattrfunc)0, /* tp_setattr */
(cmpfunc)vs_cmp, /* tp_compare */
(reprfunc)vbs_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* 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 */
vbs_methods, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
&PyGimpVectorsStroke_Type, /* tp_base */
(PyObject *)0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
(initproc)vbs_init, /* tp_init */
(allocfunc)0, /* tp_alloc */
(newfunc)0, /* tp_new */
};
static PyObject *
vectors_bezier_stroke_new(PyGimpVectors *vectors, int stroke)
{
PyGimpVectorsStroke *self;
self = PyObject_NEW(PyGimpVectorsStroke, &PyGimpVectorsBezierStroke_Type);
if (self == NULL)
return NULL;
self->vectors_ID = vectors->ID;
self->stroke = stroke;
return (PyObject *)self;
}
static PyObject *
vectors_remove_stroke(PyGimpVectors *self, PyObject *args, PyObject *kwargs)
{
int stroke_id ;
/* PyGimpVectorsStroke *stroke; */
PyObject *stroke = NULL;
static char *kwlist[] = { "stroke", NULL };
PyArg_ParseTupleAndKeywords(args, kwargs, "O:remove_stroke", kwlist, &stroke);
if (PyInt_Check(stroke))
stroke_id = PyInt_AsLong(stroke);
else if (PyObject_IsInstance(stroke, (PyObject *) &PyGimpVectorsStroke_Type))
stroke_id = ((PyGimpVectorsStroke *) stroke)->stroke;
else {
PyErr_SetString(PyExc_TypeError, "stroke must be a gimp.VectorsBezierStroke object or an Integer");
return NULL;
}
gimp_vectors_remove_stroke(self->ID, stroke_id);
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
vectors_to_selection(PyGimpVectors *self, PyObject *args, PyObject *kwargs)
{
GimpChannelOps operation = GIMP_CHANNEL_OP_REPLACE;
gboolean antialias = TRUE, feather = FALSE;
double feather_radius_x = 0.0, feather_radius_y = 0.0;
static char *kwlist[] = { "operation", "antialias", "feather",
"feather_radius_x", "feather_radius_y", NULL };
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
"|iiidd:to_selection", kwlist,
&operation, &antialias, &feather,
&feather_radius_x, &feather_radius_y))
return NULL;
gimp_context_push();
gimp_context_set_antialias(antialias);
gimp_context_set_feather(feather);
gimp_context_set_feather_radius(feather_radius_x, feather_radius_y);
gimp_image_select_item(gimp_item_get_image(self->ID), operation, self->ID);
gimp_context_pop();
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
vectors_parasite_find(PyGimpVectors *self, PyObject *args)
{
char *name;
if (!PyArg_ParseTuple(args, "s:parasite_find", &name))
return NULL;
return pygimp_parasite_new(gimp_item_get_parasite(self->ID, name));
}
static PyObject *
vectors_parasite_attach(PyGimpVectors *self, PyObject *args)
{
PyGimpParasite *parasite;
if (!PyArg_ParseTuple(args, "O!:parasite_attach", &PyGimpParasite_Type,
&parasite))
return NULL;
if (!gimp_item_attach_parasite(self->ID, parasite->para)) {
PyErr_Format(pygimp_error,
"could not attach parasite '%s' to vectors (ID %d)",
parasite->para->name, self->ID);
return NULL;
}
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
vectors_parasite_detach(PyGimpVectors *self, PyObject *args)
{
char *name;
if (!PyArg_ParseTuple(args, "s:parasite_detach", &name))
return NULL;
if (!gimp_item_detach_parasite(self->ID, name)) {
PyErr_Format(pygimp_error,
"could not detach parasite '%s' from vectors (ID %d)",
name, self->ID);
return NULL;
}
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
vectors_parasite_list(PyGimpVectors *self)
{
gint num_parasites;
gchar **parasites;
PyObject *ret;
gint i;
parasites = gimp_item_get_parasite_list(self->ID, &num_parasites);
ret = PyTuple_New(num_parasites);
for (i = 0; i < num_parasites; i++)
PyTuple_SetItem(ret, i, PyString_FromString(parasites[i]));
g_strfreev(parasites);
return ret;
}
static PyMethodDef vectors_methods[] = {
{ "remove_stroke",
(PyCFunction)vectors_remove_stroke,
METH_VARARGS | METH_KEYWORDS },
{ "to_selection",
(PyCFunction)vectors_to_selection,
METH_VARARGS | METH_KEYWORDS },
{ "parasite_find",
(PyCFunction)vectors_parasite_find,
METH_VARARGS },
{ "parasite_attach",
(PyCFunction)vectors_parasite_attach,
METH_VARARGS },
{ "parasite_detach",
(PyCFunction)vectors_parasite_detach,
METH_VARARGS },
{ "parasite_list",
(PyCFunction)vectors_parasite_list,
METH_NOARGS },
{ NULL, NULL, 0 }
};
static PyObject *
vectors_get_image(PyGimpVectors *self, void *closure)
{
return pygimp_image_new(gimp_item_get_image(self->ID));
}
static PyObject *
vectors_get_ID(PyGimpVectors *self, void *closure)
{
return PyInt_FromLong(self->ID);
}
static PyObject *
vectors_get_name(PyGimpVectors *self, void *closure)
{
return PyString_FromString(gimp_item_get_name(self->ID));
}
static int
vectors_set_name(PyGimpVectors *self, PyObject *value, void *closure)
{
if (value == NULL) {
PyErr_SetString(PyExc_TypeError, "cannot delete name");
return -1;
}
if (!PyString_Check(value) && !PyUnicode_Check(value)) {
PyErr_SetString(PyExc_TypeError, "type mismatch");
return -1;
}
gimp_item_set_name(self->ID, PyString_AsString(value));
return 0;
}
static PyObject *
vectors_get_visible(PyGimpVectors *self, void *closure)
{
return PyBool_FromLong(gimp_item_get_visible(self->ID));
}
static int
vectors_set_visible(PyGimpVectors *self, PyObject *value, void *closure)
{
if (value == NULL) {
PyErr_SetString(PyExc_TypeError, "cannot delete visible");
return -1;
}
if (!PyInt_Check(value)) {
PyErr_SetString(PyExc_TypeError, "type mismatch");
return -1;
}
gimp_item_set_visible(self->ID, PyInt_AsLong(value));
return 0;
}
static PyObject *
vectors_get_linked(PyGimpVectors *self, void *closure)
{
return PyBool_FromLong(gimp_item_get_linked(self->ID));
}
static int
vectors_set_linked(PyGimpVectors *self, PyObject *value, void *closure)
{
if (value == NULL) {
PyErr_SetString(PyExc_TypeError, "cannot delete linked");
return -1;
}
if (!PyInt_Check(value)) {
PyErr_SetString(PyExc_TypeError, "type mismatch");
return -1;
}
gimp_item_set_linked(self->ID, PyInt_AsLong(value));
return 0;
}
static PyObject *
vectors_get_tattoo(PyGimpVectors *self, void *closure)
{
return PyInt_FromLong(gimp_item_get_tattoo(self->ID));
}
static int
vectors_set_tattoo(PyGimpVectors *self, PyObject *value, void *closure)
{
if (value == NULL) {
PyErr_SetString(PyExc_TypeError, "cannot delete tattoo");
return -1;
}
if (!PyInt_Check(value)) {
PyErr_SetString(PyExc_TypeError, "type mismatch");
return -1;
}
gimp_item_set_tattoo(self->ID, PyInt_AsLong(value));
return 0;
}
static PyObject *
vectors_get_strokes(PyGimpVectors *self, void *closure)
{
int *strokes;
int i, num_strokes;
PyObject *ret;
strokes = gimp_vectors_get_strokes(self->ID, &num_strokes);
ret = PyList_New(num_strokes);
if (ret == NULL)
return NULL;
for (i = 0; i < num_strokes; i++)
PyList_SetItem(ret, i, vectors_bezier_stroke_new(self, strokes[i]));
g_free(strokes);
return ret;
}
static PyGetSetDef vectors_getsets[] = {
{ "ID", (getter)vectors_get_ID, (setter)0 },
{ "image", (getter)vectors_get_image, (setter)0 },
{ "name", (getter)vectors_get_name, (setter)vectors_set_name },
{ "visible", (getter)vectors_get_visible, (setter)vectors_set_visible },
{ "linked", (getter)vectors_get_linked, (setter)vectors_set_linked },
{ "tattoo", (getter)vectors_get_tattoo, (setter)vectors_set_tattoo },
{ "strokes", (getter)vectors_get_strokes, (setter)0 },
{ NULL, (getter)0, (setter)0 }
};
static void
vectors_dealloc(PyGimpVectors *self)
{
PyObject_DEL(self);
}
static PyObject *
vectors_repr(PyGimpVectors *self)
{
PyObject *s;
char *name;
name = gimp_item_get_name(self->ID);
s = PyString_FromFormat("<gimp.Vectors '%s'>", name ? name : "(null)");
g_free(name);
return s;
}
static int
vectors_cmp(PyGimpVectors *self, PyGimpVectors *other)
{
if (self->ID == other->ID)
return 0;
if (self->ID > other->ID)
return -1;
return 1;
}
static int
vectors_init(PyGimpVectors *self, PyObject *args, PyObject *kwargs)
{
PyGimpImage *img;
char *name;
static char *kwlist[] = { "image", "name", NULL };
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
"O!s:gimp.Vectors.__init__",
kwlist,
&PyGimpImage_Type, &img, &name))
return -1;
self->ID = gimp_vectors_new(img->ID, name);
if (self->ID < 0) {
PyErr_Format(pygimp_error,
"could not create vectors '%s' on image (ID %d)",
name, img->ID);
return -1;
}
return 0;
}
PyTypeObject PyGimpVectors_Type = {
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
"gimp.Vectors", /* tp_name */
sizeof(PyGimpVectors), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
(destructor)vectors_dealloc, /* tp_dealloc */
(printfunc)0, /* tp_print */
(getattrfunc)0, /* tp_getattr */
(setattrfunc)0, /* tp_setattr */
(cmpfunc)vectors_cmp, /* tp_compare */
(reprfunc)vectors_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* 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 */
vectors_methods, /* tp_methods */
0, /* tp_members */
vectors_getsets, /* tp_getset */
&PyGimpItem_Type, /* tp_base */
(PyObject *)0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
(initproc)vectors_init, /* tp_init */
(allocfunc)0, /* tp_alloc */
(newfunc)0, /* tp_new */
};
PyObject *
pygimp_vectors_new(gint32 ID)
{
PyGimpVectors *self;
if (!gimp_item_is_valid(ID)) {
Py_INCREF(Py_None);
return Py_None;
}
self = PyObject_NEW(PyGimpVectors, &PyGimpVectors_Type);
if (self == NULL)
return NULL;
self->ID = ID;
return (PyObject *)self;
}
Reference in New Issue View Git Blame Copy Permalink