f1cbd0f7e7e044442962644aff2330717349569b
[blender-staging.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(x, y, z)\n"
32 "\n"
33 "   Set the position for drawing text.\n";
34
35 static PyObject *py_blf_position(PyObject *self, PyObject *args)
36 {
37         float x, y, z;
38
39         if (!PyArg_ParseTuple(args, "fff:BLF.position", &x, &y, &z))
40                 return NULL;
41
42         BLF_position(x, y, z);
43
44         Py_RETURN_NONE;
45 }
46
47
48 static char py_blf_size_doc[] =
49 ".. function:: size(size, dpi)\n"
50 "\n"
51 "   Set the size and dpi for drawing text.\n"
52 "\n"
53 "   :arg size: Point size of the font.\n"
54 "   :type size: int\n"
55 "   :arg dpi: dots per inch value to use for drawing.\n"
56 "   :type dpi: int\n";
57
58 static PyObject *py_blf_size(PyObject *self, PyObject *args)
59 {
60         int size, dpi;
61
62         if (!PyArg_ParseTuple(args, "ii:BLF.size", &size, &dpi))
63                 return NULL;
64
65         BLF_size(size, dpi);
66
67         Py_RETURN_NONE;
68 }
69
70
71 static char py_blf_aspect_doc[] =
72 ".. function:: aspect(aspect)\n"
73 "\n"
74 "   Set the aspect for drawing text.\n"
75 "\n"
76 "   :arg aspect: The aspect ratio for text drawing to use.\n"
77 "   :type aspect: float\n";
78
79 static PyObject *py_blf_aspect(PyObject *self, PyObject *args)
80 {
81         float aspect;
82
83         if (!PyArg_ParseTuple(args, "f:BLF.aspect", &aspect))
84                 return NULL;
85
86         BLF_aspect(aspect);
87
88         Py_RETURN_NONE;
89 }
90
91
92 static char py_blf_blur_doc[] =
93 ".. function:: blur(radius)\n"
94 "\n"
95 "   Set the blur radius for drawing text.\n"
96 "\n"
97 "   :arg radius: The radius for blurring text (in pixels).\n"
98 "   :type radius: int\n";
99
100 static PyObject *py_blf_blur(PyObject *self, PyObject *args)
101 {
102         int blur;
103
104         if (!PyArg_ParseTuple(args, "i:BLF.blur", &blur))
105                 return NULL;
106
107         BLF_blur(blur);
108
109         Py_RETURN_NONE;
110 }
111
112
113 static char py_blf_draw_doc[] =
114 ".. function:: draw(text)\n"
115 "\n"
116 "   Draw text in the current context.\n"
117 "\n"
118 "   :arg text: the text to draw.\n"
119 "   :type text: string\n";
120
121 static PyObject *py_blf_draw(PyObject *self, PyObject *args)
122 {
123         char *text;
124
125         if (!PyArg_ParseTuple(args, "s:BLF.draw", &text))
126                 return NULL;
127
128         BLF_draw(text);
129
130         Py_RETURN_NONE;
131 }
132
133 static char py_blf_dimensions_doc[] =
134 ".. function:: dimensions(text)\n"
135 "\n"
136 "   Return the width and hight of the text.\n"
137 "\n"
138 "   :arg text: the text to draw.\n"
139 "   :type text: string\n"
140 "   :return: the width and height of the text.\n"
141 "   :rtype: tuple of 2 floats\n";
142
143 static PyObject *py_blf_dimensions(PyObject *self, PyObject *args)
144 {
145         char *text;
146         float r_width, r_height;
147         PyObject *ret;
148
149         if (!PyArg_ParseTuple(args, "s:BLF.dimensions", &text))
150                 return NULL;
151
152         BLF_width_and_height(text, &r_width, &r_height);
153
154         ret= PyTuple_New(2);
155         PyTuple_SET_ITEM(ret, 0, PyFloat_FromDouble(r_width));
156         PyTuple_SET_ITEM(ret, 1, PyFloat_FromDouble(r_height));
157         return ret;
158 }
159
160 static char py_blf_clipping_doc[] =
161 ".. function:: clipping(xmin, ymin, xmax, ymax)\n"
162 "\n"
163 "   Set the clipping, enable/disable using CLIPPING.\n";
164
165 static PyObject *py_blf_clipping(PyObject *self, PyObject *args)
166 {
167         float xmin, ymin, xmax, ymax;
168
169         if (!PyArg_ParseTuple(args, "ffff:BLF.clipping", &xmin, &ymin, &xmax, &ymax))
170                 return NULL;
171
172         BLF_clipping(xmin, ymin, xmax, ymax);
173
174         Py_RETURN_NONE;
175 }
176
177 static char py_blf_disable_doc[] =
178 ".. function:: disable(option)\n"
179 "\n"
180 "   Disable option.\n"
181 "\n"
182 "   :arg option: One of ROTATION, CLIPPING, SHADOW or KERNING_DEFAULT.\n"
183 "   :type option: int\n";
184
185 static PyObject *py_blf_disable(PyObject *self, PyObject *args)
186 {
187         int option;
188
189         if (!PyArg_ParseTuple(args, "i:BLF.disable", &option))
190                 return NULL;
191
192         BLF_disable(option);
193
194         Py_RETURN_NONE;
195 }
196
197 static char py_blf_enable_doc[] =
198 ".. function:: enable(option)\n"
199 "\n"
200 "   Enable option.\n"
201 "\n"
202 "   :arg option: One of ROTATION, CLIPPING, SHADOW or KERNING_DEFAULT.\n"
203 "   :type option: int\n";
204
205 static PyObject *py_blf_enable(PyObject *self, PyObject *args)
206 {
207         int option;
208
209         if (!PyArg_ParseTuple(args, "i:BLF.enable", &option))
210                 return NULL;
211
212         BLF_enable(option);
213
214         Py_RETURN_NONE;
215 }
216
217 static char py_blf_rotation_doc[] =
218 ".. function:: rotation(angle)\n"
219 "\n"
220 "   Set the text rotation angle, enable/disable using ROTATION.\n"
221 "\n"
222 "   :arg angle: The angle for text drawing to use.\n"
223 "   :type aspect: float\n";
224
225 static PyObject *py_blf_rotation(PyObject *self, PyObject *args)
226 {
227         float angle;
228
229         if (!PyArg_ParseTuple(args, "f:BLF.rotation", &angle))
230                 return NULL;
231                 
232         BLF_rotation(angle);
233
234         Py_RETURN_NONE;
235 }
236
237 static char py_blf_shadow_doc[] =
238 ".. function:: shadow(level, r, g, b, a)\n"
239 "\n"
240 "   Shadow options, enable/disable using SHADOW .\n"
241 "\n"
242 "   :arg level: The blur level, can be 3, 5 or 0.\n"
243 "   :type level: int\n";
244
245 static PyObject *py_blf_shadow(PyObject *self, PyObject *args)
246 {
247         int level;
248         float r, g, b, a;
249
250         if (!PyArg_ParseTuple(args, "iffff:BLF.shadow", &level, &r, &g, &b, &a))
251                 return NULL;
252
253         if (level != 0 && level != 3 && level != 5) {
254                 PyErr_SetString(PyExc_TypeError, "blf.shadow expected arg to be in (0, 3, 5)");
255                 return NULL;
256         }
257
258         BLF_shadow(level, r, g, b, a);
259
260         Py_RETURN_NONE;
261 }
262
263 static char py_blf_shadow_offset_doc[] =
264 ".. function:: shadow_offset(x, y)\n"
265 "\n"
266 "   Set the offset for shadow text.\n";
267
268 static PyObject *py_blf_shadow_offset(PyObject *self, PyObject *args)
269 {
270         int x, y;
271
272         if (!PyArg_ParseTuple(args, "ii:BLF.shadow_offset", &x, &y))
273                 return NULL;
274
275         BLF_shadow_offset(x, y);
276
277         Py_RETURN_NONE;
278 }
279
280 /*----------------------------MODULE INIT-------------------------*/
281 struct PyMethodDef BLF_methods[] = {
282         {"aspect", (PyCFunction) py_blf_aspect, METH_VARARGS, py_blf_aspect_doc},
283         {"blur", (PyCFunction) py_blf_blur, METH_VARARGS, py_blf_blur_doc},
284         {"clipping", (PyCFunction) py_blf_clipping, METH_VARARGS, py_blf_clipping_doc},
285         {"disable", (PyCFunction) py_blf_disable, METH_VARARGS, py_blf_disable_doc},
286         {"dimensions", (PyCFunction) py_blf_dimensions, METH_VARARGS, py_blf_dimensions_doc},
287         {"draw", (PyCFunction) py_blf_draw, METH_VARARGS, py_blf_draw_doc},
288         {"enable", (PyCFunction) py_blf_enable, METH_VARARGS, py_blf_enable_doc},
289         {"position", (PyCFunction)py_blf_position, METH_VARARGS, py_blf_position_doc},
290         {"rotation", (PyCFunction) py_blf_rotation, METH_VARARGS, py_blf_rotation_doc},
291         {"shadow", (PyCFunction) py_blf_shadow, METH_VARARGS, py_blf_shadow_doc},
292         {"shadow_offset", (PyCFunction) py_blf_shadow_offset, METH_VARARGS, py_blf_shadow_offset_doc},
293         {"size", (PyCFunction) py_blf_size, METH_VARARGS, py_blf_size_doc},
294         {NULL, NULL, 0, NULL}
295 };
296
297 static char BLF_doc[] =
298 "This module provides access to blenders text drawing functions.\n";
299
300 static struct PyModuleDef BLF_module_def = {
301         PyModuleDef_HEAD_INIT,
302         "blf",  /* m_name */
303         BLF_doc,  /* m_doc */
304         0,  /* m_size */
305         BLF_methods,  /* m_methods */
306         0,  /* m_reload */
307         0,  /* m_traverse */
308         0,  /* m_clear */
309         0,  /* m_free */
310 };
311
312 PyObject *BLF_Init(void)
313 {
314         PyObject *submodule;
315
316         submodule = PyModule_Create(&BLF_module_def);
317         PyDict_SetItemString(PySys_GetObject("modules"), BLF_module_def.m_name, submodule);
318
319         PyModule_AddIntConstant(submodule, "ROTATION", BLF_ROTATION);
320         PyModule_AddIntConstant(submodule, "CLIPPING", BLF_CLIPPING);
321         PyModule_AddIntConstant(submodule, "SHADOW", BLF_SHADOW);
322         PyModule_AddIntConstant(submodule, "KERNING_DEFAULT", BLF_KERNING_DEFAULT);
323
324         return (submodule);
325 }