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