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