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