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