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