option so operators can be executed with undo enabled (and redo).
[blender.git] / source / blender / python / intern / bpy_operator.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * Contributor(s): Campbell Barton
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22
23 /** \file blender/python/intern/bpy_operator.c
24  *  \ingroup pythonintern
25  *
26  * This file defines '_bpy.ops', an internal python module which gives python
27  * the ability to inspect and call both C and Python defined operators.
28  *
29  * \note
30  * This module is exposed to the user via 'release/scripts/modules/bpy/ops.py'
31  * which fakes exposing operators as modules/functions using its own classes.
32  */
33
34 #include <Python.h>
35
36 #include "RNA_types.h"
37
38 #include "BPY_extern.h"
39 #include "bpy_operator.h"
40 #include "bpy_operator_wrap.h"
41 #include "bpy_rna.h" /* for setting arg props only - pyrna_py_to_prop() */
42 #include "bpy_util.h"
43 #include "../generic/bpy_internal_import.h"
44
45 #include "BLI_utildefines.h"
46 #include "BLI_string.h"
47
48 #include "RNA_access.h"
49 #include "RNA_enum_types.h"
50
51 #include "WM_api.h"
52 #include "WM_types.h"
53
54 #include "MEM_guardedalloc.h"
55
56 #include "BLI_ghash.h"
57
58 #include "BKE_report.h"
59 #include "BKE_context.h"
60
61 /* so operators called can spawn threads which aquire the GIL */
62 #define BPY_RELEASE_GIL
63
64
65 static PyObject *pyop_poll(PyObject *UNUSED(self), PyObject *args)
66 {
67         wmOperatorType *ot;
68         char     *opname;
69         PyObject *context_dict = NULL; /* optional args */
70         PyObject *context_dict_back;
71         char     *context_str = NULL;
72         PyObject *ret;
73
74         int context = WM_OP_EXEC_DEFAULT;
75
76         /* XXX Todo, work out a better solution for passing on context,
77          * could make a tuple from self and pack the name and Context into it... */
78         bContext *C = (bContext *)BPy_GetContext();
79         
80         if (C == NULL) {
81                 PyErr_SetString(PyExc_RuntimeError, "Context is None, cant poll any operators");
82                 return NULL;
83         }
84
85         if (!PyArg_ParseTuple(args, "s|Os:_bpy.ops.poll", &opname, &context_dict, &context_str))
86                 return NULL;
87         
88         ot = WM_operatortype_find(opname, TRUE);
89
90         if (ot == NULL) {
91                 PyErr_Format(PyExc_AttributeError,
92                              "Polling operator \"bpy.ops.%s\" error, "
93                              "could not be found", opname);
94                 return NULL;
95         }
96
97         if (context_str) {
98                 if (RNA_enum_value_from_id(operator_context_items, context_str, &context) == 0) {
99                         char *enum_str = BPy_enum_as_string(operator_context_items);
100                         PyErr_Format(PyExc_TypeError,
101                                      "Calling operator \"bpy.ops.%s.poll\" error, "
102                                      "expected a string enum in (%.200s)",
103                                      opname, enum_str);
104                         MEM_freeN(enum_str);
105                         return NULL;
106                 }
107         }
108         
109         if (context_dict == NULL || context_dict == Py_None) {
110                 context_dict = NULL;
111         }
112         else if (!PyDict_Check(context_dict)) {
113                 PyErr_Format(PyExc_TypeError,
114                              "Calling operator \"bpy.ops.%s.poll\" error, "
115                              "custom context expected a dict or None, got a %.200s",
116                              opname, Py_TYPE(context_dict)->tp_name);
117                 return NULL;
118         }
119
120         context_dict_back = CTX_py_dict_get(C);
121         CTX_py_dict_set(C, (void *)context_dict);
122         Py_XINCREF(context_dict); /* so we done loose it */
123         
124         /* main purpose of thsi function */
125         ret = WM_operator_poll_context((bContext *)C, ot, context) ? Py_True : Py_False;
126         
127         /* restore with original context dict, probably NULL but need this for nested operator calls */
128         Py_XDECREF(context_dict);
129         CTX_py_dict_set(C, (void *)context_dict_back);
130         
131         Py_INCREF(ret);
132         return ret;
133 }
134
135 static PyObject *pyop_call(PyObject *UNUSED(self), PyObject *args)
136 {
137         wmOperatorType *ot;
138         int error_val = 0;
139         PointerRNA ptr;
140         int operator_ret = OPERATOR_CANCELLED;
141
142         char     *opname;
143         char     *context_str = NULL;
144         PyObject *kw = NULL; /* optional args */
145         PyObject *context_dict = NULL; /* optional args */
146         PyObject *context_dict_back;
147
148         /* note that context is an int, python does the conversion in this case */
149         int context = WM_OP_EXEC_DEFAULT;
150         int is_undo = FALSE;
151
152         /* XXX Todo, work out a better solution for passing on context,
153          * could make a tuple from self and pack the name and Context into it... */
154         bContext *C = (bContext *)BPy_GetContext();
155         
156         if (C == NULL) {
157                 PyErr_SetString(PyExc_RuntimeError, "Context is None, cant poll any operators");
158                 return NULL;
159         }
160         
161         if (!PyArg_ParseTuple(args, "sO|O!si:_bpy.ops.call",
162                               &opname, &context_dict, &PyDict_Type, &kw, &context_str, &is_undo))
163                 return NULL;
164
165         ot = WM_operatortype_find(opname, TRUE);
166
167         if (ot == NULL) {
168                 PyErr_Format(PyExc_AttributeError,
169                              "Calling operator \"bpy.ops.%s\" error, "
170                              "could not be found", opname);
171                 return NULL;
172         }
173         
174         if (!pyrna_write_check()) {
175                 PyErr_Format(PyExc_RuntimeError,
176                              "Calling operator \"bpy.ops.%s\" error, "
177                              "can't modify blend data in this state (drawing/rendering)",
178                              opname);
179                 return NULL;
180         }
181
182         if (context_str) {
183                 if (RNA_enum_value_from_id(operator_context_items, context_str, &context) == 0) {
184                         char *enum_str = BPy_enum_as_string(operator_context_items);
185                         PyErr_Format(PyExc_TypeError,
186                                      "Calling operator \"bpy.ops.%s\" error, "
187                                      "expected a string enum in (%.200s)",
188                                      opname, enum_str);
189                         MEM_freeN(enum_str);
190                         return NULL;
191                 }
192         }
193
194         if (context_dict == NULL || context_dict == Py_None) {
195                 context_dict = NULL;
196         }
197         else if (!PyDict_Check(context_dict)) {
198                 PyErr_Format(PyExc_TypeError,
199                              "Calling operator \"bpy.ops.%s\" error, "
200                              "custom context expected a dict or None, got a %.200s",
201                              opname, Py_TYPE(context_dict)->tp_name);
202                 return NULL;
203         }
204
205         context_dict_back = CTX_py_dict_get(C);
206
207         CTX_py_dict_set(C, (void *)context_dict);
208         Py_XINCREF(context_dict); /* so we done loose it */
209
210         if (WM_operator_poll_context((bContext *)C, ot, context) == FALSE) {
211                 const char *msg = CTX_wm_operator_poll_msg_get(C);
212                 PyErr_Format(PyExc_RuntimeError,
213                              "Operator bpy.ops.%.200s.poll() %.200s",
214                              opname, msg ? msg : "failed, context is incorrect");
215                 CTX_wm_operator_poll_msg_set(C, NULL); /* better set to NULL else it could be used again */
216                 error_val = -1;
217         }
218         else {
219                 WM_operator_properties_create_ptr(&ptr, ot);
220                 WM_operator_properties_sanitize(&ptr, 0);
221
222                 if (kw && PyDict_Size(kw))
223                         error_val = pyrna_pydict_to_props(&ptr, kw, 0, "Converting py args to operator properties: ");
224
225
226                 if (error_val == 0) {
227                         ReportList *reports;
228
229                         reports = MEM_mallocN(sizeof(ReportList), "wmOperatorReportList");
230                         BKE_reports_init(reports, RPT_STORE | RPT_OP_HOLD); /* own so these don't move into global reports */
231
232 #ifdef BPY_RELEASE_GIL
233                         /* release GIL, since a thread could be started from an operator
234                          * that updates a driver */
235                         /* note: I havve not seen any examples of code that does this
236                          * so it may not be officially supported but seems to work ok. */
237                         {
238                                 PyThreadState *ts = PyEval_SaveThread();
239 #endif
240
241                                 operator_ret = WM_operator_call_py(C, ot, context, &ptr, reports, is_undo);
242
243 #ifdef BPY_RELEASE_GIL
244                                 /* regain GIL */
245                                 PyEval_RestoreThread(ts);
246                         }
247 #endif
248
249                         error_val = BPy_reports_to_error(reports, PyExc_RuntimeError, FALSE);
250
251                         /* operator output is nice to have in the terminal/console too */
252                         if (reports->list.first) {
253                                 char *report_str = BKE_reports_string(reports, 0); /* all reports */
254         
255                                 if (report_str) {
256                                         PySys_WriteStdout("%s\n", report_str);
257                                         MEM_freeN(report_str);
258                                 }
259                         }
260         
261                         BKE_reports_clear(reports);
262                         if ((reports->flag & RPT_FREE) == 0) {
263                                 MEM_freeN(reports);
264                         }
265                 }
266
267                 WM_operator_properties_free(&ptr);
268
269 #if 0
270                 /* if there is some way to know an operator takes args we should use this */
271                 {
272                         /* no props */
273                         if (kw != NULL) {
274                                 PyErr_Format(PyExc_AttributeError,
275                                              "Operator \"%s\" does not take any args",
276                                              opname);
277                                 return NULL;
278                         }
279
280                         WM_operator_name_call(C, opname, WM_OP_EXEC_DEFAULT, NULL);
281                 }
282 #endif
283         }
284
285         /* restore with original context dict, probably NULL but need this for nested operator calls */
286         Py_XDECREF(context_dict);
287         CTX_py_dict_set(C, (void *)context_dict_back);
288
289         if (error_val == -1) {
290                 return NULL;
291         }
292
293         /* when calling  bpy.ops.wm.read_factory_settings() bpy.data's main pointer is freed by clear_globals(),
294          * further access will crash blender. setting context is not needed in this case, only calling because this
295          * function corrects bpy.data (internal Main pointer) */
296         BPY_modules_update(C);
297
298         /* needed for when WM_OT_read_factory_settings us called from within a script */
299         bpy_import_main_set(CTX_data_main(C));
300
301         /* return operator_ret as a bpy enum */
302         return pyrna_enum_bitfield_to_py(operator_return_items, operator_ret);
303
304 }
305
306 static PyObject *pyop_as_string(PyObject *UNUSED(self), PyObject *args)
307 {
308         wmOperatorType *ot;
309         PointerRNA ptr;
310
311         char     *opname;
312         PyObject *kw = NULL; /* optional args */
313         int all_args = 1;
314         int error_val = 0;
315
316         char *buf = NULL;
317         PyObject *pybuf;
318
319         bContext *C = (bContext *)BPy_GetContext();
320
321         if (C == NULL) {
322                 PyErr_SetString(PyExc_RuntimeError, "Context is None, cant get the string representation of this object.");
323                 return NULL;
324         }
325         
326         if (!PyArg_ParseTuple(args, "s|O!i:_bpy.ops.as_string", &opname, &PyDict_Type, &kw, &all_args))
327                 return NULL;
328
329         ot = WM_operatortype_find(opname, TRUE);
330
331         if (ot == NULL) {
332                 PyErr_Format(PyExc_AttributeError,
333                              "_bpy.ops.as_string: operator \"%.200s\" "
334                              "could not be found", opname);
335                 return NULL;
336         }
337
338         /* WM_operator_properties_create(&ptr, opname); */
339         /* Save another lookup */
340         RNA_pointer_create(NULL, ot->srna, NULL, &ptr);
341
342         if (kw && PyDict_Size(kw))
343                 error_val = pyrna_pydict_to_props(&ptr, kw, 0, "Converting py args to operator properties: ");
344
345         if (error_val == 0)
346                 buf = WM_operator_pystring(C, ot, &ptr, all_args);
347
348         WM_operator_properties_free(&ptr);
349
350         if (error_val == -1) {
351                 return NULL;
352         }
353
354         if (buf) {
355                 pybuf = PyUnicode_FromString(buf);
356                 MEM_freeN(buf);
357         }
358         else {
359                 pybuf = PyUnicode_FromString("");
360         }
361
362         return pybuf;
363 }
364
365 static PyObject *pyop_dir(PyObject *UNUSED(self))
366 {
367         GHashIterator *iter = WM_operatortype_iter();
368         PyObject *list = PyList_New(0), *name;
369
370         for ( ; !BLI_ghashIterator_isDone(iter); BLI_ghashIterator_step(iter)) {
371                 wmOperatorType *ot = BLI_ghashIterator_getValue(iter);
372
373                 name = PyUnicode_FromString(ot->idname);
374                 PyList_Append(list, name);
375                 Py_DECREF(name);
376         }
377         BLI_ghashIterator_free(iter);
378
379         return list;
380 }
381
382 static PyObject *pyop_getrna(PyObject *UNUSED(self), PyObject *value)
383 {
384         wmOperatorType *ot;
385         PointerRNA ptr;
386         const char *opname = _PyUnicode_AsString(value);
387         BPy_StructRNA *pyrna = NULL;
388         
389         if (opname == NULL) {
390                 PyErr_SetString(PyExc_TypeError, "_bpy.ops.get_rna() expects a string argument");
391                 return NULL;
392         }
393         ot = WM_operatortype_find(opname, TRUE);
394         if (ot == NULL) {
395                 PyErr_Format(PyExc_KeyError, "_bpy.ops.get_rna(\"%s\") not found", opname);
396                 return NULL;
397         }
398         
399         /* type */
400         //RNA_pointer_create(NULL, &RNA_Struct, ot->srna, &ptr);
401
402         /* XXX - should call WM_operator_properties_free */
403         WM_operator_properties_create_ptr(&ptr, ot);
404         WM_operator_properties_sanitize(&ptr, 0);
405
406         
407         pyrna = (BPy_StructRNA *)pyrna_struct_CreatePyObject(&ptr);
408 #ifdef PYRNA_FREE_SUPPORT
409         pyrna->freeptr = TRUE;
410 #endif
411         return (PyObject *)pyrna;
412 }
413
414 static PyObject *pyop_getinstance(PyObject *UNUSED(self), PyObject *value)
415 {
416         wmOperatorType *ot;
417         wmOperator *op;
418         PointerRNA ptr;
419         const char *opname = _PyUnicode_AsString(value);
420         BPy_StructRNA *pyrna = NULL;
421
422         if (opname == NULL) {
423                 PyErr_SetString(PyExc_TypeError, "_bpy.ops.get_instance() expects a string argument");
424                 return NULL;
425         }
426         ot = WM_operatortype_find(opname, TRUE);
427         if (ot == NULL) {
428                 PyErr_Format(PyExc_KeyError, "_bpy.ops.get_instance(\"%s\") not found", opname);
429                 return NULL;
430         }
431
432 #ifdef PYRNA_FREE_SUPPORT
433         op = MEM_callocN(sizeof(wmOperator), __func__);
434 #else
435         op = PyMem_MALLOC(sizeof(wmOperator));
436         memset(op, 0, sizeof(wmOperator));
437 #endif
438         BLI_strncpy(op->idname, op->idname, sizeof(op->idname)); /* in case its needed */
439         op->type = ot;
440
441         RNA_pointer_create(NULL, &RNA_Operator, op, &ptr);
442
443         pyrna = (BPy_StructRNA *)pyrna_struct_CreatePyObject(&ptr);
444 #ifdef PYRNA_FREE_SUPPORT
445         pyrna->freeptr = TRUE;
446 #endif
447         op->ptr = &pyrna->ptr;
448
449         return (PyObject *)pyrna;
450 }
451
452 static struct PyMethodDef bpy_ops_methods[] = {
453         {"poll", (PyCFunction) pyop_poll, METH_VARARGS, NULL},
454         {"call", (PyCFunction) pyop_call, METH_VARARGS, NULL},
455         {"as_string", (PyCFunction) pyop_as_string, METH_VARARGS, NULL},
456         {"dir", (PyCFunction) pyop_dir, METH_NOARGS, NULL},
457         {"get_rna", (PyCFunction) pyop_getrna, METH_O, NULL},           /* only for introspection, leaks memory */
458         {"get_instance", (PyCFunction) pyop_getinstance, METH_O, NULL}, /* only for introspection, leaks memory */
459         {"macro_define", (PyCFunction) PYOP_wrap_macro_define, METH_VARARGS, NULL},
460         {NULL, NULL, 0, NULL}
461 };
462
463 static struct PyModuleDef bpy_ops_module = {
464         PyModuleDef_HEAD_INIT,
465         "_bpy.ops",
466         NULL,
467         -1, /* multiple "initialization" just copies the module dict. */
468         bpy_ops_methods,
469         NULL, NULL, NULL, NULL
470 };
471
472 PyObject *BPY_operator_module(void)
473 {
474         PyObject *submodule;
475
476         submodule = PyModule_Create(&bpy_ops_module);
477
478         return submodule;
479 }