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