source/blender/python/generic/blf_py_api.c

   1 /*
   2  * $Id$
   3  *
   4  * ***** BEGIN GPL LICENSE BLOCK *****
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  19  *
  20  * Contributor(s): Campbell Barton
  21  *
  22  * ***** END GPL LICENSE BLOCK *****
  23  */
  24
  25 /** \file blender/python/generic/blf_py_api.c
  26  *  \ingroup pygen
  27  */
  28
  29
  30 #include <Python.h>
  31 #include "blf_py_api.h"
  32
  33 #include "../../blenfont/BLF_api.h"
  34
  35 #include "BLI_utildefines.h"
  36
  37
  38
  39 static char py_blf_position_doc[] =
  40 ".. function:: position(fontid, x, y, z)\n"
  41 "\n"
  42 "   Set the position for drawing text.\n"
  43 "\n"
  44 "   :arg fontid: The id of the typeface as returned by :func:`blf.load`, for default font use 0.\n"
  45 "   :type fontid: int\n"
  46 "   :arg x: X axis position to draw the text.\n"
  47 "   :type x: float\n"
  48 "   :arg y: Y axis position to draw the text.\n"
  49 "   :type y: float\n"
  50 "   :arg z: Z axis position to draw the text.\n"
  51 "   :type z: float\n";
  52
  53 static PyObject *py_blf_position(PyObject *UNUSED(self), PyObject *args)
  54 {
  55         int fontid;
  56         float x, y, z;
  57
  58         if (!PyArg_ParseTuple(args, "ifff:blf.position", &fontid, &x, &y, &z))
  59                 return NULL;
  60
  61         BLF_position(fontid, x, y, z);
  62
  63         Py_RETURN_NONE;
  64 }
  65
  66
  67 static char py_blf_size_doc[] =
  68 ".. function:: size(fontid, size, dpi)\n"
  69 "\n"
  70 "   Set the size and dpi for drawing text.\n"
  71 "\n"
  72 "   :arg fontid: The id of the typeface as returned by :func:`blf.load`, for default font use 0.\n"
  73 "   :type fontid: int\n"
  74 "   :arg size: Point size of the font.\n"
  75 "   :type size: int\n"
  76 "   :arg dpi: dots per inch value to use for drawing.\n"
  77 "   :type dpi: int\n";
  78
  79 static PyObject *py_blf_size(PyObject *UNUSED(self), PyObject *args)
  80 {
  81         int fontid, size, dpi;
  82
  83         if (!PyArg_ParseTuple(args, "iii:blf.size", &fontid, &size, &dpi))
  84                 return NULL;
  85
  86         BLF_size(fontid, size, dpi);
  87
  88         Py_RETURN_NONE;
  89 }
  90
  91
  92 static char py_blf_aspect_doc[] =
  93 ".. function:: aspect(fontid, aspect)\n"
  94 "\n"
  95 "   Set the aspect for drawing text.\n"
  96 "\n"
  97 "   :arg fontid: The id of the typeface as returned by :func:`blf.load`, for default font use 0.\n"
  98 "   :type fontid: int\n"
  99 "   :arg aspect: The aspect ratio for text drawing to use.\n"
 100 "   :type aspect: float\n";
 101
 102 static PyObject *py_blf_aspect(PyObject *UNUSED(self), PyObject *args)
 103 {
 104         float aspect;
 105         int fontid;
 106
 107         if (!PyArg_ParseTuple(args, "if:blf.aspect", &fontid, &aspect))
 108                 return NULL;
 109
 110         BLF_aspect(fontid, aspect, aspect, 1.0);
 111
 112         Py_RETURN_NONE;
 113 }
 114
 115
 116 static char py_blf_blur_doc[] =
 117 ".. function:: blur(fontid, radius)\n"
 118 "\n"
 119 "   Set the blur radius for drawing text.\n"
 120 "\n"
 121 "   :arg fontid: The id of the typeface as returned by :func:`blf.load`, for default font use 0.\n"
 122 "   :type fontid: int\n"
 123 "   :arg radius: The radius for blurring text (in pixels).\n"
 124 "   :type radius: int\n";
 125
 126 static PyObject *py_blf_blur(PyObject *UNUSED(self), PyObject *args)
 127 {
 128         int blur, fontid;
 129
 130         if (!PyArg_ParseTuple(args, "ii:blf.blur", &fontid, &blur))
 131                 return NULL;
 132
 133         BLF_blur(fontid, blur);
 134
 135         Py_RETURN_NONE;
 136 }
 137
 138
 139 static char py_blf_draw_doc[] =
 140 ".. function:: draw(fontid, text)\n"
 141 "\n"
 142 "   Draw text in the current context.\n"
 143 "\n"
 144 "   :arg fontid: The id of the typeface as returned by :func:`blf.load`, for default font use 0.\n"
 145 "   :type fontid: int\n"
 146 "   :arg text: the text to draw.\n"
 147 "   :type text: string\n";
 148
 149 static PyObject *py_blf_draw(PyObject *UNUSED(self), PyObject *args)
 150 {
 151         char *text;
 152         int text_length;
 153         int fontid;
 154
 155         if (!PyArg_ParseTuple(args, "is#:blf.draw", &fontid, &text, &text_length))
 156                 return NULL;
 157
 158         BLF_draw(fontid, text, (unsigned int)text_length);
 159
 160         Py_RETURN_NONE;
 161 }
 162
 163 static char py_blf_dimensions_doc[] =
 164 ".. function:: dimensions(fontid, text)\n"
 165 "\n"
 166 "   Return the width and height of the text.\n"
 167 "\n"
 168 "   :arg fontid: The id of the typeface as returned by :func:`blf.load`, for default font use 0.\n"
 169 "   :type fontid: int\n"
 170 "   :arg text: the text to draw.\n"
 171 "   :type text: string\n"
 172 "   :return: the width and height of the text.\n"
 173 "   :rtype: tuple of 2 floats\n";
 174
 175 static PyObject *py_blf_dimensions(PyObject *UNUSED(self), PyObject *args)
 176 {
 177         char *text;
 178         float r_width, r_height;
 179         PyObject *ret;
 180         int fontid;
 181
 182         if (!PyArg_ParseTuple(args, "is:blf.dimensions", &fontid, &text))
 183                 return NULL;
 184
 185         BLF_width_and_height(fontid, text, &r_width, &r_height);
 186
 187         ret= PyTuple_New(2);
 188         PyTuple_SET_ITEM(ret, 0, PyFloat_FromDouble(r_width));
 189         PyTuple_SET_ITEM(ret, 1, PyFloat_FromDouble(r_height));
 190         return ret;
 191 }
 192
 193 static char py_blf_clipping_doc[] =
 194 ".. function:: clipping(fontid, xmin, ymin, xmax, ymax)\n"
 195 "\n"
 196 "   Set the clipping, enable/disable using CLIPPING.\n"
 197 "\n"
 198 "   :arg fontid: The id of the typeface as returned by :func:`blf.load`, for default font use 0.\n"
 199 "   :type fontid: int\n"
 200 "   :arg xmin: Clip the drawing area by these bounds.\n"
 201 "   :type xmin: float\n"
 202 "   :arg ymin: Clip the drawing area by these bounds.\n"
 203 "   :type ymin: float\n"
 204 "   :arg xmax: Clip the drawing area by these bounds.\n"
 205 "   :type xmax: float\n"
 206 "   :arg ymax: Clip the drawing area by these bounds.\n"
 207 "   :type ymax: float\n";
 208
 209 static PyObject *py_blf_clipping(PyObject *UNUSED(self), PyObject *args)
 210 {
 211         float xmin, ymin, xmax, ymax;
 212         int fontid;
 213
 214         if (!PyArg_ParseTuple(args, "iffff:blf.clipping", &fontid, &xmin, &ymin, &xmax, &ymax))
 215                 return NULL;
 216
 217         BLF_clipping(fontid, xmin, ymin, xmax, ymax);
 218
 219         Py_RETURN_NONE;
 220 }
 221
 222 static char py_blf_disable_doc[] =
 223 ".. function:: disable(fontid, option)\n"
 224 "\n"
 225 "   Disable option.\n"
 226 "\n"
 227 "   :arg fontid: The id of the typeface as returned by :func:`blf.load`, for default font use 0.\n"
 228 "   :type fontid: int\n"
 229 "   :arg option: One of ROTATION, CLIPPING, SHADOW or KERNING_DEFAULT.\n"
 230 "   :type option: int\n";
 231
 232 static PyObject *py_blf_disable(PyObject *UNUSED(self), PyObject *args)
 233 {
 234         int option, fontid;
 235
 236         if (!PyArg_ParseTuple(args, "ii:blf.disable", &fontid, &option))
 237                 return NULL;
 238
 239         BLF_disable(fontid, option);
 240
 241         Py_RETURN_NONE;
 242 }
 243
 244 static char py_blf_enable_doc[] =
 245 ".. function:: enable(fontid, option)\n"
 246 "\n"
 247 "   Enable option.\n"
 248 "\n"
 249 "   :arg fontid: The id of the typeface as returned by :func:`blf.load`, for default font use 0.\n"
 250 "   :type fontid: int\n"
 251 "   :arg option: One of ROTATION, CLIPPING, SHADOW or KERNING_DEFAULT.\n"
 252 "   :type option: int\n";
 253
 254 static PyObject *py_blf_enable(PyObject *UNUSED(self), PyObject *args)
 255 {
 256         int option, fontid;
 257
 258         if (!PyArg_ParseTuple(args, "ii:blf.enable", &fontid, &option))
 259                 return NULL;
 260
 261         BLF_enable(fontid, option);
 262
 263         Py_RETURN_NONE;
 264 }
 265
 266 static char py_blf_rotation_doc[] =
 267 ".. function:: rotation(fontid, angle)\n"
 268 "\n"
 269 "   Set the text rotation angle, enable/disable using ROTATION.\n"
 270 "\n"
 271 "   :arg fontid: The id of the typeface as returned by :func:`blf.load`, for default font use 0.\n"
 272 "   :type fontid: int\n"
 273 "   :arg angle: The angle for text drawing to use.\n"
 274 "   :type angle: float\n";
 275
 276 static PyObject *py_blf_rotation(PyObject *UNUSED(self), PyObject *args)
 277 {
 278         float angle;
 279         int fontid;
 280
 281         if (!PyArg_ParseTuple(args, "if:blf.rotation", &fontid, &angle))
 282                 return NULL;
 283
 284         BLF_rotation(fontid, angle);
 285
 286         Py_RETURN_NONE;
 287 }
 288
 289 static char py_blf_shadow_doc[] =
 290 ".. function:: shadow(fontid, level, r, g, b, a)\n"
 291 "\n"
 292 "   Shadow options, enable/disable using SHADOW .\n"
 293 "\n"
 294 "   :arg fontid: The id of the typeface as returned by :func:`blf.load`, for default font use 0.\n"
 295 "   :type fontid: int\n"
 296 "   :arg level: The blur level, can be 3, 5 or 0.\n"
 297 "   :type level: int\n"
 298 "   :arg r: Shadow color (red channel 0.0 - 1.0).\n"
 299 "   :type r: float\n"
 300 "   :arg g: Shadow color (green channel 0.0 - 1.0).\n"
 301 "   :type g: float\n"
 302 "   :arg b: Shadow color (blue channel 0.0 - 1.0).\n"
 303 "   :type b: float\n"
 304 "   :arg a: Shadow color (alpha channel 0.0 - 1.0).\n"
 305 "   :type a: float\n";
 306
 307 static PyObject *py_blf_shadow(PyObject *UNUSED(self), PyObject *args)
 308 {
 309         int level, fontid;
 310         float r, g, b, a;
 311
 312         if (!PyArg_ParseTuple(args, "iiffff:blf.shadow", &fontid, &level, &r, &g, &b, &a))
 313                 return NULL;
 314
 315         if (level != 0 && level != 3 && level != 5) {
 316                 PyErr_SetString(PyExc_TypeError, "blf.shadow expected arg to be in (0, 3, 5)");
 317                 return NULL;
 318         }
 319
 320         BLF_shadow(fontid, level, r, g, b, a);
 321
 322         Py_RETURN_NONE;
 323 }
 324
 325 static char py_blf_shadow_offset_doc[] =
 326 ".. function:: shadow_offset(fontid, x, y)\n"
 327 "\n"
 328 "   Set the offset for shadow text.\n"
 329 "\n"
 330 "   :arg fontid: The id of the typeface as returned by :func:`blf.load`, for default font use 0.\n"
 331 "   :type fontid: int\n"
 332 "   :arg x: Vertical shadow offset value in pixels.\n"
 333 "   :type x: float\n"
 334 "   :arg y: Horizontal shadow offset value in pixels.\n"
 335 "   :type y: float\n";
 336
 337 static PyObject *py_blf_shadow_offset(PyObject *UNUSED(self), PyObject *args)
 338 {
 339         int x, y, fontid;
 340
 341         if (!PyArg_ParseTuple(args, "iii:blf.shadow_offset", &fontid, &x, &y))
 342                 return NULL;
 343
 344         BLF_shadow_offset(fontid, x, y);
 345
 346         Py_RETURN_NONE;
 347 }
 348
 349 static char py_blf_load_doc[] =
 350 ".. function:: load(filename)\n"
 351 "\n"
 352 "   Load a new font.\n"
 353 "\n"
 354 "   :arg filename: the filename of the font.\n"
 355 "   :type filename: string\n"
 356 "   :return: the new font's fontid or -1 if there was an error.\n"
 357 "   :rtype: integer\n";
 358
 359 static PyObject *py_blf_load(PyObject *UNUSED(self), PyObject *args)
 360 {
 361         char* filename;
 362
 363         if (!PyArg_ParseTuple(args, "s:blf.load", &filename))
 364                 return NULL;
 365
 366         return PyLong_FromLong(BLF_load(filename));
 367 }
 368
 369 /*----------------------------MODULE INIT-------------------------*/
 370 static PyMethodDef BLF_methods[] = {
 371         {"aspect", (PyCFunction) py_blf_aspect, METH_VARARGS, py_blf_aspect_doc},
 372         {"blur", (PyCFunction) py_blf_blur, METH_VARARGS, py_blf_blur_doc},
 373         {"clipping", (PyCFunction) py_blf_clipping, METH_VARARGS, py_blf_clipping_doc},
 374         {"disable", (PyCFunction) py_blf_disable, METH_VARARGS, py_blf_disable_doc},
 375         {"dimensions", (PyCFunction) py_blf_dimensions, METH_VARARGS, py_blf_dimensions_doc},
 376         {"draw", (PyCFunction) py_blf_draw, METH_VARARGS, py_blf_draw_doc},
 377         {"enable", (PyCFunction) py_blf_enable, METH_VARARGS, py_blf_enable_doc},
 378         {"position", (PyCFunction) py_blf_position, METH_VARARGS, py_blf_position_doc},
 379         {"rotation", (PyCFunction) py_blf_rotation, METH_VARARGS, py_blf_rotation_doc},
 380         {"shadow", (PyCFunction) py_blf_shadow, METH_VARARGS, py_blf_shadow_doc},
 381         {"shadow_offset", (PyCFunction) py_blf_shadow_offset, METH_VARARGS, py_blf_shadow_offset_doc},
 382         {"size", (PyCFunction) py_blf_size, METH_VARARGS, py_blf_size_doc},
 383         {"load", (PyCFunction) py_blf_load, METH_VARARGS, py_blf_load_doc},
 384         {NULL, NULL, 0, NULL}
 385 };
 386
 387 static char BLF_doc[] =
 388 "This module provides access to blenders text drawing functions.\n";
 389
 390 static struct PyModuleDef BLF_module_def = {
 391         PyModuleDef_HEAD_INIT,
 392         "blf",  /* m_name */
 393         BLF_doc,  /* m_doc */
 394         0,  /* m_size */
 395         BLF_methods,  /* m_methods */
 396         NULL,  /* m_reload */
 397         NULL,  /* m_traverse */
 398         NULL,  /* m_clear */
 399         NULL,  /* m_free */
 400 };
 401
 402 PyObject *BPyInit_blf(void)
 403 {
 404         PyObject *submodule;
 405
 406         submodule = PyModule_Create(&BLF_module_def);
 407
 408         PyModule_AddIntConstant(submodule, "ROTATION", BLF_ROTATION);
 409         PyModule_AddIntConstant(submodule, "CLIPPING", BLF_CLIPPING);
 410         PyModule_AddIntConstant(submodule, "SHADOW", BLF_SHADOW);
 411         PyModule_AddIntConstant(submodule, "KERNING_DEFAULT", BLF_KERNING_DEFAULT);
 412
 413         return submodule;
 414 }