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