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