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