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