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