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