lib/python/primitives.c

   1 /* primitives.c
   2
   3    Python wrapper for librfxswf- primitive objects (implementation)
   4
   5    Part of the swftools package.
   6
   7    Copyright (c) 2003 Matthias Kramm <kramm@quiss.org>
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  22
  23 #include <Python.h>
  24 #undef HAVE_STAT
  25 #include "../rfxswf.h"
  26 #include "../log.h"
  27 #include "./pyutils.h"
  28 #include "primitives.h"
  29
  30 //----------------------------------------------------------------------------
  31 typedef struct {
  32     PyObject_HEAD
  33     RGBA rgba;
  34 } ColorObject;
  35
  36 PyObject* f_Color(PyObject* self, PyObject* args, PyObject* kwargs)
  37 {
  38     static char *kwlist[] = {"r", "g", "b", "a", NULL};
  39     ColorObject* color;
  40     int r=0,g=0,b=0,a=255;
  41     if (!PyArg_ParseTupleAndKeywords(args, kwargs, "iii|i", kwlist, &r,&g,&b,&a))
  42         return NULL;
  43     color = PyObject_New(ColorObject, &ColorClass);
  44     color->rgba.r = r;
  45     color->rgba.g = g;
  46     color->rgba.b = b;
  47     color->rgba.a = a;
  48     return (PyObject*)color;
  49 }
  50 static PyObject* color_getattr(PyObject * self, char* a)
  51 {
  52     ColorObject*color = (ColorObject*)self;
  53     if(!strcmp(a, "r")) {
  54         return Py_BuildValue("r", color->rgba.r);
  55     } else if(!strcmp(a, "g")) {
  56         return Py_BuildValue("g", color->rgba.g);
  57     } else if(!strcmp(a, "b")) {
  58         return Py_BuildValue("b", color->rgba.b);
  59     } else if(!strcmp(a, "a")) {
  60         return Py_BuildValue("a", color->rgba.a);
  61     }
  62     return NULL;
  63 }
  64 static int color_setattr(PyObject * self, char* attr, PyObject* o)
  65 {
  66     ColorObject*color = (ColorObject*)self;
  67     if(!strcmp(attr, "r")) {
  68         if (!PyArg_Parse(o, "d", &color->rgba.r)) goto err;
  69         return 0;
  70     } else if(!strcmp(attr, "g")) {
  71         if (!PyArg_Parse(o, "d", &color->rgba.g)) goto err;
  72         return 0;
  73     } else if(!strcmp(attr, "b")) {
  74         if (!PyArg_Parse(o, "d", &color->rgba.b)) goto err;
  75         return 0;
  76     } else if(!strcmp(attr, "a")) {
  77         if (!PyArg_Parse(o, "d", &color->rgba.a)) goto err;
  78         return 0;
  79     }
  80 err:
  81     mylog("swf_setattr %08x(%d) %s = ? (%08x)\n", (int)self, self->ob_refcnt, attr, o);
  82     return 1;
  83 }
  84 RGBA color_getRGBA(PyObject*self)
  85 {
  86     ColorObject*color = 0;
  87     if (!PyArg_Parse(self, "O!", &ColorClass, &color)) {
  88         RGBA dummy;
  89         memset(&dummy, 0, sizeof(dummy));
  90         mylog("Error: wrong type for function color_getRGBA");
  91         return dummy;
  92     }
  93     return color->rgba;
  94 }
  95 PyTypeObject ColorClass =
  96 {
  97     PyObject_HEAD_INIT(NULL)
  98     0,
  99     tp_name: "Color",
 100     tp_basicsize: sizeof(ColorObject),
 101     tp_itemsize: 0,
 102     tp_dealloc: dummy_dealloc,
 103     tp_print: 0,
 104     tp_getattr: color_getattr,
 105     tp_setattr: color_setattr,
 106 };
 107 //----------------------------------------------------------------------------
 108 typedef struct {
 109     PyObject_HEAD
 110     SRECT bbox;
 111 } BBoxObject;
 112
 113 PyObject* f_BBox(PyObject* self, PyObject* args, PyObject* kwargs)
 114 {
 115     static char *kwlist[] = {"xmin", "ymin", "xmax", "ymax", NULL};
 116     BBoxObject* bbox;
 117     SRECT box;
 118     if (!PyArg_ParseTupleAndKeywords(args, kwargs, "iiii", kwlist,
 119                 &box.xmin,
 120                 &box.ymin,
 121                 &box.xmax,
 122                 &box.ymax));
 123         return NULL;
 124     bbox = PyObject_New(BBoxObject, &BBoxClass);
 125     bbox->bbox = box;
 126     return (PyObject*)bbox;
 127 }
 128 static PyObject* bbox_getattr(PyObject * self, char* a)
 129 {
 130     BBoxObject*bbox = (BBoxObject*)self;
 131     if(!strcmp(a, "xmin")) {
 132         return Py_BuildValue("i", bbox->bbox.xmin);
 133     } else if(!strcmp(a, "ymin")) {
 134         return Py_BuildValue("i", bbox->bbox.ymin);
 135     } else if(!strcmp(a, "xmax")) {
 136         return Py_BuildValue("i", bbox->bbox.xmax);
 137     } else if(!strcmp(a, "ymax")) {
 138         return Py_BuildValue("i", bbox->bbox.ymax);
 139     }
 140     return NULL;
 141 }
 142 static int bbox_setattr(PyObject * self, char* a, PyObject* o)
 143 {
 144     BBoxObject*bbox= (BBoxObject*)self;
 145     if(!strcmp(a, "xmin")) {
 146         if (!PyArg_Parse(o, "i", &bbox->bbox.xmin)) goto err;
 147         return 0;
 148     } else if(!strcmp(a, "ymin")) {
 149         if (!PyArg_Parse(o, "i", &bbox->bbox.ymin)) goto err;
 150         return 0;
 151     } else if(!strcmp(a, "xmax")) {
 152         if (!PyArg_Parse(o, "i", &bbox->bbox.xmax)) goto err;
 153         return 0;
 154     } else if(!strcmp(a, "ymax")) {
 155         if (!PyArg_Parse(o, "i", &bbox->bbox.ymax)) goto err;
 156         return 0;
 157     }
 158 err:
 159     mylog("swf_setattr %08x(%d) %s = ? (%08x)\n", (int)self, self->ob_refcnt, a, o);
 160     return 1;
 161 }
 162 SRECT bbox_getBBox(PyObject*self)
 163 {
 164     BBoxObject*bbox= 0;
 165     if (!PyArg_Parse(self, "O!", &BBoxClass, &bbox)) {
 166         SRECT dummy;
 167         memset(&dummy, 0, sizeof(dummy));
 168         mylog("Error: wrong type for function color_getRGBA");
 169         return dummy;
 170     }
 171     return bbox->bbox;
 172 }
 173 PyTypeObject BBoxClass =
 174 {
 175     PyObject_HEAD_INIT(NULL)
 176     0,
 177     tp_name: "BBox",
 178     tp_basicsize: sizeof(BBoxObject),
 179     tp_itemsize: 0,
 180     tp_dealloc: dummy_dealloc,
 181     tp_print: 0,
 182     tp_getattr: bbox_getattr,
 183     tp_setattr: bbox_setattr,
 184 };
 185 SRECT bbox_getBBox(PyObject*self);
 186 //----------------------------------------------------------------------------
 187 typedef struct {
 188     PyObject_HEAD
 189     MATRIX matrix;
 190 } MatrixObject;
 191
 192 PyObject* f_Matrix(PyObject* _self, PyObject* args, PyObject* kwargs)
 193 {
 194     PyObject*self = (PyObject*)PyObject_New(MatrixObject, &MatrixClass);
 195     MatrixObject*matrix = (MatrixObject*)self;
 196     mylog("+%08x(%d) f_Matrix", self, self->ob_refcnt);
 197     static char *kwlist[] = {"x", "y", "scale", "rotate", NULL};
 198     float x=0,y=0,scale=1.0,rotate=0;
 199     if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|ffff", kwlist, &x,&y,&scale,&rotate))
 200         return NULL;
 201     mylog(" %08x(%d) f_Matrix: x=%f y=%f scale=%f rotate=%f", self, self->ob_refcnt, x,y,scale,rotate);
 202     swf_GetMatrix(0, &matrix->matrix);
 203     matrix->matrix.tx = (int)(x*20);
 204     matrix->matrix.ty = (int)(y*20);
 205     matrix->matrix.sx = (int)(scale*65536);
 206     matrix->matrix.sy = (int)(scale*65536);
 207     /* TODO: rotate */
 208     return self;
 209 }
 210 static PyObject* matrix_getattr(PyObject * self, char* a)
 211 {
 212     PY_ASSERT_TYPE(self,&MatrixClass);
 213     return NULL;
 214 }
 215 static int matrix_setattr(PyObject * self, char* a, PyObject* o)
 216 {
 217     PY_ASSERT_TYPE(self,&MatrixClass);
 218     return 0;
 219 }
 220 MATRIX matrix_getMatrix(PyObject*self)
 221 {
 222     mylog(" %08x(%d) matrix_getMatrix", self, self->ob_refcnt);
 223     PY_ASSERT_TYPE(self,&MatrixClass);
 224     MatrixObject*matrix = (MatrixObject*)self;
 225     return matrix->matrix;
 226 }
 227 PyTypeObject MatrixClass =
 228 {
 229     PyObject_HEAD_INIT(NULL)
 230     0,
 231     tp_name: "Matrix",
 232     tp_basicsize: sizeof(MatrixObject),
 233     tp_itemsize: 0,
 234     tp_dealloc: dummy_dealloc,
 235     tp_print: 0,
 236     tp_getattr: matrix_getattr,
 237     tp_setattr: matrix_setattr,
 238     tp_compare: 0,
 239     tp_repr: 0,
 240     tp_as_number: 0,
 241     tp_as_sequence: 0,
 242     tp_as_mapping: 0,
 243     tp_hash: 0,     // dict(x)
 244     tp_call: 0,     // x()
 245     tp_str: 0       // str(x)
 246 };
 247 //----------------------------------------------------------------------------
 248 typedef struct {
 249     PyObject_HEAD
 250     CXFORM cxform;
 251 } CXFormObject;
 252
 253 PyObject* f_ColorTransform(PyObject* self, PyObject* args, PyObject* kwargs)
 254 {
 255     return NULL;
 256 }
 257 static PyObject* colortransform_getattr(PyObject * self, char* a)
 258 {
 259     return NULL;
 260 }
 261 static int colortransform_setattr(PyObject * self, char* a, PyObject* o)
 262 {
 263     return 0;
 264 }
 265 CXFORM colortransform_getCXForm(PyObject*self)
 266 {
 267     CXFormObject*cxform= 0;
 268     if (!PyArg_Parse(self, "O!", &CXFormClass, &cxform)) {
 269         CXFORM dummy;
 270         memset(&dummy, 0, sizeof(dummy));
 271         mylog("Error: wrong type for function color_getRGBA");
 272         return dummy;
 273     }
 274     return cxform->cxform;
 275 }
 276 PyTypeObject CXFormClass =
 277 {
 278     PyObject_HEAD_INIT(NULL)
 279     0,
 280     tp_name: "ColorTransform",
 281     tp_basicsize: sizeof(CXFormObject),
 282     tp_itemsize: 0,
 283     tp_dealloc: dummy_dealloc,
 284     tp_print: 0,
 285     tp_getattr: colortransform_getattr,
 286     tp_setattr: colortransform_setattr,
 287 };
 288 //----------------------------------------------------------------------------
 289 typedef struct {
 290     PyObject_HEAD
 291     GRADIENT gradient;
 292 } GradientObject;
 293
 294 PyObject* f_Gradient(PyObject* self, PyObject* args, PyObject* kwargs)
 295 {
 296     return NULL;
 297 }
 298 static PyObject* gradient_getattr(PyObject * self, char* a)
 299 {
 300     return NULL;
 301 }
 302 static int gradient_setattr(PyObject * self, char* a, PyObject* o)
 303 {
 304     return 0;
 305 }
 306 GRADIENT colortransform_getGradient(PyObject*self)
 307 {
 308     GradientObject*gradient = 0;
 309     if (!PyArg_Parse(self, "O!", &gradient, &gradient)) {
 310         GRADIENT dummy;
 311         memset(&dummy, 0, sizeof(dummy));
 312         mylog("Error: wrong type for function color_getRGBA");
 313         return dummy;
 314     }
 315     return gradient->gradient;
 316 }
 317 PyTypeObject GradientClass =
 318 {
 319     PyObject_HEAD_INIT(NULL)
 320     0,
 321     tp_name: "Gradient",
 322     tp_basicsize: sizeof(GradientObject),
 323     tp_itemsize: 0,
 324     tp_dealloc: dummy_dealloc,
 325     tp_print: 0,
 326     tp_getattr: gradient_getattr,
 327     tp_setattr: gradient_setattr,
 328 };
 329 //----------------------------------------------------------------------------
 330
 331 static PyMethodDef primitive_methods[] =
 332 {
 333     {"Color", (PyCFunction)f_Color, METH_KEYWORDS, "Create a new color object."},
 334     {"Gradient", (PyCFunction)f_Gradient, METH_KEYWORDS, "Create a new gradient object."},
 335     {"ColorTransform", (PyCFunction)f_ColorTransform, METH_KEYWORDS, "Create a new colortransform object."},
 336     {"Matrix", (PyCFunction)f_Matrix, METH_KEYWORDS, "Create a new matrix object."},
 337     {"BBox", (PyCFunction)f_BBox, METH_KEYWORDS, "Create a new bounding box object."},
 338     {NULL, NULL, 0, NULL}
 339 };
 340
 341 PyMethodDef* primitive_getMethods()
 342 {
 343     GradientClass.ob_type = &PyType_Type;
 344     CXFormClass.ob_type = &PyType_Type;
 345     BBoxClass.ob_type = &PyType_Type;
 346     MatrixClass.ob_type = &PyType_Type;
 347     return primitive_methods;
 348 }
 349
 350