Cleanup: remove redundant doxygen \file argument
[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 \ingroup pygen
18  *
19  * This file defines the 'bgl' module, used for drawing text in OpenGL.
20  */
21
22 #include <Python.h>
23 #include "blf_py_api.h"
24
25 #include "../../blenfont/BLF_api.h"
26
27 #include "BLI_utildefines.h"
28
29 #include "python_utildefines.h"
30
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 font use 0.\n"
38 "   :type fontid: int\n"
39 "   :arg x: X axis position to draw the text.\n"
40 "   :type x: float\n"
41 "   :arg y: Y axis position to draw the text.\n"
42 "   :type y: float\n"
43 "   :arg z: Z axis position to draw the text.\n"
44 "   :type z: float\n"
45 );
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         BLF_position(fontid, x, y, z);
56
57         Py_RETURN_NONE;
58 }
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 font use 0.\n"
67 "   :type fontid: int\n"
68 "   :arg size: Point size of the font.\n"
69 "   :type size: int\n"
70 "   :arg dpi: dots per inch value to use for drawing.\n"
71 "   :type dpi: int\n"
72 );
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         BLF_size(fontid, size, dpi);
81
82         Py_RETURN_NONE;
83 }
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 font use 0.\n"
92 "   :type fontid: int\n"
93 "   :arg aspect: The aspect ratio for text drawing to use.\n"
94 "   :type aspect: float\n"
95 );
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         BLF_aspect(fontid, aspect, aspect, 1.0);
105
106         Py_RETURN_NONE;
107 }
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 font use 0.\n"
116 "   :type fontid: int\n"
117 "   :arg r: red channel 0.0 - 1.0.\n"
118 "   :type r: float\n"
119 "   :arg g: green channel 0.0 - 1.0.\n"
120 "   :type g: float\n"
121 "   :arg b: blue channel 0.0 - 1.0.\n"
122 "   :type b: float\n"
123 "   :arg a: alpha channel 0.0 - 1.0.\n"
124 "   :type a: float\n"
125 );
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",
133                 &fontid, &rgba[0], &rgba[1], &rgba[2], &rgba[3]))
134         {
135                 return NULL;
136         }
137
138         BLF_color4fv(fontid, rgba);
139
140         Py_RETURN_NONE;
141 }
142
143
144 #if BLF_BLUR_ENABLE
145 PyDoc_STRVAR(py_blf_blur_doc,
146 ".. function:: blur(fontid, radius)\n"
147 "\n"
148 "   Set the blur radius for drawing text.\n"
149 "\n"
150 "   :arg fontid: The id of the typeface as returned by :func:`blf.load`, for default font use 0.\n"
151 "   :type fontid: int\n"
152 "   :arg radius: The radius for blurring text (in pixels).\n"
153 "   :type radius: int\n"
154 );
155 static PyObject *py_blf_blur(PyObject *UNUSED(self), PyObject *args)
156 {
157         int blur, fontid;
158
159         if (!PyArg_ParseTuple(args, "ii:blf.blur", &fontid, &blur))
160                 return NULL;
161
162         BLF_blur(fontid, blur);
163
164         Py_RETURN_NONE;
165 }
166 #endif
167
168
169 PyDoc_STRVAR(py_blf_draw_doc,
170 ".. function:: draw(fontid, text)\n"
171 "\n"
172 "   Draw text in the current context.\n"
173 "\n"
174 "   :arg fontid: The id of the typeface as returned by :func:`blf.load`, for default font use 0.\n"
175 "   :type fontid: int\n"
176 "   :arg text: the text to draw.\n"
177 "   :type text: string\n"
178 );
179 static PyObject *py_blf_draw(PyObject *UNUSED(self), PyObject *args)
180 {
181         const char *text;
182         int text_length;
183         int fontid;
184
185         if (!PyArg_ParseTuple(args, "is#:blf.draw", &fontid, &text, &text_length))
186                 return NULL;
187
188         BLF_draw(fontid, text, (unsigned int)text_length);
189
190         Py_RETURN_NONE;
191 }
192
193 PyDoc_STRVAR(py_blf_dimensions_doc,
194 ".. function:: dimensions(fontid, text)\n"
195 "\n"
196 "   Return the width and height of the text.\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 text: the text to draw.\n"
201 "   :type text: string\n"
202 "   :return: the width and height of the text.\n"
203 "   :rtype: tuple of 2 floats\n"
204 );
205 static PyObject *py_blf_dimensions(PyObject *UNUSED(self), PyObject *args)
206 {
207         const char *text;
208         float r_width, r_height;
209         PyObject *ret;
210         int fontid;
211
212         if (!PyArg_ParseTuple(args, "is:blf.dimensions", &fontid, &text))
213                 return NULL;
214
215         BLF_width_and_height(fontid, text, INT_MAX, &r_width, &r_height);
216
217         ret = PyTuple_New(2);
218         PyTuple_SET_ITEMS(ret,
219                 PyFloat_FromDouble(r_width),
220                 PyFloat_FromDouble(r_height));
221         return ret;
222 }
223
224 PyDoc_STRVAR(py_blf_clipping_doc,
225 ".. function:: clipping(fontid, xmin, ymin, xmax, ymax)\n"
226 "\n"
227 "   Set the clipping, enable/disable using CLIPPING.\n"
228 "\n"
229 "   :arg fontid: The id of the typeface as returned by :func:`blf.load`, for default font use 0.\n"
230 "   :type fontid: int\n"
231 "   :arg xmin: Clip the drawing area by these bounds.\n"
232 "   :type xmin: float\n"
233 "   :arg ymin: Clip the drawing area by these bounds.\n"
234 "   :type ymin: float\n"
235 "   :arg xmax: Clip the drawing area by these bounds.\n"
236 "   :type xmax: float\n"
237 "   :arg ymax: Clip the drawing area by these bounds.\n"
238 "   :type ymax: float\n"
239 );
240 static PyObject *py_blf_clipping(PyObject *UNUSED(self), PyObject *args)
241 {
242         float xmin, ymin, xmax, ymax;
243         int fontid;
244
245         if (!PyArg_ParseTuple(args, "iffff:blf.clipping", &fontid, &xmin, &ymin, &xmax, &ymax))
246                 return NULL;
247
248         BLF_clipping(fontid, xmin, ymin, xmax, ymax);
249
250         Py_RETURN_NONE;
251 }
252
253 PyDoc_STRVAR(py_blf_word_wrap_doc,
254 ".. function:: word_wrap(fontid, wrap_width)\n"
255 "\n"
256 "   Set the wrap width, enable/disable using WORD_WRAP.\n"
257 "\n"
258 "   :arg fontid: The id of the typeface as returned by :func:`blf.load`, for default font use 0.\n"
259 "   :type fontid: int\n"
260 "   :arg wrap_width: The width (in pixels) to wrap words at.\n"
261 "   :type wrap_width: int\n"
262 );
263 static PyObject *py_blf_word_wrap(PyObject *UNUSED(self), PyObject *args)
264 {
265         int wrap_width;
266         int fontid;
267
268         if (!PyArg_ParseTuple(args, "ii:blf.word_wrap", &fontid, &wrap_width))
269                 return NULL;
270
271         BLF_wordwrap(fontid, wrap_width);
272
273         Py_RETURN_NONE;
274 }
275
276 PyDoc_STRVAR(py_blf_disable_doc,
277 ".. function:: disable(fontid, option)\n"
278 "\n"
279 "   Disable option.\n"
280 "\n"
281 "   :arg fontid: The id of the typeface as returned by :func:`blf.load`, for default 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 );
286 static PyObject *py_blf_disable(PyObject *UNUSED(self), PyObject *args)
287 {
288         int option, fontid;
289
290         if (!PyArg_ParseTuple(args, "ii:blf.disable", &fontid, &option))
291                 return NULL;
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 font use 0.\n"
304 "   :type fontid: int\n"
305 "   :arg option: One of ROTATION, CLIPPING, SHADOW or KERNING_DEFAULT.\n"
306 "   :type option: int\n"
307 );
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         BLF_enable(fontid, option);
316
317         Py_RETURN_NONE;
318 }
319
320 PyDoc_STRVAR(py_blf_rotation_doc,
321 ".. function:: rotation(fontid, angle)\n"
322 "\n"
323 "   Set the text rotation angle, enable/disable using ROTATION.\n"
324 "\n"
325 "   :arg fontid: The id of the typeface as returned by :func:`blf.load`, for default font use 0.\n"
326 "   :type fontid: int\n"
327 "   :arg angle: The angle for text drawing to use.\n"
328 "   :type angle: float\n"
329 );
330 static PyObject *py_blf_rotation(PyObject *UNUSED(self), PyObject *args)
331 {
332         float angle;
333         int fontid;
334
335         if (!PyArg_ParseTuple(args, "if:blf.rotation", &fontid, &angle))
336                 return NULL;
337
338         BLF_rotation(fontid, angle);
339
340         Py_RETURN_NONE;
341 }
342
343 PyDoc_STRVAR(py_blf_shadow_doc,
344 ".. function:: shadow(fontid, level, r, g, b, a)\n"
345 "\n"
346 "   Shadow options, enable/disable using SHADOW .\n"
347 "\n"
348 "   :arg fontid: The id of the typeface as returned by :func:`blf.load`, for default font use 0.\n"
349 "   :type fontid: int\n"
350 "   :arg level: The blur level, can be 3, 5 or 0.\n"
351 "   :type level: int\n"
352 "   :arg r: Shadow color (red channel 0.0 - 1.0).\n"
353 "   :type r: float\n"
354 "   :arg g: Shadow color (green channel 0.0 - 1.0).\n"
355 "   :type g: float\n"
356 "   :arg b: Shadow color (blue channel 0.0 - 1.0).\n"
357 "   :type b: float\n"
358 "   :arg a: Shadow color (alpha channel 0.0 - 1.0).\n"
359 "   :type a: float\n"
360 );
361 static PyObject *py_blf_shadow(PyObject *UNUSED(self), PyObject *args)
362 {
363         int level, fontid;
364         float rgba[4];
365
366         if (!PyArg_ParseTuple(
367                 args, "iiffff:blf.shadow",
368                 &fontid, &level, &rgba[0], &rgba[1], &rgba[2], &rgba[3]))
369         {
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 font use 0.\n"
389 "   :type fontid: int\n"
390 "   :arg x: Vertical shadow offset value in pixels.\n"
391 "   :type x: float\n"
392 "   :arg y: Horizontal shadow offset value in pixels.\n"
393 "   :type y: float\n"
394 );
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         BLF_shadow_offset(fontid, x, y);
403
404         Py_RETURN_NONE;
405 }
406
407 PyDoc_STRVAR(py_blf_load_doc,
408 ".. function:: load(filename)\n"
409 "\n"
410 "   Load a new font.\n"
411 "\n"
412 "   :arg filename: the filename of the font.\n"
413 "   :type filename: string\n"
414 "   :return: the new font's fontid or -1 if there was an error.\n"
415 "   :rtype: integer\n"
416 );
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         return PyLong_FromLong(BLF_load(filename));
425 }
426
427 PyDoc_STRVAR(py_blf_unload_doc,
428 ".. function:: unload(filename)\n"
429 "\n"
430 "   Unload an existing font.\n"
431 "\n"
432 "   :arg filename: the filename of the font.\n"
433 "   :type filename: string\n"
434 );
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         BLF_unload(filename);
443
444         Py_RETURN_NONE;
445 }
446
447 /*----------------------------MODULE INIT-------------------------*/
448 static PyMethodDef BLF_methods[] = {
449         {"aspect", (PyCFunction) py_blf_aspect, METH_VARARGS, py_blf_aspect_doc},
450 #if BLF_BLUR_ENABLE
451         {"blur", (PyCFunction) py_blf_blur, METH_VARARGS, py_blf_blur_doc},
452 #endif
453         {"clipping", (PyCFunction) py_blf_clipping, METH_VARARGS, py_blf_clipping_doc},
454         {"word_wrap", (PyCFunction) py_blf_word_wrap, METH_VARARGS, py_blf_word_wrap_doc},
455         {"disable", (PyCFunction) py_blf_disable, METH_VARARGS, py_blf_disable_doc},
456         {"dimensions", (PyCFunction) py_blf_dimensions, METH_VARARGS, py_blf_dimensions_doc},
457         {"draw", (PyCFunction) py_blf_draw, METH_VARARGS, py_blf_draw_doc},
458         {"enable", (PyCFunction) py_blf_enable, METH_VARARGS, py_blf_enable_doc},
459         {"position", (PyCFunction) py_blf_position, METH_VARARGS, py_blf_position_doc},
460         {"rotation", (PyCFunction) py_blf_rotation, METH_VARARGS, py_blf_rotation_doc},
461         {"shadow", (PyCFunction) py_blf_shadow, METH_VARARGS, py_blf_shadow_doc},
462         {"shadow_offset", (PyCFunction) py_blf_shadow_offset, METH_VARARGS, py_blf_shadow_offset_doc},
463         {"size", (PyCFunction) py_blf_size, METH_VARARGS, py_blf_size_doc},
464         {"color", (PyCFunction) py_blf_color, METH_VARARGS, py_blf_color_doc},
465         {"load", (PyCFunction) py_blf_load, METH_VARARGS, py_blf_load_doc},
466         {"unload", (PyCFunction) py_blf_unload, METH_VARARGS, py_blf_unload_doc},
467         {NULL, NULL, 0, NULL},
468 };
469
470 PyDoc_STRVAR(BLF_doc,
471 "This module provides access to blenders text drawing functions."
472 );
473 static struct PyModuleDef BLF_module_def = {
474         PyModuleDef_HEAD_INIT,
475         "blf",  /* m_name */
476         BLF_doc,  /* m_doc */
477         0,  /* m_size */
478         BLF_methods,  /* m_methods */
479         NULL,  /* m_reload */
480         NULL,  /* m_traverse */
481         NULL,  /* m_clear */
482         NULL,  /* m_free */
483 };
484
485 PyObject *BPyInit_blf(void)
486 {
487         PyObject *submodule;
488
489         submodule = PyModule_Create(&BLF_module_def);
490
491         PyModule_AddIntConstant(submodule, "ROTATION", BLF_ROTATION);
492         PyModule_AddIntConstant(submodule, "CLIPPING", BLF_CLIPPING);
493         PyModule_AddIntConstant(submodule, "SHADOW", BLF_SHADOW);
494         PyModule_AddIntConstant(submodule, "KERNING_DEFAULT", BLF_KERNING_DEFAULT);
495         PyModule_AddIntConstant(submodule, "WORD_WRAP", BLF_WORD_WRAP);
496         PyModule_AddIntConstant(submodule, "MONOCHROME", BLF_MONOCHROME);
497
498         return submodule;
499 }