mirror of https://github.com/GNOME/gimp.git
436 lines
12 KiB
C
436 lines
12 KiB
C
/* -*- Mode: C; c-basic-offset: 4 -*-
|
|
Gimp-Python - allows the writing of Gimp plugins in Python.
|
|
Copyright (C) 2005-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 2 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, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
|
|
02111-1307, USA.
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
# include <config.h>
|
|
#endif
|
|
|
|
#include "pygimpcolor.h"
|
|
|
|
#define _INSIDE_PYGIMPCOLOR_
|
|
#include "pygimpcolor-api.h"
|
|
|
|
#include "pygimp-util.h"
|
|
|
|
|
|
static PyObject *
|
|
pygimp_rgb_parse_name(PyObject *self, PyObject *args, PyObject *kwargs)
|
|
{
|
|
char *name;
|
|
int len;
|
|
GimpRGB rgb;
|
|
gboolean success;
|
|
static char *kwlist[] = { "name", NULL };
|
|
|
|
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#:rgb_parse_name", kwlist,
|
|
&name, &len))
|
|
return NULL;
|
|
|
|
rgb.a = 1.0;
|
|
success = gimp_rgb_parse_name(&rgb, name, len);
|
|
|
|
if (!success) {
|
|
PyErr_SetString(PyExc_ValueError, "unable to parse color name");
|
|
return NULL;
|
|
}
|
|
|
|
return pygimp_rgb_new(&rgb);
|
|
}
|
|
|
|
static PyObject *
|
|
pygimp_rgb_parse_hex(PyObject *self, PyObject *args, PyObject *kwargs)
|
|
{
|
|
char *hex;
|
|
int len;
|
|
GimpRGB rgb;
|
|
gboolean success;
|
|
static char *kwlist[] = { "hex", NULL };
|
|
|
|
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#:rgb_parse_hex", kwlist,
|
|
&hex, &len))
|
|
return NULL;
|
|
|
|
rgb.a = 1.0;
|
|
success = gimp_rgb_parse_hex(&rgb, hex, len);
|
|
|
|
if (!success) {
|
|
PyErr_SetString(PyExc_ValueError, "unable to parse hex value");
|
|
return NULL;
|
|
}
|
|
|
|
return pygimp_rgb_new(&rgb);
|
|
}
|
|
|
|
static PyObject *
|
|
pygimp_rgb_parse_css(PyObject *self, PyObject *args, PyObject *kwargs)
|
|
{
|
|
char *css;
|
|
int len;
|
|
GimpRGB rgb;
|
|
gboolean success, with_alpha = FALSE;
|
|
static char *kwlist[] = { "css", "with_alpha", NULL };
|
|
|
|
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
|
|
"s#|i:rgb_parse_css", kwlist,
|
|
&css, &len, &with_alpha))
|
|
return NULL;
|
|
|
|
if (with_alpha)
|
|
success = gimp_rgba_parse_css(&rgb, css, len);
|
|
else {
|
|
rgb.a = 1.0;
|
|
success = gimp_rgb_parse_css(&rgb, css, len);
|
|
}
|
|
|
|
if (!success) {
|
|
PyErr_SetString(PyExc_ValueError, "unable to parse CSS color");
|
|
return NULL;
|
|
}
|
|
|
|
return pygimp_rgb_new(&rgb);
|
|
}
|
|
|
|
static PyObject *
|
|
pygimp_rgb_list_names(PyObject *self)
|
|
{
|
|
int num_names, i;
|
|
const char **names;
|
|
GimpRGB *colors;
|
|
PyObject *dict, *color;
|
|
|
|
num_names = gimp_rgb_list_names(&names, &colors);
|
|
|
|
dict = PyDict_New();
|
|
if (!dict)
|
|
goto cleanup;
|
|
|
|
for (i = 0; i < num_names; i++) {
|
|
color = pygimp_rgb_new(&colors[i]);
|
|
|
|
if (!color)
|
|
goto bail;
|
|
|
|
if (PyDict_SetItemString(dict, names[i], color) < 0) {
|
|
Py_DECREF(color);
|
|
goto bail;
|
|
}
|
|
|
|
Py_DECREF(color);
|
|
}
|
|
|
|
goto cleanup;
|
|
|
|
bail:
|
|
Py_DECREF(dict);
|
|
dict = NULL;
|
|
|
|
cleanup:
|
|
g_free(names);
|
|
g_free(colors);
|
|
|
|
return dict;
|
|
}
|
|
|
|
static PyObject *
|
|
pygimp_bilinear(PyObject *self, PyObject *args, PyObject *kwargs)
|
|
{
|
|
gdouble x, y;
|
|
gdouble values[4];
|
|
PyObject *py_values;
|
|
static char *kwlist[] = { "x", "y", "values", NULL };
|
|
|
|
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
|
|
"ddO:bilinear", kwlist,
|
|
&x, &y, &py_values))
|
|
return NULL;
|
|
|
|
if (PyString_Check(py_values)) {
|
|
if (PyString_Size(py_values) == 4) {
|
|
guchar ret;
|
|
ret = gimp_bilinear_8(x, y, (guchar *)PyString_AsString(py_values));
|
|
return PyString_FromStringAndSize((char *)&ret, 1);
|
|
}
|
|
} else if (PySequence_Check(py_values)) {
|
|
if (PySequence_Size(py_values) == 4) {
|
|
int i;
|
|
for (i = 0; i < 4; i++) {
|
|
PyObject *v;
|
|
v = PySequence_GetItem(py_values, i);
|
|
values[i] = PyFloat_AsDouble(v);
|
|
Py_DECREF(v);
|
|
}
|
|
return PyFloat_FromDouble(gimp_bilinear(x, y, values));
|
|
}
|
|
}
|
|
|
|
PyErr_SetString(PyExc_TypeError, "values is not a sequence of 4 items");
|
|
return NULL;
|
|
}
|
|
|
|
static PyObject *
|
|
pygimp_bilinear_color(PyObject *self, PyObject *args, PyObject *kwargs, gboolean with_alpha)
|
|
{
|
|
gdouble x, y;
|
|
GimpRGB values[4];
|
|
GimpRGB rgb;
|
|
PyObject *py_values, *v;
|
|
int i, success;
|
|
static char *kwlist[] = { "x", "y", "values", NULL };
|
|
|
|
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
|
|
with_alpha ? "ddO:bilinear_rgba"
|
|
: "ddO:bilinear_rgb",
|
|
kwlist,
|
|
&x, &y, &py_values))
|
|
return NULL;
|
|
|
|
if (!PySequence_Check(py_values) || PySequence_Size(py_values) != 4) {
|
|
PyErr_SetString(PyExc_TypeError, "values is not a sequence of 4 items");
|
|
return NULL;
|
|
}
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
v = PySequence_GetItem(py_values, i);
|
|
success = pygimp_rgb_from_pyobject(v, &values[i]);
|
|
Py_DECREF(v);
|
|
if (!success) {
|
|
PyErr_Format(PyExc_TypeError, "values[%d] is not a GimpRGB", i);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
if (with_alpha)
|
|
rgb = gimp_bilinear_rgba(x, y, values);
|
|
else
|
|
rgb = gimp_bilinear_rgb(x, y, values);
|
|
|
|
return pygimp_rgb_new(&rgb);
|
|
}
|
|
|
|
static PyObject *
|
|
pygimp_bilinear_rgb(PyObject *self, PyObject *args, PyObject *kwargs)
|
|
{
|
|
return pygimp_bilinear_color(self, args, kwargs, FALSE);
|
|
}
|
|
|
|
static PyObject *
|
|
pygimp_bilinear_rgba(PyObject *self, PyObject *args, PyObject *kwargs)
|
|
{
|
|
return pygimp_bilinear_color(self, args, kwargs, TRUE);
|
|
}
|
|
|
|
#if 0
|
|
static PyObject *
|
|
pygimp_bilinear_pixels_8(PyObject *self, PyObject *args, PyObject *kwargs)
|
|
{
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
typedef struct
|
|
{
|
|
PyObject *func;
|
|
PyObject *data;
|
|
} ProxyData;
|
|
|
|
static void
|
|
proxy_render(gdouble x, gdouble y, GimpRGB *color, gpointer pdata)
|
|
{
|
|
ProxyData *data = pdata;
|
|
|
|
if (data->data)
|
|
PyObject_CallFunction(data->func, "ddO&O", x, y, pygimp_rgb_new, color,
|
|
data->data);
|
|
else
|
|
PyObject_CallFunction(data->func, "ddO&", x, y, pygimp_rgb_new, color);
|
|
}
|
|
|
|
static void
|
|
proxy_put_pixel(gint x, gint y, GimpRGB *color, gpointer pdata)
|
|
{
|
|
ProxyData *data = pdata;
|
|
|
|
if (data->data)
|
|
PyObject_CallFunction(data->func, "iiO&O", x, y, pygimp_rgb_new, color,
|
|
data->data);
|
|
else
|
|
PyObject_CallFunction(data->func, "iiO&", x, y, pygimp_rgb_new, color);
|
|
}
|
|
|
|
static void
|
|
proxy_progress(gint min, gint max, gint current, gpointer pdata)
|
|
{
|
|
ProxyData *data = pdata;
|
|
|
|
if (data->data)
|
|
PyObject_CallFunction(data->func, "iiiO", min, max, current,
|
|
data->data);
|
|
else
|
|
PyObject_CallFunction(data->func, "iii", min, max, current);
|
|
}
|
|
|
|
static PyObject *
|
|
pygimp_adaptive_supersample_area(PyObject *self, PyObject *args, PyObject *kwargs)
|
|
{
|
|
gulong r;
|
|
|
|
gint x1, y1, x2, y2, max_depth;
|
|
gdouble threshold;
|
|
PyObject *py_func_render = NULL, *py_data_render = NULL;
|
|
PyObject *py_func_put_pixel = NULL, *py_data_put_pixel = NULL;
|
|
PyObject *py_func_progress = NULL, *py_data_progress = NULL;
|
|
|
|
GimpRenderFunc proxy_func_render = NULL;
|
|
GimpPutPixelFunc proxy_func_put_pixel = NULL;
|
|
GimpProgressFunc proxy_func_progress = NULL;
|
|
|
|
ProxyData proxy_data_render, proxy_data_put_pixel, proxy_data_progress;
|
|
|
|
static char *kwlist[] = {
|
|
"x1", "y1", "x2", "y2", "max_depth", "threshold",
|
|
"render_func", "render_data",
|
|
"put_pixel_func", "put_pixel_data",
|
|
"progress_func", "progress_data",
|
|
NULL
|
|
};
|
|
|
|
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
|
|
"iiiiid|OOOOOO"
|
|
":adaptive_supersample_area",
|
|
kwlist,
|
|
&x1, &y1, &x2, &y2, &max_depth, &threshold,
|
|
&py_func_render, &py_data_render,
|
|
&py_func_put_pixel, &py_data_put_pixel,
|
|
&py_func_progress, &py_data_progress))
|
|
return NULL;
|
|
|
|
#define PROCESS_FUNC(n) G_STMT_START { \
|
|
if (py_func_##n != NULL) { \
|
|
if (!PyCallable_Check(py_func_##n)) { \
|
|
PyErr_SetString(PyExc_TypeError, #n "_func " \
|
|
"must be callable"); \
|
|
return NULL; \
|
|
} \
|
|
\
|
|
proxy_func_##n = proxy_##n; \
|
|
\
|
|
proxy_data_##n.func = py_func_##n; \
|
|
proxy_data_##n.data = py_data_##n; \
|
|
} \
|
|
} G_STMT_END
|
|
|
|
PROCESS_FUNC(render);
|
|
PROCESS_FUNC(put_pixel);
|
|
PROCESS_FUNC(progress);
|
|
|
|
#undef PROCESS_FUNC
|
|
|
|
#define PASS_FUNC(n) proxy_func_##n, &proxy_data_##n
|
|
|
|
r = gimp_adaptive_supersample_area (x1, y1, x2, y2, max_depth, threshold,
|
|
PASS_FUNC(render),
|
|
PASS_FUNC(put_pixel),
|
|
PASS_FUNC(progress));
|
|
|
|
#undef PASS_FUNC
|
|
|
|
return PyInt_FromLong(r);
|
|
}
|
|
#endif
|
|
|
|
/* List of methods defined in the module */
|
|
|
|
static struct PyMethodDef gimpcolor_methods[] = {
|
|
{"rgb_parse_name", (PyCFunction)pygimp_rgb_parse_name, METH_VARARGS | METH_KEYWORDS},
|
|
{"rgb_parse_hex", (PyCFunction)pygimp_rgb_parse_hex, METH_VARARGS | METH_KEYWORDS},
|
|
{"rgb_parse_css", (PyCFunction)pygimp_rgb_parse_css, METH_VARARGS | METH_KEYWORDS},
|
|
{"rgb_names", (PyCFunction)pygimp_rgb_list_names, METH_NOARGS},
|
|
{"bilinear", (PyCFunction)pygimp_bilinear, METH_VARARGS | METH_KEYWORDS},
|
|
{"bilinear_rgb", (PyCFunction)pygimp_bilinear_rgb, METH_VARARGS | METH_KEYWORDS},
|
|
{"bilinear_rgba", (PyCFunction)pygimp_bilinear_rgba, METH_VARARGS | METH_KEYWORDS},
|
|
#if 0
|
|
{"bilinear_pixels_8", (PyCFunction)pygimp_bilinear_pixels_8, METH_VARARGS | METH_KEYWORDS},
|
|
{"adaptive_supersample_area", (PyCFunction)pygimp_adaptive_supersample_area, METH_VARARGS | METH_KEYWORDS},
|
|
#endif
|
|
{NULL, (PyCFunction)NULL, 0, NULL} /* sentinel */
|
|
};
|
|
|
|
|
|
static struct _PyGimpColor_Functions pygimpcolor_api_functions = {
|
|
&PyGimpRGB_Type,
|
|
pygimp_rgb_new,
|
|
&PyGimpHSV_Type,
|
|
pygimp_hsv_new,
|
|
&PyGimpHSL_Type,
|
|
pygimp_hsl_new,
|
|
&PyGimpCMYK_Type,
|
|
pygimp_cmyk_new,
|
|
pygimp_rgb_from_pyobject
|
|
};
|
|
|
|
|
|
/* Initialization function for the module (*must* be called initgimpcolor) */
|
|
|
|
static char gimpcolor_doc[] =
|
|
"This module provides interfaces to allow you to write gimp plugins"
|
|
;
|
|
|
|
void initgimpcolor(void);
|
|
|
|
PyMODINIT_FUNC
|
|
initgimpcolor(void)
|
|
{
|
|
PyObject *m, *d;
|
|
|
|
pygimp_init_pygobject();
|
|
|
|
/* Create the module and add the functions */
|
|
m = Py_InitModule3("gimpcolor", gimpcolor_methods, gimpcolor_doc);
|
|
|
|
d = PyModule_GetDict(m);
|
|
|
|
pyg_register_boxed(d, "RGB", GIMP_TYPE_RGB, &PyGimpRGB_Type);
|
|
pyg_register_boxed(d, "HSV", GIMP_TYPE_HSV, &PyGimpHSV_Type);
|
|
pyg_register_boxed(d, "HSL", GIMP_TYPE_HSL, &PyGimpHSL_Type);
|
|
pyg_register_boxed(d, "CMYK", GIMP_TYPE_CMYK, &PyGimpCMYK_Type);
|
|
|
|
PyModule_AddObject(m, "RGB_COMPOSITE_NONE",
|
|
PyInt_FromLong(GIMP_RGB_COMPOSITE_NONE));
|
|
PyModule_AddObject(m, "RGB_COMPOSITE_NORMAL",
|
|
PyInt_FromLong(GIMP_RGB_COMPOSITE_NORMAL));
|
|
PyModule_AddObject(m, "RGB_COMPOSITE_BEHIND",
|
|
PyInt_FromLong(GIMP_RGB_COMPOSITE_BEHIND));
|
|
|
|
PyModule_AddObject(m, "RGB_LUMINANCE_RED",
|
|
PyFloat_FromDouble(GIMP_RGB_LUMINANCE_RED));
|
|
PyModule_AddObject(m, "RGB_LUMINANCE_GREEN",
|
|
PyFloat_FromDouble(GIMP_RGB_LUMINANCE_GREEN));
|
|
PyModule_AddObject(m, "RGB_LUMINANCE_BLUE",
|
|
PyFloat_FromDouble(GIMP_RGB_LUMINANCE_BLUE));
|
|
|
|
/* for other modules */
|
|
PyModule_AddObject(m, "_PyGimpColor_API",
|
|
PyCObject_FromVoidPtr(&pygimpcolor_api_functions, NULL));
|
|
|
|
/* Check for errors */
|
|
if (PyErr_Occurred())
|
|
Py_FatalError("can't initialize module gimpcolor");
|
|
}
|