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