e78e79fd6a825ebb341c6b7ef60da47775c400f3
[blender-staging.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() %s", 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
160                 if(kw && PyDict_Size(kw))
161                         error_val= pyrna_pydict_to_props(&ptr, kw, 0, "Converting py args to operator properties: ");
162
163
164                 if (error_val==0) {
165                         ReportList *reports;
166
167                         reports= MEM_mallocN(sizeof(ReportList), "wmOperatorReportList");
168                         BKE_reports_init(reports, RPT_STORE);
169
170                         operator_ret= WM_operator_call_py(C, ot, context, &ptr, reports);
171
172                         if(BPy_reports_to_error(reports))
173                                 error_val = -1;
174
175                         /* operator output is nice to have in the terminal/console too */
176                         if(reports->list.first) {
177                                 char *report_str= BKE_reports_string(reports, 0); /* all reports */
178         
179                                 if(report_str) {
180                                         PySys_WriteStdout("%s\n", report_str);
181                                         MEM_freeN(report_str);
182                                 }
183                         }
184         
185                         BKE_reports_clear(reports);
186                         if ((reports->flag & RPT_FREE) == 0)
187                         {
188                                 MEM_freeN(reports);
189                         }
190                 }
191
192                 WM_operator_properties_free(&ptr);
193
194 #if 0
195                 /* if there is some way to know an operator takes args we should use this */
196                 {
197                         /* no props */
198                         if (kw != NULL) {
199                                 PyErr_Format(PyExc_AttributeError, "Operator \"%s\" does not take any args", opname);
200                                 return NULL;
201                         }
202
203                         WM_operator_name_call(C, opname, WM_OP_EXEC_DEFAULT, NULL);
204                 }
205 #endif
206         }
207
208         /* restore with original context dict, probably NULL but need this for nested operator calls */
209         Py_XDECREF(context_dict);
210         CTX_py_dict_set(C, (void *)context_dict_back);
211
212         if (error_val==-1) {
213                 return NULL;
214         }
215
216         /* return operator_ret as a bpy enum */
217         return pyrna_enum_bitfield_to_py(operator_return_items, operator_ret);
218
219 }
220
221 static PyObject *pyop_as_string(PyObject *UNUSED(self), PyObject *args)
222 {
223         wmOperatorType *ot;
224         PointerRNA ptr;
225
226         char            *opname;
227         PyObject        *kw= NULL; /* optional args */
228         int all_args = 1;
229         int error_val= 0;
230
231         char *buf = NULL;
232         PyObject *pybuf;
233
234         bContext *C = BPy_GetContext();
235
236         if (!PyArg_ParseTuple(args, "s|O!i:_bpy.ops.as_string", &opname, &PyDict_Type, &kw, &all_args))
237                 return NULL;
238
239         ot= WM_operatortype_find(opname, TRUE);
240
241         if (ot == NULL) {
242                 PyErr_Format( PyExc_SystemError, "_bpy.ops.as_string: operator \"%s\"could not be found", opname);
243                 return NULL;
244         }
245
246         /* WM_operator_properties_create(&ptr, opname); */
247         /* Save another lookup */
248         RNA_pointer_create(NULL, ot->srna, NULL, &ptr);
249
250         if(kw && PyDict_Size(kw))
251                 error_val= pyrna_pydict_to_props(&ptr, kw, 0, "Converting py args to operator properties: ");
252
253         if (error_val==0)
254                 buf= WM_operator_pystring(C, ot, &ptr, all_args);
255
256         WM_operator_properties_free(&ptr);
257
258         if (error_val==-1) {
259                 return NULL;
260         }
261
262         if(buf) {
263                 pybuf= PyUnicode_FromString(buf);
264                 MEM_freeN(buf);
265         }
266         else {
267                 pybuf= PyUnicode_FromString("");
268         }
269
270         return pybuf;
271 }
272
273 static PyObject *pyop_dir(PyObject *UNUSED(self))
274 {
275         PyObject *list = PyList_New(0), *name;
276         wmOperatorType *ot;
277         
278         for(ot= WM_operatortype_first(); ot; ot= ot->next) {
279                 name = PyUnicode_FromString(ot->idname);
280                 PyList_Append(list, name);
281                 Py_DECREF(name);
282         }
283         
284         return list;
285 }
286
287 static PyObject *pyop_getrna(PyObject *UNUSED(self), PyObject *value)
288 {
289         wmOperatorType *ot;
290         PointerRNA ptr;
291         char *opname= _PyUnicode_AsString(value);
292         BPy_StructRNA *pyrna= NULL;
293         
294         if(opname==NULL) {
295                 PyErr_SetString(PyExc_TypeError, "_bpy.ops.get_rna() expects a string argument");
296                 return NULL;
297         }
298         ot= WM_operatortype_find(opname, TRUE);
299         if(ot==NULL) {
300                 PyErr_Format(PyExc_KeyError, "_bpy.ops.get_rna(\"%s\") not found", opname);
301                 return NULL;
302         }
303         
304         /* type */
305         //RNA_pointer_create(NULL, &RNA_Struct, ot->srna, &ptr);
306
307         /* XXX - should call WM_operator_properties_free */
308         WM_operator_properties_create_ptr(&ptr, ot);
309
310         
311         pyrna= (BPy_StructRNA *)pyrna_struct_CreatePyObject(&ptr);
312         pyrna->freeptr= TRUE;
313         return (PyObject *)pyrna;
314 }
315
316 static struct PyMethodDef bpy_ops_methods[] = {
317         {"poll", (PyCFunction) pyop_poll, METH_VARARGS, NULL},
318         {"call", (PyCFunction) pyop_call, METH_VARARGS, NULL},
319         {"as_string", (PyCFunction) pyop_as_string, METH_VARARGS, NULL},
320         {"dir", (PyCFunction) pyop_dir, METH_NOARGS, NULL},
321         {"get_rna", (PyCFunction) pyop_getrna, METH_O, NULL},
322         {"macro_define", (PyCFunction) PYOP_wrap_macro_define, METH_VARARGS, NULL},
323         {NULL, NULL, 0, NULL}
324 };
325
326 static struct PyModuleDef bpy_ops_module = {
327         PyModuleDef_HEAD_INIT,
328         "_bpy.ops",
329         NULL,
330         -1,/* multiple "initialization" just copies the module dict. */
331         bpy_ops_methods,
332         NULL, NULL, NULL, NULL
333 };
334
335 PyObject *BPY_operator_module(void)
336 {
337         PyObject *submodule;
338
339         submodule= PyModule_Create(&bpy_ops_module);
340
341         return submodule;
342 }