minor edits to exception formatting (remove ... or \n from suffix)
[blender.git] / source / blender / python / intern / bpy_operator.c
1
2 /**
3  * $Id$
4  *
5  * ***** BEGIN GPL LICENSE BLOCK *****
6  *
7  * This program is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License
9  * as published by the Free Software Foundation; either version 2
10  * of the License, or (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software Foundation,
19  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
20  *
21  * Contributor(s): Campbell Barton
22  *
23  * ***** END GPL LICENSE BLOCK *****
24  */
25
26 /* Note, this module is not to be used directly by the user.
27  * its accessed from blender with bpy.__ops__
28  * */
29
30 #include "bpy_operator.h"
31 #include "bpy_operator_wrap.h"
32 #include "bpy_rna.h" /* for setting arg props only - pyrna_py_to_prop() */
33 #include "bpy_util.h"
34
35 #include "RNA_enum_types.h"
36
37 #include "WM_api.h"
38 #include "WM_types.h"
39
40 #include "MEM_guardedalloc.h"
41 #include "BKE_report.h"
42
43 static PyObject *pyop_poll(PyObject *UNUSED(self), PyObject *args)
44 {
45         wmOperatorType *ot;
46         char            *opname;
47         PyObject        *context_dict= NULL; /* optional args */
48         PyObject        *context_dict_back;
49         char            *context_str= NULL;
50         PyObject        *ret;
51
52         int context= WM_OP_EXEC_DEFAULT;
53
54         // XXX Todo, work out a better solution for passing on context, could make a tuple from self and pack the name and Context into it...
55         bContext *C = BPy_GetContext();
56         
57         if (!PyArg_ParseTuple(args, "s|Os:_bpy.ops.poll", &opname, &context_dict, &context_str))
58                 return NULL;
59         
60         ot= WM_operatortype_find(opname, TRUE);
61
62         if (ot == NULL) {
63                 PyErr_Format(PyExc_SystemError, "Polling operator \"bpy.ops.%s\" error, could not be found", opname);
64                 return NULL;
65         }
66
67         if(context_str) {
68                 if(RNA_enum_value_from_id(operator_context_items, context_str, &context)==0) {
69                         char *enum_str= BPy_enum_as_string(operator_context_items);
70                         PyErr_Format(PyExc_TypeError, "Calling operator \"bpy.ops.%s.poll\" error, expected a string enum in (%.200s)", opname, enum_str);
71                         MEM_freeN(enum_str);
72                         return NULL;
73                 }
74         }
75         
76         if(context_dict==NULL || context_dict==Py_None) {
77                 context_dict= NULL;
78         }
79         else if (!PyDict_Check(context_dict)) {
80                 PyErr_Format(PyExc_TypeError, "Calling operator \"bpy.ops.%s.poll\" error, custom context expected a dict or None, got a %.200s", opname, Py_TYPE(context_dict)->tp_name);
81                 return NULL;
82         }
83
84         context_dict_back= CTX_py_dict_get(C);
85
86         CTX_py_dict_set(C, (void *)context_dict);
87         Py_XINCREF(context_dict); /* so we done loose it */
88         
89         /* main purpose of thsi function */
90         ret= WM_operator_poll_context((bContext*)C, ot, context) ? Py_True : Py_False;
91         
92         /* restore with original context dict, probably NULL but need this for nested operator calls */
93         Py_XDECREF(context_dict);
94         CTX_py_dict_set(C, (void *)context_dict_back);
95         
96         Py_INCREF(ret);
97         return ret;
98 }
99
100 static PyObject *pyop_call(PyObject *UNUSED(self), PyObject *args)
101 {
102         wmOperatorType *ot;
103         int error_val = 0;
104         PointerRNA ptr;
105         int operator_ret= OPERATOR_CANCELLED;
106
107         char            *opname;
108         char            *context_str= NULL;
109         PyObject        *kw= NULL; /* optional args */
110         PyObject        *context_dict= NULL; /* optional args */
111         PyObject        *context_dict_back;
112
113         /* note that context is an int, python does the conversion in this case */
114         int context= WM_OP_EXEC_DEFAULT;
115
116         // XXX Todo, work out a better solution for passing on context, could make a tuple from self and pack the name and Context into it...
117         bContext *C = BPy_GetContext();
118         
119         if (!PyArg_ParseTuple(args, "sO|O!s:_bpy.ops.call", &opname, &context_dict, &PyDict_Type, &kw, &context_str))
120                 return NULL;
121
122         ot= WM_operatortype_find(opname, TRUE);
123
124         if (ot == NULL) {
125                 PyErr_Format(PyExc_SystemError, "Calling operator \"bpy.ops.%s\" error, could not be found", opname);
126                 return NULL;
127         }
128         
129         if(context_str) {
130                 if(RNA_enum_value_from_id(operator_context_items, context_str, &context)==0) {
131                         char *enum_str= BPy_enum_as_string(operator_context_items);
132                         PyErr_Format(PyExc_TypeError, "Calling operator \"bpy.ops.%s\" error, expected a string enum in (%.200s)", opname, enum_str);
133                         MEM_freeN(enum_str);
134                         return NULL;
135                 }
136         }
137
138         if(context_dict==NULL || context_dict==Py_None) {
139                 context_dict= NULL;
140         }
141         else if (!PyDict_Check(context_dict)) {
142                 PyErr_Format(PyExc_TypeError, "Calling operator \"bpy.ops.%s\" error, custom context expected a dict or None, got a %.200s", opname, Py_TYPE(context_dict)->tp_name);
143                 return NULL;
144         }
145
146         context_dict_back= CTX_py_dict_get(C);
147
148         CTX_py_dict_set(C, (void *)context_dict);
149         Py_XINCREF(context_dict); /* so we done loose it */
150
151         if(WM_operator_poll_context((bContext*)C, ot, context) == FALSE) {
152                 const char *msg= CTX_wm_operator_poll_msg_get(C);
153                 PyErr_Format(PyExc_SystemError, "Operator bpy.ops.%.200s.poll() %.200s", opname, msg ? msg : "failed, context is incorrect");
154                 CTX_wm_operator_poll_msg_set(C, NULL); /* better set to NULL else it could be used again */
155                 error_val= -1;
156         }
157         else {
158                 WM_operator_properties_create_ptr(&ptr, ot);
159                 WM_operator_properties_sanitize(&ptr, 0);
160
161                 if(kw && PyDict_Size(kw))
162                         error_val= pyrna_pydict_to_props(&ptr, kw, 0, "Converting py args to operator properties: ");
163
164
165                 if (error_val==0) {
166                         ReportList *reports;
167
168                         reports= MEM_mallocN(sizeof(ReportList), "wmOperatorReportList");
169                         BKE_reports_init(reports, RPT_STORE);
170
171                         operator_ret= WM_operator_call_py(C, ot, context, &ptr, reports);
172
173                         if(BPy_reports_to_error(reports))
174                                 error_val = -1;
175
176                         /* operator output is nice to have in the terminal/console too */
177                         if(reports->list.first) {
178                                 char *report_str= BKE_reports_string(reports, 0); /* all reports */
179         
180                                 if(report_str) {
181                                         PySys_WriteStdout("%s\n", report_str);
182                                         MEM_freeN(report_str);
183                                 }
184                         }
185         
186                         BKE_reports_clear(reports);
187                         if ((reports->flag & RPT_FREE) == 0)
188                         {
189                                 MEM_freeN(reports);
190                         }
191                 }
192
193                 WM_operator_properties_free(&ptr);
194
195 #if 0
196                 /* if there is some way to know an operator takes args we should use this */
197                 {
198                         /* no props */
199                         if (kw != NULL) {
200                                 PyErr_Format(PyExc_AttributeError, "Operator \"%s\" does not take any args", opname);
201                                 return NULL;
202                         }
203
204                         WM_operator_name_call(C, opname, WM_OP_EXEC_DEFAULT, NULL);
205                 }
206 #endif
207         }
208
209         /* restore with original context dict, probably NULL but need this for nested operator calls */
210         Py_XDECREF(context_dict);
211         CTX_py_dict_set(C, (void *)context_dict_back);
212
213         if (error_val==-1) {
214                 return NULL;
215         }
216
217         /* return operator_ret as a bpy enum */
218         return pyrna_enum_bitfield_to_py(operator_return_items, operator_ret);
219
220 }
221
222 static PyObject *pyop_as_string(PyObject *UNUSED(self), PyObject *args)
223 {
224         wmOperatorType *ot;
225         PointerRNA ptr;
226
227         char            *opname;
228         PyObject        *kw= NULL; /* optional args */
229         int all_args = 1;
230         int error_val= 0;
231
232         char *buf = NULL;
233         PyObject *pybuf;
234
235         bContext *C = BPy_GetContext();
236
237         if (!PyArg_ParseTuple(args, "s|O!i:_bpy.ops.as_string", &opname, &PyDict_Type, &kw, &all_args))
238                 return NULL;
239
240         ot= WM_operatortype_find(opname, TRUE);
241
242         if (ot == NULL) {
243                 PyErr_Format(PyExc_SystemError, "_bpy.ops.as_string: operator \"%.200s\"could not be found", opname);
244                 return NULL;
245         }
246
247         /* WM_operator_properties_create(&ptr, opname); */
248         /* Save another lookup */
249         RNA_pointer_create(NULL, ot->srna, NULL, &ptr);
250
251         if(kw && PyDict_Size(kw))
252                 error_val= pyrna_pydict_to_props(&ptr, kw, 0, "Converting py args to operator properties: ");
253
254         if (error_val==0)
255                 buf= WM_operator_pystring(C, ot, &ptr, all_args);
256
257         WM_operator_properties_free(&ptr);
258
259         if (error_val==-1) {
260                 return NULL;
261         }
262
263         if(buf) {
264                 pybuf= PyUnicode_FromString(buf);
265                 MEM_freeN(buf);
266         }
267         else {
268                 pybuf= PyUnicode_FromString("");
269         }
270
271         return pybuf;
272 }
273
274 static PyObject *pyop_dir(PyObject *UNUSED(self))
275 {
276         PyObject *list = PyList_New(0), *name;
277         wmOperatorType *ot;
278         
279         for(ot= WM_operatortype_first(); ot; ot= ot->next) {
280                 name = PyUnicode_FromString(ot->idname);
281                 PyList_Append(list, name);
282                 Py_DECREF(name);
283         }
284         
285         return list;
286 }
287
288 static PyObject *pyop_getrna(PyObject *UNUSED(self), PyObject *value)
289 {
290         wmOperatorType *ot;
291         PointerRNA ptr;
292         char *opname= _PyUnicode_AsString(value);
293         BPy_StructRNA *pyrna= NULL;
294         
295         if(opname==NULL) {
296                 PyErr_SetString(PyExc_TypeError, "_bpy.ops.get_rna() expects a string argument");
297                 return NULL;
298         }
299         ot= WM_operatortype_find(opname, TRUE);
300         if(ot==NULL) {
301                 PyErr_Format(PyExc_KeyError, "_bpy.ops.get_rna(\"%s\") not found", opname);
302                 return NULL;
303         }
304         
305         /* type */
306         //RNA_pointer_create(NULL, &RNA_Struct, ot->srna, &ptr);
307
308         /* XXX - should call WM_operator_properties_free */
309         WM_operator_properties_create_ptr(&ptr, ot);
310         WM_operator_properties_sanitize(&ptr, 0);
311
312         
313         pyrna= (BPy_StructRNA *)pyrna_struct_CreatePyObject(&ptr);
314         pyrna->freeptr= TRUE;
315         return (PyObject *)pyrna;
316 }
317
318 static struct PyMethodDef bpy_ops_methods[] = {
319         {"poll", (PyCFunction) pyop_poll, METH_VARARGS, NULL},
320         {"call", (PyCFunction) pyop_call, METH_VARARGS, NULL},
321         {"as_string", (PyCFunction) pyop_as_string, METH_VARARGS, NULL},
322         {"dir", (PyCFunction) pyop_dir, METH_NOARGS, NULL},
323         {"get_rna", (PyCFunction) pyop_getrna, METH_O, NULL},
324         {"macro_define", (PyCFunction) PYOP_wrap_macro_define, METH_VARARGS, NULL},
325         {NULL, NULL, 0, NULL}
326 };
327
328 static struct PyModuleDef bpy_ops_module = {
329         PyModuleDef_HEAD_INIT,
330         "_bpy.ops",
331         NULL,
332         -1,/* multiple "initialization" just copies the module dict. */
333         bpy_ops_methods,
334         NULL, NULL, NULL, NULL
335 };
336
337 PyObject *BPY_operator_module(void)
338 {
339         PyObject *submodule;
340
341         submodule= PyModule_Create(&bpy_ops_module);
342
343         return submodule;
344 }