Merge branch 'master' into blender2.8
[blender.git] / source / blender / makesrna / intern / rna_wm_api.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  * The Original Code is Copyright (C) 2009 Blender Foundation.
19  * All rights reserved.
20  *
21  *
22  * Contributor(s): Blender Foundation
23  *
24  * ***** END GPL LICENSE BLOCK *****
25  */
26
27 /** \file blender/makesrna/intern/rna_wm_api.c
28  *  \ingroup RNA
29  */
30
31
32 #include <stdlib.h>
33 #include <stdio.h>
34
35 #include "BLI_utildefines.h"
36
37 #include "RNA_define.h"
38 #include "RNA_enum_types.h"
39
40 #include "DNA_screen_types.h"
41 #include "DNA_space_types.h"
42 #include "DNA_windowmanager_types.h"
43
44 #include "wm_cursors.h"
45
46 #include "rna_internal.h"  /* own include */
47
48 /* confusingm 2 enums mixed up here */
49 const EnumPropertyItem rna_enum_window_cursor_items[] = {
50         {CURSOR_STD, "DEFAULT", 0, "Default", ""},
51         {CURSOR_NONE, "NONE", 0, "None", ""},
52         {CURSOR_WAIT, "WAIT", 0, "Wait", ""},
53         {CURSOR_EDIT, "CROSSHAIR", 0, "Crosshair", ""},
54         {CURSOR_X_MOVE, "MOVE_X", 0, "Move-X", ""},
55         {CURSOR_Y_MOVE, "MOVE_Y", 0, "Move-Y", ""},
56
57         /* new */
58         {BC_KNIFECURSOR, "KNIFE", 0, "Knife", ""},
59         {BC_TEXTEDITCURSOR, "TEXT", 0, "Text", ""},
60         {BC_PAINTBRUSHCURSOR, "PAINT_BRUSH", 0, "Paint Brush", ""},
61         {BC_HANDCURSOR, "HAND", 0, "Hand", ""},
62         {BC_EW_SCROLLCURSOR, "SCROLL_X", 0, "Scroll-X", ""},
63         {BC_NS_SCROLLCURSOR, "SCROLL_Y", 0, "Scroll-Y", ""},
64         {BC_NSEW_SCROLLCURSOR, "SCROLL_XY", 0, "Scroll-XY", ""},
65         {BC_EYEDROPPER_CURSOR, "EYEDROPPER", 0, "Eyedropper", ""},
66         {0, NULL, 0, NULL, NULL}
67 };
68
69 #ifdef RNA_RUNTIME
70
71 #include "UI_interface.h"
72 #include "BKE_context.h"
73
74 #include "WM_types.h"
75
76 static wmKeyMap *rna_keymap_active(wmKeyMap *km, bContext *C)
77 {
78         wmWindowManager *wm = CTX_wm_manager(C);
79         return WM_keymap_active(wm, km);
80 }
81
82 static void rna_keymap_restore_item_to_default(wmKeyMap *km, bContext *C, wmKeyMapItem *kmi)
83 {
84         WM_keymap_restore_item_to_default(C, km, kmi);
85 }
86
87 static void rna_Operator_report(wmOperator *op, int type, const char *msg)
88 {
89         BKE_report(op->reports, type, msg);
90 }
91
92 static int rna_Operator_is_repeat(wmOperator *op, bContext *C)
93 {
94         return WM_operator_is_repeat(C, op);
95 }
96
97 /* since event isn't needed... */
98 static void rna_Operator_enum_search_invoke(bContext *C, wmOperator *op)
99 {
100         WM_enum_search_invoke(C, op, NULL);
101         
102 }
103
104 static int rna_event_modal_handler_add(struct bContext *C, struct wmOperator *operator)
105 {
106         return WM_event_add_modal_handler(C, operator) != NULL;
107 }
108
109 /* XXX, need a way for python to know event types, 0x0110 is hard coded */
110 static wmTimer *rna_event_timer_add(struct wmWindowManager *wm, float time_step, wmWindow *win)
111 {
112         return WM_event_add_timer(wm, win, 0x0110, time_step);
113 }
114
115 static void rna_event_timer_remove(struct wmWindowManager *wm, wmTimer *timer)
116 {
117         WM_event_remove_timer(wm, timer->win, timer);
118 }
119
120
121 static wmManipulatorGroupType *wm_manipulatorgrouptype_find_for_add_remove(ReportList *reports, const char *idname)
122 {
123         wmManipulatorGroupType *wgt = WM_manipulatorgrouptype_find(idname, true);
124         if (wgt == NULL) {
125                 BKE_reportf(reports, RPT_ERROR, "Manipulator group type '%s' not found!", idname);
126                 return NULL;
127         }
128         if (wgt->flag & WM_MANIPULATORGROUPTYPE_PERSISTENT) {
129                 BKE_reportf(reports, RPT_ERROR, "Manipulator group '%s' has 'PERSISTENT' option set!", idname);
130                 return NULL;
131         }
132         return wgt;
133 }
134
135 static void rna_manipulator_group_type_add(ReportList *reports, const char *idname)
136 {
137         wmManipulatorGroupType *wgt = wm_manipulatorgrouptype_find_for_add_remove(reports, idname);
138         if (wgt != NULL) {
139                 WM_manipulator_group_type_add_ptr(wgt);
140         }
141 }
142
143 static void rna_manipulator_group_type_remove(Main *bmain, ReportList *reports, const char *idname)
144 {
145         wmManipulatorGroupType *wgt = wm_manipulatorgrouptype_find_for_add_remove(reports, idname);
146         if (wgt != NULL) {
147                 WM_manipulator_group_type_remove_ptr(bmain, wgt);
148         }
149 }
150
151 /* placeholder data for final implementation of a true progressbar */
152 static struct wmStaticProgress {
153         float min;
154         float max;
155         bool  is_valid;
156 } wm_progress_state = {0, 0, false};
157
158
159 static void rna_progress_begin(struct wmWindowManager *UNUSED(wm), float min, float max)
160 {
161         float range = max - min;
162         if (range != 0) {
163                 wm_progress_state.min = min;
164                 wm_progress_state.max = max;
165                 wm_progress_state.is_valid = true;
166         }
167         else {
168                 wm_progress_state.is_valid = false;
169         }
170 }
171
172 static void rna_progress_update(struct wmWindowManager *wm, float value)
173 {
174         if (wm_progress_state.is_valid) {
175                 /* Map to cursor_time range [0,9999] */
176                 wmWindow *win = wm->winactive;
177                 if (win) {
178                         int val = (int)(10000 * (value - wm_progress_state.min) / (wm_progress_state.max - wm_progress_state.min));
179                         WM_cursor_time(win, val);
180                 }
181         }
182 }
183
184 static void rna_progress_end(struct wmWindowManager *wm)
185 {
186         if (wm_progress_state.is_valid) {
187                 wmWindow *win = wm->winactive;
188                 if (win) {
189                         WM_cursor_modal_restore(win);
190                         wm_progress_state.is_valid = false;
191                 }
192         }
193 }
194
195 /* wrap these because of 'const wmEvent *' */
196 static int rna_Operator_confirm(bContext *C, wmOperator *op, wmEvent *event)
197 {
198         return WM_operator_confirm(C, op, event);
199 }
200 static int rna_Operator_props_popup(bContext *C, wmOperator *op, wmEvent *event)
201 {
202         return WM_operator_props_popup(C, op, event);
203 }
204
205 static wmKeyMapItem *rna_KeyMap_item_new(wmKeyMap *km, ReportList *reports, const char *idname, int type, int value,
206                                          int any, int shift, int ctrl, int alt, int oskey, int keymodifier, int head)
207 {
208 /*      wmWindowManager *wm = CTX_wm_manager(C); */
209         wmKeyMapItem *kmi = NULL;
210         char idname_bl[OP_MAX_TYPENAME];
211         int modifier = 0;
212
213         /* only on non-modal maps */
214         if (km->flag & KEYMAP_MODAL) {
215                 BKE_report(reports, RPT_ERROR, "Not a non-modal keymap");
216                 return NULL;
217         }
218
219         WM_operator_bl_idname(idname_bl, idname);
220
221         if (shift) modifier |= KM_SHIFT;
222         if (ctrl) modifier |= KM_CTRL;
223         if (alt) modifier |= KM_ALT;
224         if (oskey) modifier |= KM_OSKEY;
225
226         if (any) modifier = KM_ANY;
227         
228         /* create keymap item */
229         kmi = WM_keymap_add_item(km, idname_bl, type, value, modifier, keymodifier);
230         
231         /* [#32437] allow scripts to define hotkeys that get added to start of keymap 
232          *          so that they stand a chance against catch-all defines later on
233          */
234         if (head) {
235                 BLI_remlink(&km->items, kmi);
236                 BLI_addhead(&km->items, kmi);
237         }
238         
239         return kmi;
240 }
241
242 static wmKeyMapItem *rna_KeyMap_item_new_modal(wmKeyMap *km, ReportList *reports, const char *propvalue_str,
243                                                int type, int value, int any, int shift, int ctrl, int alt,
244                                                int oskey, int keymodifier)
245 {
246         int modifier = 0;
247         int propvalue = 0;
248
249         /* only modal maps */
250         if ((km->flag & KEYMAP_MODAL) == 0) {
251                 BKE_report(reports, RPT_ERROR, "Not a modal keymap");
252                 return NULL;
253         }
254
255         if (shift) modifier |= KM_SHIFT;
256         if (ctrl) modifier |= KM_CTRL;
257         if (alt) modifier |= KM_ALT;
258         if (oskey) modifier |= KM_OSKEY;
259
260         if (any) modifier = KM_ANY;
261
262         /* not initialized yet, do delayed lookup */
263         if (!km->modal_items)
264                 return WM_modalkeymap_add_item_str(km, type, value, modifier, keymodifier, propvalue_str);
265
266         if (RNA_enum_value_from_id(km->modal_items, propvalue_str, &propvalue) == 0)
267                 BKE_report(reports, RPT_WARNING, "Property value not in enumeration");
268
269         return WM_modalkeymap_add_item(km, type, value, modifier, keymodifier, propvalue);
270 }
271
272 static void rna_KeyMap_item_remove(wmKeyMap *km, ReportList *reports, PointerRNA *kmi_ptr)
273 {
274         wmKeyMapItem *kmi = kmi_ptr->data;
275
276         if (WM_keymap_remove_item(km, kmi) == false) {
277                 BKE_reportf(reports, RPT_ERROR, "KeyMapItem '%s' cannot be removed from '%s'", kmi->idname, km->idname);
278                 return;
279         }
280
281         RNA_POINTER_INVALIDATE(kmi_ptr);
282 }
283
284 static wmKeyMap *rna_keymap_new(wmKeyConfig *keyconf, const char *idname, int spaceid, int regionid, int modal)
285 {
286         if (modal == 0) {
287                 return WM_keymap_find(keyconf, idname, spaceid, regionid);
288         }
289         else {
290                 return WM_modalkeymap_add(keyconf, idname, NULL); /* items will be lazy init */
291         }
292 }
293
294 static wmKeyMap *rna_keymap_find(wmKeyConfig *keyconf, const char *idname, int spaceid, int regionid)
295 {
296         return WM_keymap_list_find(&keyconf->keymaps, idname, spaceid, regionid);
297 }
298
299 static wmKeyMap *rna_keymap_find_modal(wmKeyConfig *UNUSED(keyconf), const char *idname)
300 {
301         wmOperatorType *ot = WM_operatortype_find(idname, 0);
302
303         if (!ot)
304                 return NULL;
305         else
306                 return ot->modalkeymap;
307 }
308
309 static void rna_KeyMap_remove(wmKeyConfig *keyconfig, ReportList *reports, PointerRNA *keymap_ptr)
310 {
311         wmKeyMap *keymap = keymap_ptr->data;
312
313         if (WM_keymap_remove(keyconfig, keymap) == false) {
314                 BKE_reportf(reports, RPT_ERROR, "KeyConfig '%s' cannot be removed", keymap->idname);
315                 return;
316         }
317
318         RNA_POINTER_INVALIDATE(keymap_ptr);
319 }
320
321 static void rna_KeyConfig_remove(wmWindowManager *wm, ReportList *reports, PointerRNA *keyconf_ptr)
322 {
323         wmKeyConfig *keyconf = keyconf_ptr->data;
324
325         if (WM_keyconfig_remove(wm, keyconf) == false) {
326                 BKE_reportf(reports, RPT_ERROR, "KeyConfig '%s' cannot be removed", keyconf->idname);
327                 return;
328         }
329
330         RNA_POINTER_INVALIDATE(keyconf_ptr);
331 }
332
333 static PointerRNA rna_KeyConfig_find_item_from_operator(
334         wmWindowManager *wm,
335         bContext *C,
336         const char *idname,
337         int opcontext,
338         PointerRNA *properties,
339         int is_hotkey,
340         PointerRNA *km_ptr)
341 {
342         char idname_bl[OP_MAX_TYPENAME];
343         WM_operator_bl_idname(idname_bl, idname);
344
345         wmKeyMap *km = NULL;
346         wmKeyMapItem *kmi = WM_key_event_operator(C, idname_bl, opcontext, properties->data, (bool)is_hotkey, &km);
347         PointerRNA kmi_ptr;
348         RNA_pointer_create(&wm->id, &RNA_KeyMap, km, km_ptr);
349         RNA_pointer_create(&wm->id, &RNA_KeyMapItem, kmi, &kmi_ptr);
350         return kmi_ptr;
351 }
352
353 static void rna_KeyConfig_update(wmWindowManager *wm)
354 {
355         WM_keyconfig_update(wm);
356 }
357
358 /* popup menu wrapper */
359 static PointerRNA rna_PopMenuBegin(bContext *C, const char *title, int icon)
360 {
361         PointerRNA r_ptr;
362         void *data;
363
364         data = (void *)UI_popup_menu_begin(C, title, icon);
365
366         RNA_pointer_create(NULL, &RNA_UIPopupMenu, data, &r_ptr);
367
368         return r_ptr;
369 }
370
371 static void rna_PopMenuEnd(bContext *C, PointerRNA *handle)
372 {
373         UI_popup_menu_end(C, handle->data);
374 }
375
376 /* popover wrapper */
377 static PointerRNA rna_PopoverBegin(bContext *C)
378 {
379         PointerRNA r_ptr;
380         void *data;
381
382         data = (void *)UI_popover_begin(C);
383
384         RNA_pointer_create(NULL, &RNA_UIPopover, data, &r_ptr);
385
386         return r_ptr;
387 }
388
389 static void rna_PopoverEnd(bContext *C, PointerRNA *handle, wmKeyMap *keymap)
390 {
391         UI_popover_end(C, handle->data, keymap);
392 }
393
394 /* pie menu wrapper */
395 static PointerRNA rna_PieMenuBegin(bContext *C, const char *title, int icon, PointerRNA *event)
396 {
397         PointerRNA r_ptr;
398         void *data;
399
400         data = (void *)UI_pie_menu_begin(C, title, icon, event->data);
401
402         RNA_pointer_create(NULL, &RNA_UIPieMenu, data, &r_ptr);
403
404         return r_ptr;
405 }
406
407 static void rna_PieMenuEnd(bContext *C, PointerRNA *handle)
408 {
409         UI_pie_menu_end(C, handle->data);
410 }
411
412 static PointerRNA rna_WindoManager_operator_properties_last(const char *idname)
413 {
414         wmOperatorType *ot = WM_operatortype_find(idname, true);
415
416         if (ot != NULL) {
417                 PointerRNA ptr;
418                 WM_operator_last_properties_ensure(ot, &ptr);
419                 return ptr;
420         }
421         return PointerRNA_NULL;
422 }
423
424 #else
425
426 #define WM_GEN_INVOKE_EVENT (1 << 0)
427 #define WM_GEN_INVOKE_SIZE (1 << 1)
428 #define WM_GEN_INVOKE_RETURN (1 << 2)
429
430 static void rna_generic_op_invoke(FunctionRNA *func, int flag)
431 {
432         PropertyRNA *parm;
433
434         RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_CONTEXT);
435         parm = RNA_def_pointer(func, "operator", "Operator", "", "Operator to call");
436         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
437
438         if (flag & WM_GEN_INVOKE_EVENT) {
439                 parm = RNA_def_pointer(func, "event", "Event", "", "Event");
440                 RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
441         }
442
443         if (flag & WM_GEN_INVOKE_SIZE) {
444                 RNA_def_int(func, "width", 300, 0, INT_MAX, "", "Width of the popup", 0, INT_MAX);
445                 RNA_def_int(func, "height", 20, 0, INT_MAX, "", "Height of the popup", 0, INT_MAX);
446         }
447
448         if (flag & WM_GEN_INVOKE_RETURN) {
449                 parm = RNA_def_enum_flag(func, "result", rna_enum_operator_return_items, OPERATOR_CANCELLED, "result", "");
450                 RNA_def_function_return(func, parm);
451         }
452 }
453
454 void RNA_api_window(StructRNA *srna)
455 {
456         FunctionRNA *func;
457         PropertyRNA *parm;
458
459         func = RNA_def_function(srna, "cursor_warp", "WM_cursor_warp");
460         parm = RNA_def_int(func, "x", 0, INT_MIN, INT_MAX, "", "", INT_MIN, INT_MAX);
461         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
462         parm = RNA_def_int(func, "y", 0, INT_MIN, INT_MAX, "", "", INT_MIN, INT_MAX);
463         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
464         RNA_def_function_ui_description(func, "Set the cursor position");
465
466         func = RNA_def_function(srna, "cursor_set", "WM_cursor_set");
467         parm = RNA_def_property(func, "cursor", PROP_ENUM, PROP_NONE);
468         RNA_def_property_enum_items(parm, rna_enum_window_cursor_items);
469         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
470         RNA_def_function_ui_description(func, "Set the cursor");
471
472         func = RNA_def_function(srna, "cursor_modal_set", "WM_cursor_modal_set");
473         parm = RNA_def_property(func, "cursor", PROP_ENUM, PROP_NONE);
474         RNA_def_property_enum_items(parm, rna_enum_window_cursor_items);
475         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
476         RNA_def_function_ui_description(func, "Set the cursor, so the previous cursor can be restored");
477
478         RNA_def_function(srna, "cursor_modal_restore", "WM_cursor_modal_restore");
479         RNA_def_function_ui_description(func, "Restore the previous cursor after calling ``cursor_modal_set``");
480 }
481
482 void RNA_api_wm(StructRNA *srna)
483 {
484         FunctionRNA *func;
485         PropertyRNA *parm;
486
487         func = RNA_def_function(srna, "fileselect_add", "WM_event_add_fileselect");
488         RNA_def_function_ui_description(func, "Opens a file selector with an operator. "
489                                         "The string properties 'filepath', 'filename', 'directory' and a 'files' "
490                                         "collection are assigned when present in the operator");
491         rna_generic_op_invoke(func, 0);
492
493         func = RNA_def_function(srna, "modal_handler_add", "rna_event_modal_handler_add");
494         RNA_def_function_ui_description(func, "Add a modal handler to the window manager, for the given modal operator "
495                                         "(called by invoke() with self, just before returning {'RUNNING_MODAL'})");
496         RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_CONTEXT);
497         parm = RNA_def_pointer(func, "operator", "Operator", "", "Operator to call");
498         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
499         RNA_def_function_return(func, RNA_def_boolean(func, "handle", 1, "", "Whether adding the handler was successful"));
500
501
502         func = RNA_def_function(srna, "event_timer_add", "rna_event_timer_add");
503         RNA_def_function_ui_description(func, "Add a timer to the given window, to generate periodic 'TIMER' events");
504         parm = RNA_def_property(func, "time_step", PROP_FLOAT, PROP_NONE);
505         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
506         RNA_def_property_range(parm, 0.0, FLT_MAX);
507         RNA_def_property_ui_text(parm, "Time Step", "Interval in seconds between timer events");
508         RNA_def_pointer(func, "window", "Window", "", "Window to attach the timer to, or None");
509         parm = RNA_def_pointer(func, "result", "Timer", "", "");
510         RNA_def_function_return(func, parm);
511
512
513         func = RNA_def_function(srna, "event_timer_remove", "rna_event_timer_remove");
514         parm = RNA_def_pointer(func, "timer", "Timer", "", "");
515         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
516
517         func = RNA_def_function(srna, "manipulator_group_type_add", "rna_manipulator_group_type_add");
518         RNA_def_function_ui_description(func, "Activate an existing widget group (when the persistent option isn't set)");
519         RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_REPORTS);
520         parm = RNA_def_string(func, "identifier", NULL, 0, "", "Manipulator group type name");
521         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
522
523         func = RNA_def_function(srna, "manipulator_group_type_remove", "rna_manipulator_group_type_remove");
524         RNA_def_function_ui_description(func, "De-activate a widget group (when the persistent option isn't set)");
525         RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_MAIN | FUNC_USE_REPORTS);
526         parm = RNA_def_string(func, "identifier", NULL, 0, "", "Manipulator group type name");
527         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
528
529         /* Progress bar interface */
530         func = RNA_def_function(srna, "progress_begin", "rna_progress_begin");
531         RNA_def_function_ui_description(func, "Start progress report");
532         parm = RNA_def_property(func, "min", PROP_FLOAT, PROP_NONE);
533         RNA_def_property_ui_text(parm, "min", "any value in range [0,9999]");
534         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
535         parm = RNA_def_property(func, "max", PROP_FLOAT, PROP_NONE);
536         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
537         RNA_def_property_ui_text(parm, "max", "any value in range [min+1,9998]");
538
539         func = RNA_def_function(srna, "progress_update", "rna_progress_update");
540         RNA_def_function_ui_description(func, "Update the progress feedback");
541         parm = RNA_def_property(func, "value", PROP_FLOAT, PROP_NONE);
542         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
543         RNA_def_property_ui_text(parm, "value", "Any value between min and max as set in progress_begin()");
544
545         func = RNA_def_function(srna, "progress_end", "rna_progress_end");
546         RNA_def_function_ui_description(func, "Terminate progress report");
547
548         /* invoke functions, for use with python */
549         func = RNA_def_function(srna, "invoke_props_popup", "rna_Operator_props_popup");
550         RNA_def_function_ui_description(func, "Operator popup invoke "
551                                         "(show operator properties and execute it automatically on changes)");
552         rna_generic_op_invoke(func, WM_GEN_INVOKE_EVENT | WM_GEN_INVOKE_RETURN);
553
554         /* invoked dialog opens popup with OK button, does not auto-exec operator. */
555         func = RNA_def_function(srna, "invoke_props_dialog", "WM_operator_props_dialog_popup");
556         RNA_def_function_ui_description(func, "Operator dialog (non-autoexec popup) invoke "
557                                         "(show operator properties and only execute it on click on OK button)");
558         rna_generic_op_invoke(func, WM_GEN_INVOKE_SIZE | WM_GEN_INVOKE_RETURN);
559
560         /* invoke enum */
561         func = RNA_def_function(srna, "invoke_search_popup", "rna_Operator_enum_search_invoke");
562         RNA_def_function_ui_description(
563                 func,
564                 "Operator search popup invoke which "
565                 "searches values of the operator's :class:`bpy.types.Operator.bl_property` "
566                 "(which must be an EnumProperty), executing it on confirmation");
567         rna_generic_op_invoke(func, 0);
568
569         /* invoke functions, for use with python */
570         func = RNA_def_function(srna, "invoke_popup", "WM_operator_ui_popup");
571         RNA_def_function_ui_description(func, "Operator popup invoke "
572                                         "(only shows operator's properties, without executing it)");
573         rna_generic_op_invoke(func, WM_GEN_INVOKE_SIZE | WM_GEN_INVOKE_RETURN);
574
575         func = RNA_def_function(srna, "invoke_confirm", "rna_Operator_confirm");
576         RNA_def_function_ui_description(func, "Operator confirmation popup "
577                                         "(only to let user confirm the execution, no operator properties shown)");
578         rna_generic_op_invoke(func, WM_GEN_INVOKE_EVENT | WM_GEN_INVOKE_RETURN);
579
580
581         /* wrap UI_popup_menu_begin */
582         func = RNA_def_function(srna, "popmenu_begin__internal", "rna_PopMenuBegin");
583         RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_CONTEXT);
584         parm = RNA_def_string(func, "title", NULL, 0, "", "");
585         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
586         parm = RNA_def_property(func, "icon", PROP_ENUM, PROP_NONE);
587         RNA_def_property_enum_items(parm, rna_enum_icon_items);
588         /* return */
589         parm = RNA_def_pointer(func, "menu", "UIPopupMenu", "", "");
590         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_RNAPTR);
591         RNA_def_function_return(func, parm);
592
593         /* wrap UI_popup_menu_end */
594         func = RNA_def_function(srna, "popmenu_end__internal", "rna_PopMenuEnd");
595         RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_CONTEXT);
596         parm = RNA_def_pointer(func, "menu", "UIPopupMenu", "", "");
597         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_RNAPTR);
598
599
600         /* wrap UI_popover_begin */
601         func = RNA_def_function(srna, "popover_begin__internal", "rna_PopoverBegin");
602         RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_CONTEXT);
603         /* return */
604         parm = RNA_def_pointer(func, "menu", "UIPopover", "", "");
605         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_RNAPTR);
606         RNA_def_function_return(func, parm);
607
608         /* wrap UI_popover_end */
609         func = RNA_def_function(srna, "popover_end__internal", "rna_PopoverEnd");
610         RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_CONTEXT);
611         parm = RNA_def_pointer(func, "menu", "UIPopover", "", "");
612         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_RNAPTR);
613         RNA_def_pointer(func, "keymap", "KeyMap", "Key Map", "Active key map");
614
615
616         /* wrap uiPieMenuBegin */
617         func = RNA_def_function(srna, "piemenu_begin__internal", "rna_PieMenuBegin");
618         RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_CONTEXT);
619         parm = RNA_def_string(func, "title", NULL, 0, "", "");
620         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
621         parm = RNA_def_property(func, "icon", PROP_ENUM, PROP_NONE);
622         RNA_def_property_enum_items(parm, rna_enum_icon_items);
623         parm = RNA_def_pointer(func, "event", "Event", "", "");
624         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_RNAPTR);
625         /* return */
626         parm = RNA_def_pointer(func, "menu_pie", "UIPieMenu", "", "");
627         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_RNAPTR);
628         RNA_def_function_return(func, parm);
629
630         /* wrap uiPieMenuEnd */
631         func = RNA_def_function(srna, "piemenu_end__internal", "rna_PieMenuEnd");
632         RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_CONTEXT);
633         parm = RNA_def_pointer(func, "menu", "UIPieMenu", "", "");
634         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_RNAPTR);
635
636         /* access last operator options (optionally create). */
637         func = RNA_def_function(srna, "operator_properties_last", "rna_WindoManager_operator_properties_last");
638         RNA_def_function_flag(func, FUNC_NO_SELF);
639         parm = RNA_def_string(func, "operator", NULL, 0, "", "");
640         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
641         /* return */
642         parm = RNA_def_pointer(func, "result", "OperatorProperties", "", "");
643         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_RNAPTR);
644         RNA_def_function_return(func, parm);
645
646 }
647
648 void RNA_api_operator(StructRNA *srna)
649 {
650         FunctionRNA *func;
651         PropertyRNA *parm;
652
653         /* utility, not for registering */
654         func = RNA_def_function(srna, "report", "rna_Operator_report");
655         parm = RNA_def_enum_flag(func, "type", rna_enum_wm_report_items, 0, "Type", "");
656         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
657         parm = RNA_def_string(func, "message", NULL, 0, "Report Message", "");
658         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
659
660         /* utility, not for registering */
661         func = RNA_def_function(srna, "is_repeat", "rna_Operator_is_repeat");
662         RNA_def_function_flag(func, FUNC_USE_CONTEXT);
663         /* return */
664         parm = RNA_def_boolean(func, "result", 0, "result", "");
665         RNA_def_function_return(func, parm);
666
667         /* Registration */
668
669         /* poll */
670         func = RNA_def_function(srna, "poll", NULL);
671         RNA_def_function_ui_description(func, "Test if the operator can be called or not");
672         RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_REGISTER_OPTIONAL);
673         RNA_def_function_return(func, RNA_def_boolean(func, "visible", 1, "", ""));
674         parm = RNA_def_pointer(func, "context", "Context", "", "");
675         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
676
677         /* exec */
678         func = RNA_def_function(srna, "execute", NULL);
679         RNA_def_function_ui_description(func, "Execute the operator");
680         RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL | FUNC_ALLOW_WRITE);
681         parm = RNA_def_pointer(func, "context", "Context", "", "");
682         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
683
684         /* better name? */
685         parm = RNA_def_enum_flag(func, "result", rna_enum_operator_return_items, OPERATOR_CANCELLED, "result", "");
686         RNA_def_function_return(func, parm);
687
688         /* check */
689         func = RNA_def_function(srna, "check", NULL);
690         RNA_def_function_ui_description(func, "Check the operator settings, return True to signal a change to redraw");
691         RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL | FUNC_ALLOW_WRITE);
692         parm = RNA_def_pointer(func, "context", "Context", "", "");
693         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
694
695         parm = RNA_def_boolean(func, "result", 0, "result", ""); /* better name? */
696         RNA_def_function_return(func, parm);
697         
698         /* invoke */
699         func = RNA_def_function(srna, "invoke", NULL);
700         RNA_def_function_ui_description(func, "Invoke the operator");
701         RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL | FUNC_ALLOW_WRITE);
702         parm = RNA_def_pointer(func, "context", "Context", "", "");
703         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
704         parm = RNA_def_pointer(func, "event", "Event", "", "");
705         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
706
707         /* better name? */
708         parm = RNA_def_enum_flag(func, "result", rna_enum_operator_return_items, OPERATOR_CANCELLED, "result", "");
709         RNA_def_function_return(func, parm);
710
711         func = RNA_def_function(srna, "modal", NULL); /* same as invoke */
712         RNA_def_function_ui_description(func, "Modal operator function");
713         RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL | FUNC_ALLOW_WRITE);
714         parm = RNA_def_pointer(func, "context", "Context", "", "");
715         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
716         parm = RNA_def_pointer(func, "event", "Event", "", "");
717         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
718
719         /* better name? */
720         parm = RNA_def_enum_flag(func, "result", rna_enum_operator_return_items, OPERATOR_CANCELLED, "result", "");
721         RNA_def_function_return(func, parm);
722
723         /* draw */
724         func = RNA_def_function(srna, "draw", NULL);
725         RNA_def_function_ui_description(func, "Draw function for the operator");
726         RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL);
727         parm = RNA_def_pointer(func, "context", "Context", "", "");
728         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
729
730         /* cancel */
731         func = RNA_def_function(srna, "cancel", NULL);
732         RNA_def_function_ui_description(func, "Called when the operator is canceled");
733         RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL | FUNC_ALLOW_WRITE);
734         parm = RNA_def_pointer(func, "context", "Context", "", "");
735         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
736 }
737
738 void RNA_api_macro(StructRNA *srna)
739 {
740         FunctionRNA *func;
741         PropertyRNA *parm;
742
743         /* utility, not for registering */
744         func = RNA_def_function(srna, "report", "rna_Operator_report");
745         parm = RNA_def_enum_flag(func, "type", rna_enum_wm_report_items, 0, "Type", "");
746         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
747         parm = RNA_def_string(func, "message", NULL, 0, "Report Message", "");
748         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
749
750
751         /* Registration */
752
753         /* poll */
754         func = RNA_def_function(srna, "poll", NULL);
755         RNA_def_function_ui_description(func, "Test if the operator can be called or not");
756         RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_REGISTER_OPTIONAL);
757         RNA_def_function_return(func, RNA_def_boolean(func, "visible", 1, "", ""));
758         parm = RNA_def_pointer(func, "context", "Context", "", "");
759         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
760
761         /* draw */
762         func = RNA_def_function(srna, "draw", NULL);
763         RNA_def_function_ui_description(func, "Draw function for the operator");
764         RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL);
765         parm = RNA_def_pointer(func, "context", "Context", "", "");
766         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
767 }
768
769 void RNA_api_keyconfig(StructRNA *UNUSED(srna))
770 {
771         /* FunctionRNA *func; */
772         /* PropertyRNA *parm; */
773 }
774
775 void RNA_api_keymap(StructRNA *srna)
776 {
777         FunctionRNA *func;
778         PropertyRNA *parm;
779
780         func = RNA_def_function(srna, "active", "rna_keymap_active");
781         RNA_def_function_flag(func, FUNC_USE_CONTEXT);
782         parm = RNA_def_pointer(func, "keymap", "KeyMap", "Key Map", "Active key map");
783         RNA_def_function_return(func, parm);
784
785         func = RNA_def_function(srna, "restore_to_default", "WM_keymap_restore_to_default");
786         RNA_def_function_flag(func, FUNC_USE_CONTEXT);
787
788         func = RNA_def_function(srna, "restore_item_to_default", "rna_keymap_restore_item_to_default");
789         RNA_def_function_flag(func, FUNC_USE_CONTEXT);
790         parm = RNA_def_pointer(func, "item", "KeyMapItem", "Item", "");
791         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
792 }
793
794 void RNA_api_keymapitem(StructRNA *srna)
795 {
796         FunctionRNA *func;
797         PropertyRNA *parm;
798
799         func = RNA_def_function(srna, "compare", "WM_keymap_item_compare");
800         parm = RNA_def_pointer(func, "item", "KeyMapItem", "Item", "");
801         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
802         parm = RNA_def_boolean(func, "result", 0, "Comparison result", "");
803         RNA_def_function_return(func, parm);
804 }
805
806 void RNA_api_keymapitems(StructRNA *srna)
807 {
808         FunctionRNA *func;
809         PropertyRNA *parm;
810
811         func = RNA_def_function(srna, "new", "rna_KeyMap_item_new");
812         RNA_def_function_flag(func, FUNC_USE_REPORTS);
813         parm = RNA_def_string(func, "idname", NULL, 0, "Operator Identifier", "");
814         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
815         parm = RNA_def_enum(func, "type", rna_enum_event_type_items, 0, "Type", "");
816         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
817         parm = RNA_def_enum(func, "value", rna_enum_event_value_items, 0, "Value", "");
818         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
819         RNA_def_boolean(func, "any", 0, "Any", "");
820         RNA_def_boolean(func, "shift", 0, "Shift", "");
821         RNA_def_boolean(func, "ctrl", 0, "Ctrl", "");
822         RNA_def_boolean(func, "alt", 0, "Alt", "");
823         RNA_def_boolean(func, "oskey", 0, "OS Key", "");
824         RNA_def_enum(func, "key_modifier", rna_enum_event_type_items, 0, "Key Modifier", "");
825         RNA_def_boolean(func, "head", 0, "At Head", 
826                         "Force item to be added at start (not end) of key map so that "
827                         "it doesn't get blocked by an existing key map item");
828         parm = RNA_def_pointer(func, "item", "KeyMapItem", "Item", "Added key map item");
829         RNA_def_function_return(func, parm);
830
831         func = RNA_def_function(srna, "new_modal", "rna_KeyMap_item_new_modal");
832         RNA_def_function_flag(func, FUNC_USE_REPORTS);
833         parm = RNA_def_string(func, "propvalue", NULL, 0, "Property Value", "");
834         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
835         parm = RNA_def_enum(func, "type", rna_enum_event_type_items, 0, "Type", "");
836         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
837         parm = RNA_def_enum(func, "value", rna_enum_event_value_items, 0, "Value", "");
838         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
839         RNA_def_boolean(func, "any", 0, "Any", "");
840         RNA_def_boolean(func, "shift", 0, "Shift", "");
841         RNA_def_boolean(func, "ctrl", 0, "Ctrl", "");
842         RNA_def_boolean(func, "alt", 0, "Alt", "");
843         RNA_def_boolean(func, "oskey", 0, "OS Key", "");
844         RNA_def_enum(func, "key_modifier", rna_enum_event_type_items, 0, "Key Modifier", "");
845         parm = RNA_def_pointer(func, "item", "KeyMapItem", "Item", "Added key map item");
846         RNA_def_function_return(func, parm);
847         
848         func = RNA_def_function(srna, "remove", "rna_KeyMap_item_remove");
849         RNA_def_function_flag(func, FUNC_USE_REPORTS);
850         parm = RNA_def_pointer(func, "item", "KeyMapItem", "Item", "");
851         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
852         RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
853
854         func = RNA_def_function(srna, "from_id", "WM_keymap_item_find_id");
855         parm = RNA_def_property(func, "id", PROP_INT, PROP_NONE);
856         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
857         RNA_def_property_ui_text(parm, "id", "ID of the item");
858         parm = RNA_def_pointer(func, "item", "KeyMapItem", "Item", "");
859         RNA_def_function_return(func, parm);
860 }
861
862 void RNA_api_keymaps(StructRNA *srna)
863 {
864         FunctionRNA *func;
865         PropertyRNA *parm;
866
867         func = RNA_def_function(srna, "new", "rna_keymap_new"); /* add_keymap */
868         parm = RNA_def_string(func, "name", NULL, 0, "Name", "");
869         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
870         RNA_def_enum(func, "space_type", rna_enum_space_type_items, SPACE_EMPTY, "Space Type", "");
871         RNA_def_enum(func, "region_type", rna_enum_region_type_items, RGN_TYPE_WINDOW, "Region Type", "");
872         RNA_def_boolean(func, "modal", 0, "Modal", "");
873         parm = RNA_def_pointer(func, "keymap", "KeyMap", "Key Map", "Added key map");
874         RNA_def_function_return(func, parm);
875
876         func = RNA_def_function(srna, "remove", "rna_KeyMap_remove"); /* remove_keymap */
877         RNA_def_function_flag(func, FUNC_USE_REPORTS);
878         parm = RNA_def_pointer(func, "keymap", "KeyMap", "Key Map", "Removed key map");
879         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
880         RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
881
882         func = RNA_def_function(srna, "find", "rna_keymap_find"); /* find_keymap */
883         parm = RNA_def_string(func, "name", NULL, 0, "Name", "");
884         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
885         RNA_def_enum(func, "space_type", rna_enum_space_type_items, SPACE_EMPTY, "Space Type", "");
886         RNA_def_enum(func, "region_type", rna_enum_region_type_items, RGN_TYPE_WINDOW, "Region Type", "");
887         parm = RNA_def_pointer(func, "keymap", "KeyMap", "Key Map", "Corresponding key map");
888         RNA_def_function_return(func, parm);
889
890         func = RNA_def_function(srna, "find_modal", "rna_keymap_find_modal"); /* find_keymap_modal */
891         parm = RNA_def_string(func, "name", NULL, 0, "Operator Name", "");
892         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
893         parm = RNA_def_pointer(func, "keymap", "KeyMap", "Key Map", "Corresponding key map");
894         RNA_def_function_return(func, parm);
895 }
896
897 void RNA_api_keyconfigs(StructRNA *srna)
898 {
899         FunctionRNA *func;
900         PropertyRNA *parm;
901
902         func = RNA_def_function(srna, "new", "WM_keyconfig_new_user"); /* add_keyconfig */
903         parm = RNA_def_string(func, "name", NULL, 0, "Name", "");
904         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
905         parm = RNA_def_pointer(func, "keyconfig", "KeyConfig", "Key Configuration", "Added key configuration");
906         RNA_def_function_return(func, parm);
907
908         func = RNA_def_function(srna, "remove", "rna_KeyConfig_remove"); /* remove_keyconfig */
909         RNA_def_function_flag(func, FUNC_USE_REPORTS);
910         parm = RNA_def_pointer(func, "keyconfig", "KeyConfig", "Key Configuration", "Removed key configuration");
911         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
912         RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
913
914         /* Helper functions */
915
916         /* Keymap introspection */
917         func = RNA_def_function(srna, "find_item_from_operator", "rna_KeyConfig_find_item_from_operator");
918         RNA_def_function_flag(func, FUNC_USE_CONTEXT);
919         parm = RNA_def_string(func, "idname", NULL, 0, "Operator Identifier", "");
920         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
921         parm = RNA_def_property(func, "context", PROP_ENUM, PROP_NONE);
922         RNA_def_property_enum_items(parm, rna_enum_operator_context_items);
923         parm = RNA_def_pointer(func, "properties", "OperatorProperties", "", "");
924         RNA_def_parameter_flags(parm, 0, PARM_RNAPTR);
925         RNA_def_boolean(func, "is_hotkey", 0, "Hotkey", "Event is not a modifier");
926         parm = RNA_def_pointer(func, "item", "KeyMapItem", "", "");
927         RNA_def_parameter_flags(parm, 0, PARM_RNAPTR);
928         parm = RNA_def_pointer(func, "keymap", "KeyMap", "", "");
929         RNA_def_parameter_flags(parm, 0, PARM_RNAPTR | PARM_OUTPUT);
930         RNA_def_function_return(func, parm);
931
932         RNA_def_function(srna, "update", "rna_KeyConfig_update"); /* WM_keyconfig_update */
933 }
934
935 #endif