WM: add keymap.find_from_operator(...)
[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 modal/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 PointerRNA rna_KeyMap_item_find_from_operator(
313         ID *id,
314         wmKeyMap *km,
315         const char *idname,
316         PointerRNA *properties,
317         int include_mask, int exclude_mask)
318 {
319         char idname_bl[OP_MAX_TYPENAME];
320         WM_operator_bl_idname(idname_bl, idname);
321
322         wmKeyMapItem *kmi = WM_key_event_operator_from_keymap(
323                 km, idname_bl, properties->data, include_mask, exclude_mask);
324         PointerRNA kmi_ptr;
325         RNA_pointer_create(id, &RNA_KeyMapItem, kmi, &kmi_ptr);
326         return kmi_ptr;
327 }
328
329 static wmKeyMap *rna_keymap_new(wmKeyConfig *keyconf, const char *idname, int spaceid, int regionid, bool modal, bool tool)
330 {
331         wmKeyMap *keymap;
332
333         if (modal == 0) {
334                 keymap = WM_keymap_ensure(keyconf, idname, spaceid, regionid);
335         }
336         else {
337                 keymap = WM_modalkeymap_add(keyconf, idname, NULL); /* items will be lazy init */
338         }
339
340         if (keymap && tool) {
341                 keymap->flag |= KEYMAP_TOOL;
342         }
343
344         return keymap;
345 }
346
347 static wmKeyMap *rna_keymap_find(wmKeyConfig *keyconf, const char *idname, int spaceid, int regionid)
348 {
349         return WM_keymap_list_find(&keyconf->keymaps, idname, spaceid, regionid);
350 }
351
352 static wmKeyMap *rna_keymap_find_modal(wmKeyConfig *UNUSED(keyconf), const char *idname)
353 {
354         wmOperatorType *ot = WM_operatortype_find(idname, 0);
355
356         if (!ot)
357                 return NULL;
358         else
359                 return ot->modalkeymap;
360 }
361
362 static void rna_KeyMap_remove(wmKeyConfig *keyconfig, ReportList *reports, PointerRNA *keymap_ptr)
363 {
364         wmKeyMap *keymap = keymap_ptr->data;
365
366         if (WM_keymap_remove(keyconfig, keymap) == false) {
367                 BKE_reportf(reports, RPT_ERROR, "KeyConfig '%s' cannot be removed", keymap->idname);
368                 return;
369         }
370
371         RNA_POINTER_INVALIDATE(keymap_ptr);
372 }
373
374 static void rna_KeyConfig_remove(wmWindowManager *wm, ReportList *reports, PointerRNA *keyconf_ptr)
375 {
376         wmKeyConfig *keyconf = keyconf_ptr->data;
377
378         if (WM_keyconfig_remove(wm, keyconf) == false) {
379                 BKE_reportf(reports, RPT_ERROR, "KeyConfig '%s' cannot be removed", keyconf->idname);
380                 return;
381         }
382
383         RNA_POINTER_INVALIDATE(keyconf_ptr);
384 }
385
386 static PointerRNA rna_KeyConfig_find_item_from_operator(
387         wmWindowManager *wm,
388         bContext *C,
389         const char *idname,
390         int opcontext,
391         PointerRNA *properties,
392         int include_mask, int exclude_mask,
393         PointerRNA *km_ptr)
394 {
395         char idname_bl[OP_MAX_TYPENAME];
396         WM_operator_bl_idname(idname_bl, idname);
397
398         wmKeyMap *km = NULL;
399         wmKeyMapItem *kmi = WM_key_event_operator(
400                 C, idname_bl, opcontext, properties->data, include_mask, exclude_mask, &km);
401         PointerRNA kmi_ptr;
402         RNA_pointer_create(&wm->id, &RNA_KeyMap, km, km_ptr);
403         RNA_pointer_create(&wm->id, &RNA_KeyMapItem, kmi, &kmi_ptr);
404         return kmi_ptr;
405 }
406
407 static void rna_KeyConfig_update(wmWindowManager *wm)
408 {
409         WM_keyconfig_update(wm);
410 }
411
412 /* popup menu wrapper */
413 static PointerRNA rna_PopMenuBegin(bContext *C, const char *title, int icon)
414 {
415         PointerRNA r_ptr;
416         void *data;
417
418         data = (void *)UI_popup_menu_begin(C, title, icon);
419
420         RNA_pointer_create(NULL, &RNA_UIPopupMenu, data, &r_ptr);
421
422         return r_ptr;
423 }
424
425 static void rna_PopMenuEnd(bContext *C, PointerRNA *handle)
426 {
427         UI_popup_menu_end(C, handle->data);
428 }
429
430 /* popover wrapper */
431 static PointerRNA rna_PopoverBegin(bContext *C, int ui_units_x)
432 {
433         PointerRNA r_ptr;
434         void *data;
435
436         data = (void *)UI_popover_begin(C, U.widget_unit * ui_units_x);
437
438         RNA_pointer_create(NULL, &RNA_UIPopover, data, &r_ptr);
439
440         return r_ptr;
441 }
442
443 static void rna_PopoverEnd(bContext *C, PointerRNA *handle, wmKeyMap *keymap)
444 {
445         UI_popover_end(C, handle->data, keymap);
446 }
447
448 /* pie menu wrapper */
449 static PointerRNA rna_PieMenuBegin(bContext *C, const char *title, int icon, PointerRNA *event)
450 {
451         PointerRNA r_ptr;
452         void *data;
453
454         data = (void *)UI_pie_menu_begin(C, title, icon, event->data);
455
456         RNA_pointer_create(NULL, &RNA_UIPieMenu, data, &r_ptr);
457
458         return r_ptr;
459 }
460
461 static void rna_PieMenuEnd(bContext *C, PointerRNA *handle)
462 {
463         UI_pie_menu_end(C, handle->data);
464 }
465
466 static PointerRNA rna_WindoManager_operator_properties_last(const char *idname)
467 {
468         wmOperatorType *ot = WM_operatortype_find(idname, true);
469
470         if (ot != NULL) {
471                 PointerRNA ptr;
472                 WM_operator_last_properties_ensure(ot, &ptr);
473                 return ptr;
474         }
475         return PointerRNA_NULL;
476 }
477
478 #else
479
480 #define WM_GEN_INVOKE_EVENT (1 << 0)
481 #define WM_GEN_INVOKE_SIZE (1 << 1)
482 #define WM_GEN_INVOKE_RETURN (1 << 2)
483
484 static void rna_generic_op_invoke(FunctionRNA *func, int flag)
485 {
486         PropertyRNA *parm;
487
488         RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_CONTEXT);
489         parm = RNA_def_pointer(func, "operator", "Operator", "", "Operator to call");
490         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
491
492         if (flag & WM_GEN_INVOKE_EVENT) {
493                 parm = RNA_def_pointer(func, "event", "Event", "", "Event");
494                 RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
495         }
496
497         if (flag & WM_GEN_INVOKE_SIZE) {
498                 RNA_def_int(func, "width", 300, 0, INT_MAX, "", "Width of the popup", 0, INT_MAX);
499                 RNA_def_int(func, "height", 20, 0, INT_MAX, "", "Height of the popup", 0, INT_MAX);
500         }
501
502         if (flag & WM_GEN_INVOKE_RETURN) {
503                 parm = RNA_def_enum_flag(func, "result", rna_enum_operator_return_items, OPERATOR_CANCELLED, "result", "");
504                 RNA_def_function_return(func, parm);
505         }
506 }
507
508 void RNA_api_window(StructRNA *srna)
509 {
510         FunctionRNA *func;
511         PropertyRNA *parm;
512
513         func = RNA_def_function(srna, "cursor_warp", "WM_cursor_warp");
514         parm = RNA_def_int(func, "x", 0, INT_MIN, INT_MAX, "", "", INT_MIN, INT_MAX);
515         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
516         parm = RNA_def_int(func, "y", 0, INT_MIN, INT_MAX, "", "", INT_MIN, INT_MAX);
517         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
518         RNA_def_function_ui_description(func, "Set the cursor position");
519
520         func = RNA_def_function(srna, "cursor_set", "WM_cursor_set");
521         parm = RNA_def_property(func, "cursor", PROP_ENUM, PROP_NONE);
522         RNA_def_property_enum_items(parm, rna_enum_window_cursor_items);
523         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
524         RNA_def_function_ui_description(func, "Set the cursor");
525
526         func = RNA_def_function(srna, "cursor_modal_set", "WM_cursor_modal_set");
527         parm = RNA_def_property(func, "cursor", PROP_ENUM, PROP_NONE);
528         RNA_def_property_enum_items(parm, rna_enum_window_cursor_items);
529         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
530         RNA_def_function_ui_description(func, "Set the cursor, so the previous cursor can be restored");
531
532         RNA_def_function(srna, "cursor_modal_restore", "WM_cursor_modal_restore");
533         RNA_def_function_ui_description(func, "Restore the previous cursor after calling ``cursor_modal_set``");
534 }
535
536 void RNA_api_wm(StructRNA *srna)
537 {
538         FunctionRNA *func;
539         PropertyRNA *parm;
540
541         func = RNA_def_function(srna, "fileselect_add", "WM_event_add_fileselect");
542         RNA_def_function_ui_description(func, "Opens a file selector with an operator. "
543                                         "The string properties 'filepath', 'filename', 'directory' and a 'files' "
544                                         "collection are assigned when present in the operator");
545         rna_generic_op_invoke(func, 0);
546
547         func = RNA_def_function(srna, "modal_handler_add", "rna_event_modal_handler_add");
548         RNA_def_function_ui_description(func, "Add a modal handler to the window manager, for the given modal operator "
549                                         "(called by invoke() with self, just before returning {'RUNNING_MODAL'})");
550         RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_CONTEXT);
551         parm = RNA_def_pointer(func, "operator", "Operator", "", "Operator to call");
552         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
553         RNA_def_function_return(func, RNA_def_boolean(func, "handle", 1, "", "Whether adding the handler was successful"));
554
555
556         func = RNA_def_function(srna, "event_timer_add", "rna_event_timer_add");
557         RNA_def_function_ui_description(func, "Add a timer to the given window, to generate periodic 'TIMER' events");
558         parm = RNA_def_property(func, "time_step", PROP_FLOAT, PROP_NONE);
559         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
560         RNA_def_property_range(parm, 0.0, FLT_MAX);
561         RNA_def_property_ui_text(parm, "Time Step", "Interval in seconds between timer events");
562         RNA_def_pointer(func, "window", "Window", "", "Window to attach the timer to, or None");
563         parm = RNA_def_pointer(func, "result", "Timer", "", "");
564         RNA_def_function_return(func, parm);
565
566
567         func = RNA_def_function(srna, "event_timer_remove", "rna_event_timer_remove");
568         parm = RNA_def_pointer(func, "timer", "Timer", "", "");
569         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
570
571         func = RNA_def_function(srna, "gizmo_group_type_ensure", "rna_gizmo_group_type_ensure");
572         RNA_def_function_ui_description(func, "Activate an existing widget group (when the persistent option isn't set)");
573         RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_REPORTS);
574         parm = RNA_def_string(func, "identifier", NULL, 0, "", "Gizmo group type name");
575         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
576
577         func = RNA_def_function(srna, "gizmo_group_type_unlink_delayed", "rna_gizmo_group_type_unlink_delayed");
578         RNA_def_function_ui_description(func, "Unlink a widget group (when the persistent option is set)");
579         RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_REPORTS);
580         parm = RNA_def_string(func, "identifier", NULL, 0, "", "Gizmo group type name");
581         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
582
583         /* Progress bar interface */
584         func = RNA_def_function(srna, "progress_begin", "rna_progress_begin");
585         RNA_def_function_ui_description(func, "Start progress report");
586         parm = RNA_def_property(func, "min", PROP_FLOAT, PROP_NONE);
587         RNA_def_property_ui_text(parm, "min", "any value in range [0,9999]");
588         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
589         parm = RNA_def_property(func, "max", PROP_FLOAT, PROP_NONE);
590         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
591         RNA_def_property_ui_text(parm, "max", "any value in range [min+1,9998]");
592
593         func = RNA_def_function(srna, "progress_update", "rna_progress_update");
594         RNA_def_function_ui_description(func, "Update the progress feedback");
595         parm = RNA_def_property(func, "value", PROP_FLOAT, PROP_NONE);
596         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
597         RNA_def_property_ui_text(parm, "value", "Any value between min and max as set in progress_begin()");
598
599         func = RNA_def_function(srna, "progress_end", "rna_progress_end");
600         RNA_def_function_ui_description(func, "Terminate progress report");
601
602         /* invoke functions, for use with python */
603         func = RNA_def_function(srna, "invoke_props_popup", "rna_Operator_props_popup");
604         RNA_def_function_ui_description(func, "Operator popup invoke "
605                                         "(show operator properties and execute it automatically on changes)");
606         rna_generic_op_invoke(func, WM_GEN_INVOKE_EVENT | WM_GEN_INVOKE_RETURN);
607
608         /* invoked dialog opens popup with OK button, does not auto-exec operator. */
609         func = RNA_def_function(srna, "invoke_props_dialog", "WM_operator_props_dialog_popup");
610         RNA_def_function_ui_description(func, "Operator dialog (non-autoexec popup) invoke "
611                                         "(show operator properties and only execute it on click on OK button)");
612         rna_generic_op_invoke(func, WM_GEN_INVOKE_SIZE | WM_GEN_INVOKE_RETURN);
613
614         /* invoke enum */
615         func = RNA_def_function(srna, "invoke_search_popup", "rna_Operator_enum_search_invoke");
616         RNA_def_function_ui_description(
617                 func,
618                 "Operator search popup invoke which "
619                 "searches values of the operator's :class:`bpy.types.Operator.bl_property` "
620                 "(which must be an EnumProperty), executing it on confirmation");
621         rna_generic_op_invoke(func, 0);
622
623         /* invoke functions, for use with python */
624         func = RNA_def_function(srna, "invoke_popup", "WM_operator_ui_popup");
625         RNA_def_function_ui_description(func, "Operator popup invoke "
626                                         "(only shows operator's properties, without executing it)");
627         rna_generic_op_invoke(func, WM_GEN_INVOKE_SIZE | WM_GEN_INVOKE_RETURN);
628
629         func = RNA_def_function(srna, "invoke_confirm", "rna_Operator_confirm");
630         RNA_def_function_ui_description(func, "Operator confirmation popup "
631                                         "(only to let user confirm the execution, no operator properties shown)");
632         rna_generic_op_invoke(func, WM_GEN_INVOKE_EVENT | WM_GEN_INVOKE_RETURN);
633
634
635         /* wrap UI_popup_menu_begin */
636         func = RNA_def_function(srna, "popmenu_begin__internal", "rna_PopMenuBegin");
637         RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_CONTEXT);
638         parm = RNA_def_string(func, "title", NULL, 0, "", "");
639         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
640         parm = RNA_def_property(func, "icon", PROP_ENUM, PROP_NONE);
641         RNA_def_property_enum_items(parm, rna_enum_icon_items);
642         /* return */
643         parm = RNA_def_pointer(func, "menu", "UIPopupMenu", "", "");
644         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_RNAPTR);
645         RNA_def_function_return(func, parm);
646
647         /* wrap UI_popup_menu_end */
648         func = RNA_def_function(srna, "popmenu_end__internal", "rna_PopMenuEnd");
649         RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_CONTEXT);
650         parm = RNA_def_pointer(func, "menu", "UIPopupMenu", "", "");
651         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_RNAPTR | PARM_REQUIRED);
652
653         /* wrap UI_popover_begin */
654         func = RNA_def_function(srna, "popover_begin__internal", "rna_PopoverBegin");
655         RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_CONTEXT);
656         RNA_def_property(func, "ui_units_x", PROP_INT, PROP_UNSIGNED);
657         /* return */
658         parm = RNA_def_pointer(func, "menu", "UIPopover", "", "");
659         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_RNAPTR);
660         RNA_def_function_return(func, parm);
661
662         /* wrap UI_popover_end */
663         func = RNA_def_function(srna, "popover_end__internal", "rna_PopoverEnd");
664         RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_CONTEXT);
665         parm = RNA_def_pointer(func, "menu", "UIPopover", "", "");
666         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_RNAPTR | PARM_REQUIRED);
667         RNA_def_pointer(func, "keymap", "KeyMap", "Key Map", "Active key map");
668
669
670         /* wrap uiPieMenuBegin */
671         func = RNA_def_function(srna, "piemenu_begin__internal", "rna_PieMenuBegin");
672         RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_CONTEXT);
673         parm = RNA_def_string(func, "title", NULL, 0, "", "");
674         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
675         parm = RNA_def_property(func, "icon", PROP_ENUM, PROP_NONE);
676         RNA_def_property_enum_items(parm, rna_enum_icon_items);
677         parm = RNA_def_pointer(func, "event", "Event", "", "");
678         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_RNAPTR);
679         /* return */
680         parm = RNA_def_pointer(func, "menu_pie", "UIPieMenu", "", "");
681         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_RNAPTR);
682         RNA_def_function_return(func, parm);
683
684         /* wrap uiPieMenuEnd */
685         func = RNA_def_function(srna, "piemenu_end__internal", "rna_PieMenuEnd");
686         RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_CONTEXT);
687         parm = RNA_def_pointer(func, "menu", "UIPieMenu", "", "");
688         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_RNAPTR | PARM_REQUIRED);
689
690         /* access last operator options (optionally create). */
691         func = RNA_def_function(srna, "operator_properties_last", "rna_WindoManager_operator_properties_last");
692         RNA_def_function_flag(func, FUNC_NO_SELF);
693         parm = RNA_def_string(func, "operator", NULL, 0, "", "");
694         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
695         /* return */
696         parm = RNA_def_pointer(func, "result", "OperatorProperties", "", "");
697         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_RNAPTR);
698         RNA_def_function_return(func, parm);
699
700 }
701
702 void RNA_api_operator(StructRNA *srna)
703 {
704         FunctionRNA *func;
705         PropertyRNA *parm;
706
707         /* utility, not for registering */
708         func = RNA_def_function(srna, "report", "rna_Operator_report");
709         parm = RNA_def_enum_flag(func, "type", rna_enum_wm_report_items, 0, "Type", "");
710         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
711         parm = RNA_def_string(func, "message", NULL, 0, "Report Message", "");
712         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
713
714         /* utility, not for registering */
715         func = RNA_def_function(srna, "is_repeat", "rna_Operator_is_repeat");
716         RNA_def_function_flag(func, FUNC_USE_CONTEXT);
717         /* return */
718         parm = RNA_def_boolean(func, "result", 0, "result", "");
719         RNA_def_function_return(func, parm);
720
721         /* Registration */
722
723         /* poll */
724         func = RNA_def_function(srna, "poll", NULL);
725         RNA_def_function_ui_description(func, "Test if the operator can be called or not");
726         RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_REGISTER_OPTIONAL);
727         RNA_def_function_return(func, RNA_def_boolean(func, "visible", 1, "", ""));
728         parm = RNA_def_pointer(func, "context", "Context", "", "");
729         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
730
731         /* exec */
732         func = RNA_def_function(srna, "execute", NULL);
733         RNA_def_function_ui_description(func, "Execute the operator");
734         RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL | FUNC_ALLOW_WRITE);
735         parm = RNA_def_pointer(func, "context", "Context", "", "");
736         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
737
738         /* better name? */
739         parm = RNA_def_enum_flag(func, "result", rna_enum_operator_return_items, OPERATOR_CANCELLED, "result", "");
740         RNA_def_function_return(func, parm);
741
742         /* check */
743         func = RNA_def_function(srna, "check", NULL);
744         RNA_def_function_ui_description(func, "Check the operator settings, return True to signal a change to redraw");
745         RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL | FUNC_ALLOW_WRITE);
746         parm = RNA_def_pointer(func, "context", "Context", "", "");
747         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
748
749         parm = RNA_def_boolean(func, "result", 0, "result", ""); /* better name? */
750         RNA_def_function_return(func, parm);
751
752         /* invoke */
753         func = RNA_def_function(srna, "invoke", NULL);
754         RNA_def_function_ui_description(func, "Invoke the operator");
755         RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL | FUNC_ALLOW_WRITE);
756         parm = RNA_def_pointer(func, "context", "Context", "", "");
757         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
758         parm = RNA_def_pointer(func, "event", "Event", "", "");
759         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
760
761         /* better name? */
762         parm = RNA_def_enum_flag(func, "result", rna_enum_operator_return_items, OPERATOR_CANCELLED, "result", "");
763         RNA_def_function_return(func, parm);
764
765         func = RNA_def_function(srna, "modal", NULL); /* same as invoke */
766         RNA_def_function_ui_description(func, "Modal operator function");
767         RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL | FUNC_ALLOW_WRITE);
768         parm = RNA_def_pointer(func, "context", "Context", "", "");
769         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
770         parm = RNA_def_pointer(func, "event", "Event", "", "");
771         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
772
773         /* better name? */
774         parm = RNA_def_enum_flag(func, "result", rna_enum_operator_return_items, OPERATOR_CANCELLED, "result", "");
775         RNA_def_function_return(func, parm);
776
777         /* draw */
778         func = RNA_def_function(srna, "draw", NULL);
779         RNA_def_function_ui_description(func, "Draw function for the operator");
780         RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL);
781         parm = RNA_def_pointer(func, "context", "Context", "", "");
782         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
783
784         /* cancel */
785         func = RNA_def_function(srna, "cancel", NULL);
786         RNA_def_function_ui_description(func, "Called when the operator is canceled");
787         RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL | FUNC_ALLOW_WRITE);
788         parm = RNA_def_pointer(func, "context", "Context", "", "");
789         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
790 }
791
792 void RNA_api_macro(StructRNA *srna)
793 {
794         FunctionRNA *func;
795         PropertyRNA *parm;
796
797         /* utility, not for registering */
798         func = RNA_def_function(srna, "report", "rna_Operator_report");
799         parm = RNA_def_enum_flag(func, "type", rna_enum_wm_report_items, 0, "Type", "");
800         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
801         parm = RNA_def_string(func, "message", NULL, 0, "Report Message", "");
802         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
803
804
805         /* Registration */
806
807         /* poll */
808         func = RNA_def_function(srna, "poll", NULL);
809         RNA_def_function_ui_description(func, "Test if the operator can be called or not");
810         RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_REGISTER_OPTIONAL);
811         RNA_def_function_return(func, RNA_def_boolean(func, "visible", 1, "", ""));
812         parm = RNA_def_pointer(func, "context", "Context", "", "");
813         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
814
815         /* draw */
816         func = RNA_def_function(srna, "draw", NULL);
817         RNA_def_function_ui_description(func, "Draw function for the operator");
818         RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL);
819         parm = RNA_def_pointer(func, "context", "Context", "", "");
820         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
821 }
822
823 void RNA_api_keyconfig(StructRNA *UNUSED(srna))
824 {
825         /* FunctionRNA *func; */
826         /* PropertyRNA *parm; */
827 }
828
829 void RNA_api_keymap(StructRNA *srna)
830 {
831         FunctionRNA *func;
832         PropertyRNA *parm;
833
834         func = RNA_def_function(srna, "active", "rna_keymap_active");
835         RNA_def_function_flag(func, FUNC_USE_CONTEXT);
836         parm = RNA_def_pointer(func, "keymap", "KeyMap", "Key Map", "Active key map");
837         RNA_def_function_return(func, parm);
838
839         func = RNA_def_function(srna, "restore_to_default", "WM_keymap_restore_to_default");
840         RNA_def_function_flag(func, FUNC_USE_CONTEXT);
841
842         func = RNA_def_function(srna, "restore_item_to_default", "rna_keymap_restore_item_to_default");
843         RNA_def_function_flag(func, FUNC_USE_CONTEXT);
844         parm = RNA_def_pointer(func, "item", "KeyMapItem", "Item", "");
845         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
846 }
847
848 void RNA_api_keymapitem(StructRNA *srna)
849 {
850         FunctionRNA *func;
851         PropertyRNA *parm;
852
853         func = RNA_def_function(srna, "compare", "WM_keymap_item_compare");
854         parm = RNA_def_pointer(func, "item", "KeyMapItem", "Item", "");
855         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
856         parm = RNA_def_boolean(func, "result", 0, "Comparison result", "");
857         RNA_def_function_return(func, parm);
858
859         func = RNA_def_function(srna, "to_string", "rna_KeyMapItem_to_string");
860         RNA_def_boolean(func, "compact", false, "Compact", "");
861         parm = RNA_def_string(func, "result", NULL, UI_MAX_SHORTCUT_STR, "result", "");
862         RNA_def_parameter_flags(parm, PROP_THICK_WRAP, 0);
863         RNA_def_function_output(func, parm);
864 }
865
866 void RNA_api_keymapitems(StructRNA *srna)
867 {
868         FunctionRNA *func;
869         PropertyRNA *parm;
870
871         func = RNA_def_function(srna, "new", "rna_KeyMap_item_new");
872         RNA_def_function_flag(func, FUNC_USE_REPORTS);
873         parm = RNA_def_string(func, "idname", NULL, 0, "Operator Identifier", "");
874         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
875         parm = RNA_def_enum(func, "type", rna_enum_event_type_items, 0, "Type", "");
876         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
877         parm = RNA_def_enum(func, "value", rna_enum_event_value_items, 0, "Value", "");
878         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
879         RNA_def_boolean(func, "any", 0, "Any", "");
880         RNA_def_boolean(func, "shift", 0, "Shift", "");
881         RNA_def_boolean(func, "ctrl", 0, "Ctrl", "");
882         RNA_def_boolean(func, "alt", 0, "Alt", "");
883         RNA_def_boolean(func, "oskey", 0, "OS Key", "");
884         RNA_def_enum(func, "key_modifier", rna_enum_event_type_items, 0, "Key Modifier", "");
885         RNA_def_boolean(func, "head", 0, "At Head",
886                         "Force item to be added at start (not end) of key map so that "
887                         "it doesn't get blocked by an existing key map item");
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_modal", "rna_KeyMap_item_new_modal");
892         RNA_def_function_flag(func, FUNC_USE_REPORTS);
893         parm = RNA_def_string(func, "propvalue", NULL, 0, "Property Value", "");
894         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
895         parm = RNA_def_enum(func, "type", rna_enum_event_type_items, 0, "Type", "");
896         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
897         parm = RNA_def_enum(func, "value", rna_enum_event_value_items, 0, "Value", "");
898         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
899         RNA_def_boolean(func, "any", 0, "Any", "");
900         RNA_def_boolean(func, "shift", 0, "Shift", "");
901         RNA_def_boolean(func, "ctrl", 0, "Ctrl", "");
902         RNA_def_boolean(func, "alt", 0, "Alt", "");
903         RNA_def_boolean(func, "oskey", 0, "OS Key", "");
904         RNA_def_enum(func, "key_modifier", rna_enum_event_type_items, 0, "Key Modifier", "");
905         parm = RNA_def_pointer(func, "item", "KeyMapItem", "Item", "Added key map item");
906         RNA_def_function_return(func, parm);
907
908         func = RNA_def_function(srna, "new_from_item", "rna_KeyMap_item_new_from_item");
909         RNA_def_function_flag(func, FUNC_USE_REPORTS);
910         parm = RNA_def_pointer(func, "item", "KeyMapItem", "Item", "Item to use as a reference");
911         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
912         RNA_def_boolean(func, "head", 0, "At Head", "");
913         parm = RNA_def_pointer(func, "result", "KeyMapItem", "Item", "Added key map item");
914         RNA_def_function_return(func, parm);
915
916         func = RNA_def_function(srna, "remove", "rna_KeyMap_item_remove");
917         RNA_def_function_flag(func, FUNC_USE_REPORTS);
918         parm = RNA_def_pointer(func, "item", "KeyMapItem", "Item", "");
919         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
920         RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
921
922         func = RNA_def_function(srna, "from_id", "WM_keymap_item_find_id");
923         parm = RNA_def_property(func, "id", PROP_INT, PROP_NONE);
924         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
925         RNA_def_property_ui_text(parm, "id", "ID of the item");
926         parm = RNA_def_pointer(func, "item", "KeyMapItem", "Item", "");
927         RNA_def_function_return(func, parm);
928
929         /* Keymap introspection
930          * Args follow: KeyConfigs.find_item_from_operator */
931         func = RNA_def_function(srna, "find_from_operator", "rna_KeyMap_item_find_from_operator");
932         RNA_def_function_flag(func, FUNC_USE_SELF_ID);
933         parm = RNA_def_string(func, "idname", NULL, 0, "Operator Identifier", "");
934         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
935         parm = RNA_def_pointer(func, "properties", "OperatorProperties", "", "");
936         RNA_def_parameter_flags(parm, 0, PARM_RNAPTR);
937         RNA_def_enum_flag(func, "include", rna_enum_event_type_mask_items, EVT_TYPE_MASK_ALL, "Include", "");
938         RNA_def_enum_flag(func, "exclude", rna_enum_event_type_mask_items, 0, "Exclude", "");
939         parm = RNA_def_pointer(func, "item", "KeyMapItem", "", "");
940         RNA_def_parameter_flags(parm, 0, PARM_RNAPTR);
941         RNA_def_function_return(func, parm);
942 }
943
944 void RNA_api_keymaps(StructRNA *srna)
945 {
946         FunctionRNA *func;
947         PropertyRNA *parm;
948
949         func = RNA_def_function(srna, "new", "rna_keymap_new"); /* add_keymap */
950         parm = RNA_def_string(func, "name", NULL, 0, "Name", "");
951         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
952         RNA_def_enum(func, "space_type", rna_enum_space_type_items, SPACE_EMPTY, "Space Type", "");
953         RNA_def_enum(func, "region_type", rna_enum_region_type_items, RGN_TYPE_WINDOW, "Region Type", "");
954         RNA_def_boolean(func, "modal", 0, "Modal", "Keymap for modal operators");
955         RNA_def_boolean(func, "tool", 0, "Tool", "Keymap for active tools");
956         parm = RNA_def_pointer(func, "keymap", "KeyMap", "Key Map", "Added key map");
957         RNA_def_function_return(func, parm);
958
959         func = RNA_def_function(srna, "remove", "rna_KeyMap_remove"); /* remove_keymap */
960         RNA_def_function_flag(func, FUNC_USE_REPORTS);
961         parm = RNA_def_pointer(func, "keymap", "KeyMap", "Key Map", "Removed key map");
962         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
963         RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
964
965         func = RNA_def_function(srna, "find", "rna_keymap_find"); /* find_keymap */
966         parm = RNA_def_string(func, "name", NULL, 0, "Name", "");
967         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
968         RNA_def_enum(func, "space_type", rna_enum_space_type_items, SPACE_EMPTY, "Space Type", "");
969         RNA_def_enum(func, "region_type", rna_enum_region_type_items, RGN_TYPE_WINDOW, "Region Type", "");
970         parm = RNA_def_pointer(func, "keymap", "KeyMap", "Key Map", "Corresponding key map");
971         RNA_def_function_return(func, parm);
972
973         func = RNA_def_function(srna, "find_modal", "rna_keymap_find_modal"); /* find_keymap_modal */
974         parm = RNA_def_string(func, "name", NULL, 0, "Operator Name", "");
975         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
976         parm = RNA_def_pointer(func, "keymap", "KeyMap", "Key Map", "Corresponding key map");
977         RNA_def_function_return(func, parm);
978 }
979
980 void RNA_api_keyconfigs(StructRNA *srna)
981 {
982         FunctionRNA *func;
983         PropertyRNA *parm;
984
985         func = RNA_def_function(srna, "new", "WM_keyconfig_new_user"); /* add_keyconfig */
986         parm = RNA_def_string(func, "name", NULL, 0, "Name", "");
987         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
988         parm = RNA_def_pointer(func, "keyconfig", "KeyConfig", "Key Configuration", "Added key configuration");
989         RNA_def_function_return(func, parm);
990
991         func = RNA_def_function(srna, "remove", "rna_KeyConfig_remove"); /* remove_keyconfig */
992         RNA_def_function_flag(func, FUNC_USE_REPORTS);
993         parm = RNA_def_pointer(func, "keyconfig", "KeyConfig", "Key Configuration", "Removed key configuration");
994         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
995         RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
996
997         /* Helper functions */
998
999         /* Keymap introspection */
1000         func = RNA_def_function(srna, "find_item_from_operator", "rna_KeyConfig_find_item_from_operator");
1001         RNA_def_function_flag(func, FUNC_USE_CONTEXT);
1002         parm = RNA_def_string(func, "idname", NULL, 0, "Operator Identifier", "");
1003         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1004         parm = RNA_def_property(func, "context", PROP_ENUM, PROP_NONE);
1005         RNA_def_property_enum_items(parm, rna_enum_operator_context_items);
1006         parm = RNA_def_pointer(func, "properties", "OperatorProperties", "", "");
1007         RNA_def_parameter_flags(parm, 0, PARM_RNAPTR);
1008         RNA_def_enum_flag(func, "include", rna_enum_event_type_mask_items, EVT_TYPE_MASK_ALL, "Include", "");
1009         RNA_def_enum_flag(func, "exclude", rna_enum_event_type_mask_items, 0, "Exclude", "");
1010         parm = RNA_def_pointer(func, "keymap", "KeyMap", "", "");
1011         RNA_def_parameter_flags(parm, 0, PARM_RNAPTR | PARM_OUTPUT);
1012         parm = RNA_def_pointer(func, "item", "KeyMapItem", "", "");
1013         RNA_def_parameter_flags(parm, 0, PARM_RNAPTR);
1014         RNA_def_function_return(func, parm);
1015
1016         RNA_def_function(srna, "update", "rna_KeyConfig_update"); /* WM_keyconfig_update */
1017 }
1018
1019 #endif