CMake: add WITH_LINKER_LLD option for unix platforms
[blender-staging.git] / source / blender / makesrna / intern / rna_wm_api.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2009 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup RNA
22  */
23
24 #include <ctype.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27
28 #include "BLI_utildefines.h"
29
30 #include "RNA_define.h"
31 #include "RNA_enum_types.h"
32
33 #include "DNA_screen_types.h"
34 #include "DNA_space_types.h"
35 #include "DNA_windowmanager_types.h"
36
37 #include "UI_interface.h"
38
39 #include "wm_cursors.h"
40 #include "wm_event_types.h"
41
42 #include "rna_internal.h" /* own include */
43
44 /* confusing 2 enums mixed up here */
45 const EnumPropertyItem rna_enum_window_cursor_items[] = {
46     {WM_CURSOR_DEFAULT, "DEFAULT", 0, "Default", ""},
47     {WM_CURSOR_NONE, "NONE", 0, "None", ""},
48     {WM_CURSOR_WAIT, "WAIT", 0, "Wait", ""},
49     {WM_CURSOR_EDIT, "CROSSHAIR", 0, "Crosshair", ""},
50     {WM_CURSOR_X_MOVE, "MOVE_X", 0, "Move-X", ""},
51     {WM_CURSOR_Y_MOVE, "MOVE_Y", 0, "Move-Y", ""},
52
53     /* new */
54     {WM_CURSOR_KNIFE, "KNIFE", 0, "Knife", ""},
55     {WM_CURSOR_TEXT_EDIT, "TEXT", 0, "Text", ""},
56     {WM_CURSOR_PAINT_BRUSH, "PAINT_BRUSH", 0, "Paint Brush", ""},
57     {WM_CURSOR_PAINT, "PAINT_CROSS", 0, "Paint Cross", ""},
58     {WM_CURSOR_DOT, "DOT", 0, "Dot Cursor", ""},
59     {WM_CURSOR_ERASER, "ERASER", 0, "Eraser", ""},
60     {WM_CURSOR_HAND, "HAND", 0, "Hand", ""},
61     {WM_CURSOR_EW_SCROLL, "SCROLL_X", 0, "Scroll-X", ""},
62     {WM_CURSOR_NS_SCROLL, "SCROLL_Y", 0, "Scroll-Y", ""},
63     {WM_CURSOR_NSEW_SCROLL, "SCROLL_XY", 0, "Scroll-XY", ""},
64     {WM_CURSOR_EYEDROPPER, "EYEDROPPER", 0, "Eyedropper", ""},
65     {0, NULL, 0, NULL, NULL},
66 };
67
68 #ifdef RNA_RUNTIME
69
70 #  include "BKE_context.h"
71 #  include "BKE_undo_system.h"
72
73 #  include "WM_types.h"
74
75 static void rna_KeyMapItem_to_string(wmKeyMapItem *kmi, bool compact, char *result)
76 {
77   WM_keymap_item_to_string(kmi, compact, result, UI_MAX_SHORTCUT_STR);
78 }
79
80 static wmKeyMap *rna_keymap_active(wmKeyMap *km, bContext *C)
81 {
82   wmWindowManager *wm = CTX_wm_manager(C);
83   return WM_keymap_active(wm, km);
84 }
85
86 static void rna_keymap_restore_to_default(wmKeyMap *km, bContext *C)
87 {
88   WM_keymap_restore_to_default(km, CTX_wm_manager(C));
89 }
90
91 static void rna_keymap_restore_item_to_default(wmKeyMap *km, bContext *C, wmKeyMapItem *kmi)
92 {
93   WM_keymap_item_restore_to_default(CTX_wm_manager(C), km, kmi);
94 }
95
96 static void rna_Operator_report(wmOperator *op, int type, const char *msg)
97 {
98   BKE_report(op->reports, type, msg);
99 }
100
101 static bool rna_Operator_is_repeat(wmOperator *op, bContext *C)
102 {
103   return WM_operator_is_repeat(C, op);
104 }
105
106 /* since event isn't needed... */
107 static void rna_Operator_enum_search_invoke(bContext *C, wmOperator *op)
108 {
109   WM_enum_search_invoke(C, op, NULL);
110 }
111
112 static bool rna_event_modal_handler_add(struct bContext *C, struct wmOperator *operator)
113 {
114   return WM_event_add_modal_handler(C, operator) != NULL;
115 }
116
117 /* XXX, need a way for python to know event types, 0x0110 is hard coded */
118 static wmTimer *rna_event_timer_add(struct wmWindowManager *wm, float time_step, wmWindow *win)
119 {
120   return WM_event_add_timer(wm, win, 0x0110, time_step);
121 }
122
123 static void rna_event_timer_remove(struct wmWindowManager *wm, wmTimer *timer)
124 {
125   WM_event_remove_timer(wm, timer->win, timer);
126 }
127
128 static wmGizmoGroupType *wm_gizmogrouptype_find_for_add_remove(ReportList *reports,
129                                                                const char *idname)
130 {
131   wmGizmoGroupType *gzgt = WM_gizmogrouptype_find(idname, true);
132   if (gzgt == NULL) {
133     BKE_reportf(reports, RPT_ERROR, "Gizmo group type '%s' not found!", idname);
134     return NULL;
135   }
136   if (gzgt->flag & WM_GIZMOGROUPTYPE_PERSISTENT) {
137     BKE_reportf(reports, RPT_ERROR, "Gizmo group '%s' has 'PERSISTENT' option set!", idname);
138     return NULL;
139   }
140   return gzgt;
141 }
142
143 static void rna_gizmo_group_type_ensure(ReportList *reports, const char *idname)
144 {
145   wmGizmoGroupType *gzgt = wm_gizmogrouptype_find_for_add_remove(reports, idname);
146   if (gzgt != NULL) {
147     WM_gizmo_group_type_ensure_ptr(gzgt);
148   }
149 }
150
151 static void rna_gizmo_group_type_unlink_delayed(ReportList *reports, const char *idname)
152 {
153   wmGizmoGroupType *gzgt = wm_gizmogrouptype_find_for_add_remove(reports, idname);
154   if (gzgt != NULL) {
155     WM_gizmo_group_type_unlink_delayed_ptr(gzgt);
156   }
157 }
158
159 /* placeholder data for final implementation of a true progressbar */
160 static struct wmStaticProgress {
161   float min;
162   float max;
163   bool is_valid;
164 } wm_progress_state = {0, 0, false};
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) /
186                       (wm_progress_state.max - wm_progress_state.min));
187       WM_cursor_time(win, val);
188     }
189   }
190 }
191
192 static void rna_progress_end(struct wmWindowManager *wm)
193 {
194   if (wm_progress_state.is_valid) {
195     wmWindow *win = wm->winactive;
196     if (win) {
197       WM_cursor_modal_restore(win);
198       wm_progress_state.is_valid = false;
199     }
200   }
201 }
202
203 /* wrap these because of 'const wmEvent *' */
204 static int rna_Operator_confirm(bContext *C, wmOperator *op, wmEvent *event)
205 {
206   return WM_operator_confirm(C, op, event);
207 }
208 static int rna_Operator_props_popup(bContext *C, wmOperator *op, wmEvent *event)
209 {
210   return WM_operator_props_popup(C, op, event);
211 }
212
213 static wmKeyMapItem *rna_KeyMap_item_new(wmKeyMap *km,
214                                          ReportList *reports,
215                                          const char *idname,
216                                          int type,
217                                          int value,
218                                          bool any,
219                                          bool shift,
220                                          bool ctrl,
221                                          bool alt,
222                                          bool oskey,
223                                          int keymodifier,
224                                          bool repeat,
225                                          bool head)
226 {
227   /*  wmWindowManager *wm = CTX_wm_manager(C); */
228   wmKeyMapItem *kmi = NULL;
229   char idname_bl[OP_MAX_TYPENAME];
230   int modifier = 0;
231
232   /* only on non-modal maps */
233   if (km->flag & KEYMAP_MODAL) {
234     BKE_report(reports, RPT_ERROR, "Not a non-modal keymap");
235     return NULL;
236   }
237
238   WM_operator_bl_idname(idname_bl, idname);
239
240   if (shift) {
241     modifier |= KM_SHIFT;
242   }
243   if (ctrl) {
244     modifier |= KM_CTRL;
245   }
246   if (alt) {
247     modifier |= KM_ALT;
248   }
249   if (oskey) {
250     modifier |= KM_OSKEY;
251   }
252
253   if (any) {
254     modifier = KM_ANY;
255   }
256
257   /* create keymap item */
258   kmi = WM_keymap_add_item(km, idname_bl, type, value, modifier, keymodifier);
259
260   if (!repeat) {
261     kmi->flag |= KMI_REPEAT_IGNORE;
262   }
263
264   /* [#32437] allow scripts to define hotkeys that get added to start of keymap
265    *          so that they stand a chance against catch-all defines later on
266    */
267   if (head) {
268     BLI_remlink(&km->items, kmi);
269     BLI_addhead(&km->items, kmi);
270   }
271
272   return kmi;
273 }
274
275 static wmKeyMapItem *rna_KeyMap_item_new_from_item(wmKeyMap *km,
276                                                    ReportList *reports,
277                                                    wmKeyMapItem *kmi_src,
278                                                    bool head)
279 {
280   /*  wmWindowManager *wm = CTX_wm_manager(C); */
281
282   if ((km->flag & KEYMAP_MODAL) == (kmi_src->idname[0] != '\0')) {
283     BKE_report(reports, RPT_ERROR, "Can not mix modal/non-modal items");
284     return NULL;
285   }
286
287   /* create keymap item */
288   wmKeyMapItem *kmi = WM_keymap_add_item_copy(km, kmi_src);
289   if (head) {
290     BLI_remlink(&km->items, kmi);
291     BLI_addhead(&km->items, kmi);
292   }
293   return kmi;
294 }
295
296 static wmKeyMapItem *rna_KeyMap_item_new_modal(wmKeyMap *km,
297                                                ReportList *reports,
298                                                const char *propvalue_str,
299                                                int type,
300                                                int value,
301                                                bool any,
302                                                bool shift,
303                                                bool ctrl,
304                                                bool alt,
305                                                bool oskey,
306                                                int keymodifier,
307                                                bool repeat)
308 {
309   wmKeyMapItem *kmi = NULL;
310   int modifier = 0;
311   int propvalue = 0;
312
313   /* only modal maps */
314   if ((km->flag & KEYMAP_MODAL) == 0) {
315     BKE_report(reports, RPT_ERROR, "Not a modal keymap");
316     return NULL;
317   }
318
319   if (shift) {
320     modifier |= KM_SHIFT;
321   }
322   if (ctrl) {
323     modifier |= KM_CTRL;
324   }
325   if (alt) {
326     modifier |= KM_ALT;
327   }
328   if (oskey) {
329     modifier |= KM_OSKEY;
330   }
331
332   if (any) {
333     modifier = KM_ANY;
334   }
335
336   /* not initialized yet, do delayed lookup */
337   if (!km->modal_items) {
338     kmi = WM_modalkeymap_add_item_str(km, type, value, modifier, keymodifier, propvalue_str);
339   }
340   else {
341     if (RNA_enum_value_from_id(km->modal_items, propvalue_str, &propvalue) == 0) {
342       BKE_report(reports, RPT_WARNING, "Property value not in enumeration");
343     }
344     kmi = WM_modalkeymap_add_item(km, type, value, modifier, keymodifier, propvalue);
345   }
346
347   if (!repeat) {
348     kmi->flag |= KMI_REPEAT_IGNORE;
349   }
350
351   return kmi;
352 }
353
354 static void rna_KeyMap_item_remove(wmKeyMap *km, ReportList *reports, PointerRNA *kmi_ptr)
355 {
356   wmKeyMapItem *kmi = kmi_ptr->data;
357
358   if (WM_keymap_remove_item(km, kmi) == false) {
359     BKE_reportf(reports,
360                 RPT_ERROR,
361                 "KeyMapItem '%s' cannot be removed from '%s'",
362                 kmi->idname,
363                 km->idname);
364     return;
365   }
366
367   RNA_POINTER_INVALIDATE(kmi_ptr);
368 }
369
370 static PointerRNA rna_KeyMap_item_find_from_operator(ID *id,
371                                                      wmKeyMap *km,
372                                                      const char *idname,
373                                                      PointerRNA *properties,
374                                                      int include_mask,
375                                                      int exclude_mask)
376 {
377   char idname_bl[OP_MAX_TYPENAME];
378   WM_operator_bl_idname(idname_bl, idname);
379
380   wmKeyMapItem *kmi = WM_key_event_operator_from_keymap(
381       km, idname_bl, properties->data, include_mask, exclude_mask);
382   PointerRNA kmi_ptr;
383   RNA_pointer_create(id, &RNA_KeyMapItem, kmi, &kmi_ptr);
384   return kmi_ptr;
385 }
386
387 static PointerRNA rna_KeyMap_item_match_event(ID *id, wmKeyMap *km, bContext *C, wmEvent *event)
388 {
389   wmKeyMapItem *kmi = WM_event_match_keymap_item(C, km, event);
390   PointerRNA kmi_ptr;
391   RNA_pointer_create(id, &RNA_KeyMapItem, kmi, &kmi_ptr);
392   return kmi_ptr;
393 }
394
395 static wmKeyMap *rna_keymap_new(wmKeyConfig *keyconf,
396                                 ReportList *reports,
397                                 const char *idname,
398                                 int spaceid,
399                                 int regionid,
400                                 bool modal,
401                                 bool tool)
402 {
403   if (modal) {
404     /* Sanity check: Don't allow add-ons to override internal modal key-maps
405      * because this isn't supported, the restriction can be removed when
406      * add-ons can define modal key-maps.
407      * Currently this is only useful for add-ons to override built-in modal keymaps
408      * which is not the intended use for add-on keymaps. */
409     wmWindowManager *wm = G_MAIN->wm.first;
410     if (keyconf == wm->addonconf) {
411       BKE_reportf(reports, RPT_ERROR, "Modal key-maps not supported for add-on key-config");
412       return NULL;
413     }
414   }
415
416   wmKeyMap *keymap;
417
418   if (modal == 0) {
419     keymap = WM_keymap_ensure(keyconf, idname, spaceid, regionid);
420   }
421   else {
422     keymap = WM_modalkeymap_ensure(keyconf, idname, NULL); /* items will be lazy init */
423   }
424
425   if (keymap && tool) {
426     keymap->flag |= KEYMAP_TOOL;
427   }
428
429   return keymap;
430 }
431
432 static wmKeyMap *rna_keymap_find(wmKeyConfig *keyconf,
433                                  const char *idname,
434                                  int spaceid,
435                                  int regionid)
436 {
437   return WM_keymap_list_find(&keyconf->keymaps, idname, spaceid, regionid);
438 }
439
440 static wmKeyMap *rna_keymap_find_modal(wmKeyConfig *UNUSED(keyconf), const char *idname)
441 {
442   wmOperatorType *ot = WM_operatortype_find(idname, 0);
443
444   if (!ot) {
445     return NULL;
446   }
447   else {
448     return ot->modalkeymap;
449   }
450 }
451
452 static void rna_KeyMap_remove(wmKeyConfig *keyconfig, ReportList *reports, PointerRNA *keymap_ptr)
453 {
454   wmKeyMap *keymap = keymap_ptr->data;
455
456   if (WM_keymap_remove(keyconfig, keymap) == false) {
457     BKE_reportf(reports, RPT_ERROR, "KeyConfig '%s' cannot be removed", keymap->idname);
458     return;
459   }
460
461   RNA_POINTER_INVALIDATE(keymap_ptr);
462 }
463
464 static void rna_KeyConfig_remove(wmWindowManager *wm, ReportList *reports, PointerRNA *keyconf_ptr)
465 {
466   wmKeyConfig *keyconf = keyconf_ptr->data;
467
468   if (WM_keyconfig_remove(wm, keyconf) == false) {
469     BKE_reportf(reports, RPT_ERROR, "KeyConfig '%s' cannot be removed", keyconf->idname);
470     return;
471   }
472
473   RNA_POINTER_INVALIDATE(keyconf_ptr);
474 }
475
476 static PointerRNA rna_KeyConfig_find_item_from_operator(wmWindowManager *wm,
477                                                         bContext *C,
478                                                         const char *idname,
479                                                         int opcontext,
480                                                         PointerRNA *properties,
481                                                         int include_mask,
482                                                         int exclude_mask,
483                                                         PointerRNA *km_ptr)
484 {
485   char idname_bl[OP_MAX_TYPENAME];
486   WM_operator_bl_idname(idname_bl, idname);
487
488   wmKeyMap *km = NULL;
489   wmKeyMapItem *kmi = WM_key_event_operator(
490       C, idname_bl, opcontext, properties->data, include_mask, exclude_mask, &km);
491   PointerRNA kmi_ptr;
492   RNA_pointer_create(&wm->id, &RNA_KeyMap, km, km_ptr);
493   RNA_pointer_create(&wm->id, &RNA_KeyMapItem, kmi, &kmi_ptr);
494   return kmi_ptr;
495 }
496
497 static void rna_KeyConfig_update(wmWindowManager *wm)
498 {
499   WM_keyconfig_update(wm);
500 }
501
502 /* popup menu wrapper */
503 static PointerRNA rna_PopMenuBegin(bContext *C, const char *title, int icon)
504 {
505   PointerRNA r_ptr;
506   void *data;
507
508   data = (void *)UI_popup_menu_begin(C, title, icon);
509
510   RNA_pointer_create(NULL, &RNA_UIPopupMenu, data, &r_ptr);
511
512   return r_ptr;
513 }
514
515 static void rna_PopMenuEnd(bContext *C, PointerRNA *handle)
516 {
517   UI_popup_menu_end(C, handle->data);
518 }
519
520 /* popover wrapper */
521 static PointerRNA rna_PopoverBegin(bContext *C, int ui_units_x, bool from_active_button)
522 {
523   PointerRNA r_ptr;
524   void *data;
525
526   data = (void *)UI_popover_begin(C, U.widget_unit * ui_units_x, from_active_button);
527
528   RNA_pointer_create(NULL, &RNA_UIPopover, data, &r_ptr);
529
530   return r_ptr;
531 }
532
533 static void rna_PopoverEnd(bContext *C, PointerRNA *handle, wmKeyMap *keymap)
534 {
535   UI_popover_end(C, handle->data, keymap);
536 }
537
538 /* pie menu wrapper */
539 static PointerRNA rna_PieMenuBegin(bContext *C, const char *title, int icon, PointerRNA *event)
540 {
541   PointerRNA r_ptr;
542   void *data;
543
544   data = (void *)UI_pie_menu_begin(C, title, icon, event->data);
545
546   RNA_pointer_create(NULL, &RNA_UIPieMenu, data, &r_ptr);
547
548   return r_ptr;
549 }
550
551 static void rna_PieMenuEnd(bContext *C, PointerRNA *handle)
552 {
553   UI_pie_menu_end(C, handle->data);
554 }
555
556 static void rna_WindowManager_print_undo_steps(wmWindowManager *wm)
557 {
558   BKE_undosys_print(wm->undo_stack);
559 }
560
561 static PointerRNA rna_WindoManager_operator_properties_last(const char *idname)
562 {
563   wmOperatorType *ot = WM_operatortype_find(idname, true);
564
565   if (ot != NULL) {
566     PointerRNA ptr;
567     WM_operator_last_properties_ensure(ot, &ptr);
568     return ptr;
569   }
570   return PointerRNA_NULL;
571 }
572
573 static wmEvent *rna_Window_event_add_simulate(wmWindow *win,
574                                               ReportList *reports,
575                                               int type,
576                                               int value,
577                                               const char *unicode,
578                                               int x,
579                                               int y,
580                                               bool shift,
581                                               bool ctrl,
582                                               bool alt,
583                                               bool oskey)
584 {
585   if ((G.f & G_FLAG_EVENT_SIMULATE) == 0) {
586     BKE_report(reports, RPT_ERROR, "Not running with '--enable-event-simulate' enabled");
587     return NULL;
588   }
589
590   if (!ELEM(value, KM_PRESS, KM_RELEASE, KM_NOTHING)) {
591     BKE_report(reports, RPT_ERROR, "Value: only 'PRESS/RELEASE/NOTHING' are supported");
592     return NULL;
593   }
594   if (ISKEYBOARD(type) || ISMOUSE_BUTTON(type)) {
595     if (!ELEM(value, KM_PRESS, KM_RELEASE)) {
596       BKE_report(reports, RPT_ERROR, "Value: must be 'PRESS/RELEASE' for keyboard/buttons");
597       return NULL;
598     }
599   }
600   if (ELEM(type, MOUSEMOVE, INBETWEEN_MOUSEMOVE)) {
601     if (value != KM_NOTHING) {
602       BKE_report(reports, RPT_ERROR, "Value: must be 'NOTHING' for motion");
603       return NULL;
604     }
605   }
606   if (unicode != NULL) {
607     if (value != KM_PRESS) {
608       BKE_report(reports, RPT_ERROR, "Value: must be 'PRESS' when unicode is set");
609       return NULL;
610     }
611   }
612   /* TODO: validate NDOF. */
613
614   char ascii = 0;
615   if (unicode != NULL) {
616     int len = BLI_str_utf8_size(unicode);
617     if (len == -1 || unicode[len] != '\0') {
618       BKE_report(reports, RPT_ERROR, "Only a single character supported");
619       return NULL;
620     }
621     if (len == 1 && isascii(unicode[0])) {
622       ascii = unicode[0];
623     }
624   }
625
626   wmEvent e = *win->eventstate;
627   e.type = type;
628   e.val = value;
629   e.x = x;
630   e.y = y;
631   /* Note: KM_MOD_FIRST, KM_MOD_SECOND aren't used anywhere, set as bools */
632   e.shift = shift;
633   e.ctrl = ctrl;
634   e.alt = alt;
635   e.oskey = oskey;
636
637   e.prevx = win->eventstate->x;
638   e.prevy = win->eventstate->y;
639   e.prevval = win->eventstate->val;
640   e.prevtype = win->eventstate->type;
641
642   e.ascii = '\0';
643   e.utf8_buf[0] = '\0';
644   if (unicode != NULL) {
645     e.ascii = ascii;
646     STRNCPY(e.utf8_buf, unicode);
647   }
648
649   return WM_event_add_simulate(win, &e);
650 }
651
652 #else
653
654 #  define WM_GEN_INVOKE_EVENT (1 << 0)
655 #  define WM_GEN_INVOKE_SIZE (1 << 1)
656 #  define WM_GEN_INVOKE_RETURN (1 << 2)
657
658 static void rna_generic_op_invoke(FunctionRNA *func, int flag)
659 {
660   PropertyRNA *parm;
661
662   RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_CONTEXT);
663   parm = RNA_def_pointer(func, "operator", "Operator", "", "Operator to call");
664   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
665
666   if (flag & WM_GEN_INVOKE_EVENT) {
667     parm = RNA_def_pointer(func, "event", "Event", "", "Event");
668     RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
669   }
670
671   if (flag & WM_GEN_INVOKE_SIZE) {
672     RNA_def_int(func, "width", 300, 0, INT_MAX, "", "Width of the popup", 0, INT_MAX);
673   }
674
675   if (flag & WM_GEN_INVOKE_RETURN) {
676     parm = RNA_def_enum_flag(
677         func, "result", rna_enum_operator_return_items, OPERATOR_FINISHED, "result", "");
678     RNA_def_function_return(func, parm);
679   }
680 }
681
682 void RNA_api_window(StructRNA *srna)
683 {
684   FunctionRNA *func;
685   PropertyRNA *parm;
686
687   func = RNA_def_function(srna, "cursor_warp", "WM_cursor_warp");
688   parm = RNA_def_int(func, "x", 0, INT_MIN, INT_MAX, "", "", INT_MIN, INT_MAX);
689   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
690   parm = RNA_def_int(func, "y", 0, INT_MIN, INT_MAX, "", "", INT_MIN, INT_MAX);
691   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
692   RNA_def_function_ui_description(func, "Set the cursor position");
693
694   func = RNA_def_function(srna, "cursor_set", "WM_cursor_set");
695   parm = RNA_def_property(func, "cursor", PROP_ENUM, PROP_NONE);
696   RNA_def_property_enum_items(parm, rna_enum_window_cursor_items);
697   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
698   RNA_def_function_ui_description(func, "Set the cursor");
699
700   func = RNA_def_function(srna, "cursor_modal_set", "WM_cursor_modal_set");
701   parm = RNA_def_property(func, "cursor", PROP_ENUM, PROP_NONE);
702   RNA_def_property_enum_items(parm, rna_enum_window_cursor_items);
703   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
704   RNA_def_function_ui_description(func, "Set the cursor, so the previous cursor can be restored");
705
706   RNA_def_function(srna, "cursor_modal_restore", "WM_cursor_modal_restore");
707   RNA_def_function_ui_description(
708       func, "Restore the previous cursor after calling ``cursor_modal_set``");
709
710   /* Arguments match 'rna_KeyMap_item_new'. */
711   func = RNA_def_function(srna, "event_simulate", "rna_Window_event_add_simulate");
712   RNA_def_function_flag(func, FUNC_USE_REPORTS);
713   parm = RNA_def_enum(func, "type", rna_enum_event_type_items, 0, "Type", "");
714   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
715   parm = RNA_def_enum(func, "value", rna_enum_event_value_items, 0, "Value", "");
716   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
717   parm = RNA_def_string(func, "unicode", NULL, 0, "", "");
718   RNA_def_parameter_clear_flags(parm, PROP_NEVER_NULL, 0);
719
720   RNA_def_int(func, "x", 0, INT_MIN, INT_MAX, "", "", INT_MIN, INT_MAX);
721   RNA_def_int(func, "y", 0, INT_MIN, INT_MAX, "", "", INT_MIN, INT_MAX);
722
723   RNA_def_boolean(func, "shift", 0, "Shift", "");
724   RNA_def_boolean(func, "ctrl", 0, "Ctrl", "");
725   RNA_def_boolean(func, "alt", 0, "Alt", "");
726   RNA_def_boolean(func, "oskey", 0, "OS Key", "");
727   parm = RNA_def_pointer(func, "event", "Event", "Item", "Added key map item");
728   RNA_def_function_return(func, parm);
729 }
730
731 void RNA_api_wm(StructRNA *srna)
732 {
733   FunctionRNA *func;
734   PropertyRNA *parm;
735
736   func = RNA_def_function(srna, "fileselect_add", "WM_event_add_fileselect");
737   RNA_def_function_ui_description(
738       func,
739       "Opens a file selector with an operator. "
740       "The string properties 'filepath', 'filename', 'directory' and a 'files' "
741       "collection are assigned when present in the operator");
742   rna_generic_op_invoke(func, 0);
743
744   func = RNA_def_function(srna, "modal_handler_add", "rna_event_modal_handler_add");
745   RNA_def_function_ui_description(
746       func,
747       "Add a modal handler to the window manager, for the given modal operator "
748       "(called by invoke() with self, just before returning {'RUNNING_MODAL'})");
749   RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_CONTEXT);
750   parm = RNA_def_pointer(func, "operator", "Operator", "", "Operator to call");
751   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
752   RNA_def_function_return(
753       func, RNA_def_boolean(func, "handle", 1, "", "Whether adding the handler was successful"));
754
755   func = RNA_def_function(srna, "event_timer_add", "rna_event_timer_add");
756   RNA_def_function_ui_description(
757       func, "Add a timer to the given window, to generate periodic 'TIMER' events");
758   parm = RNA_def_property(func, "time_step", PROP_FLOAT, PROP_NONE);
759   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
760   RNA_def_property_range(parm, 0.0, FLT_MAX);
761   RNA_def_property_ui_text(parm, "Time Step", "Interval in seconds between timer events");
762   RNA_def_pointer(func, "window", "Window", "", "Window to attach the timer to, or None");
763   parm = RNA_def_pointer(func, "result", "Timer", "", "");
764   RNA_def_function_return(func, parm);
765
766   func = RNA_def_function(srna, "event_timer_remove", "rna_event_timer_remove");
767   parm = RNA_def_pointer(func, "timer", "Timer", "", "");
768   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
769
770   func = RNA_def_function(srna, "gizmo_group_type_ensure", "rna_gizmo_group_type_ensure");
771   RNA_def_function_ui_description(
772       func, "Activate an existing widget group (when the persistent option isn't set)");
773   RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_REPORTS);
774   parm = RNA_def_string(func, "identifier", NULL, 0, "", "Gizmo group type name");
775   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
776
777   func = RNA_def_function(
778       srna, "gizmo_group_type_unlink_delayed", "rna_gizmo_group_type_unlink_delayed");
779   RNA_def_function_ui_description(func,
780                                   "Unlink a widget group (when the persistent option is set)");
781   RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_REPORTS);
782   parm = RNA_def_string(func, "identifier", NULL, 0, "", "Gizmo group type name");
783   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
784
785   /* Progress bar interface */
786   func = RNA_def_function(srna, "progress_begin", "rna_progress_begin");
787   RNA_def_function_ui_description(func, "Start progress report");
788   parm = RNA_def_property(func, "min", PROP_FLOAT, PROP_NONE);
789   RNA_def_property_ui_text(parm, "min", "any value in range [0,9999]");
790   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
791   parm = RNA_def_property(func, "max", PROP_FLOAT, PROP_NONE);
792   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
793   RNA_def_property_ui_text(parm, "max", "any value in range [min+1,9998]");
794
795   func = RNA_def_function(srna, "progress_update", "rna_progress_update");
796   RNA_def_function_ui_description(func, "Update the progress feedback");
797   parm = RNA_def_property(func, "value", PROP_FLOAT, PROP_NONE);
798   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
799   RNA_def_property_ui_text(
800       parm, "value", "Any value between min and max as set in progress_begin()");
801
802   func = RNA_def_function(srna, "progress_end", "rna_progress_end");
803   RNA_def_function_ui_description(func, "Terminate progress report");
804
805   /* invoke functions, for use with python */
806   func = RNA_def_function(srna, "invoke_props_popup", "rna_Operator_props_popup");
807   RNA_def_function_ui_description(
808       func,
809       "Operator popup invoke "
810       "(show operator properties and execute it automatically on changes)");
811   rna_generic_op_invoke(func, WM_GEN_INVOKE_EVENT | WM_GEN_INVOKE_RETURN);
812
813   /* invoked dialog opens popup with OK button, does not auto-exec operator. */
814   func = RNA_def_function(srna, "invoke_props_dialog", "WM_operator_props_dialog_popup");
815   RNA_def_function_ui_description(
816       func,
817       "Operator dialog (non-autoexec popup) invoke "
818       "(show operator properties and only execute it on click on OK button)");
819   rna_generic_op_invoke(func, WM_GEN_INVOKE_SIZE | WM_GEN_INVOKE_RETURN);
820
821   /* invoke enum */
822   func = RNA_def_function(srna, "invoke_search_popup", "rna_Operator_enum_search_invoke");
823   RNA_def_function_ui_description(
824       func,
825       "Operator search popup invoke which "
826       "searches values of the operator's :class:`bpy.types.Operator.bl_property` "
827       "(which must be an EnumProperty), executing it on confirmation");
828   rna_generic_op_invoke(func, 0);
829
830   /* invoke functions, for use with python */
831   func = RNA_def_function(srna, "invoke_popup", "WM_operator_ui_popup");
832   RNA_def_function_ui_description(func,
833                                   "Operator popup invoke "
834                                   "(only shows operator's properties, without executing it)");
835   rna_generic_op_invoke(func, WM_GEN_INVOKE_SIZE | WM_GEN_INVOKE_RETURN);
836
837   func = RNA_def_function(srna, "invoke_confirm", "rna_Operator_confirm");
838   RNA_def_function_ui_description(
839       func,
840       "Operator confirmation popup "
841       "(only to let user confirm the execution, no operator properties shown)");
842   rna_generic_op_invoke(func, WM_GEN_INVOKE_EVENT | WM_GEN_INVOKE_RETURN);
843
844   /* wrap UI_popup_menu_begin */
845   func = RNA_def_function(srna, "popmenu_begin__internal", "rna_PopMenuBegin");
846   RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_CONTEXT);
847   parm = RNA_def_string(func, "title", NULL, 0, "", "");
848   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
849   parm = RNA_def_property(func, "icon", PROP_ENUM, PROP_NONE);
850   RNA_def_property_enum_items(parm, rna_enum_icon_items);
851   /* return */
852   parm = RNA_def_pointer(func, "menu", "UIPopupMenu", "", "");
853   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_RNAPTR);
854   RNA_def_function_return(func, parm);
855
856   /* wrap UI_popup_menu_end */
857   func = RNA_def_function(srna, "popmenu_end__internal", "rna_PopMenuEnd");
858   RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_CONTEXT);
859   parm = RNA_def_pointer(func, "menu", "UIPopupMenu", "", "");
860   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_RNAPTR | PARM_REQUIRED);
861
862   /* wrap UI_popover_begin */
863   func = RNA_def_function(srna, "popover_begin__internal", "rna_PopoverBegin");
864   RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_CONTEXT);
865   RNA_def_property(func, "ui_units_x", PROP_INT, PROP_UNSIGNED);
866   /* return */
867   parm = RNA_def_pointer(func, "menu", "UIPopover", "", "");
868   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_RNAPTR);
869   RNA_def_function_return(func, parm);
870   RNA_def_boolean(
871       func, "from_active_button", 0, "Use Button", "Use the active button for positioning");
872
873   /* wrap UI_popover_end */
874   func = RNA_def_function(srna, "popover_end__internal", "rna_PopoverEnd");
875   RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_CONTEXT);
876   parm = RNA_def_pointer(func, "menu", "UIPopover", "", "");
877   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_RNAPTR | PARM_REQUIRED);
878   RNA_def_pointer(func, "keymap", "KeyMap", "Key Map", "Active key map");
879
880   /* wrap uiPieMenuBegin */
881   func = RNA_def_function(srna, "piemenu_begin__internal", "rna_PieMenuBegin");
882   RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_CONTEXT);
883   parm = RNA_def_string(func, "title", NULL, 0, "", "");
884   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
885   parm = RNA_def_property(func, "icon", PROP_ENUM, PROP_NONE);
886   RNA_def_property_enum_items(parm, rna_enum_icon_items);
887   parm = RNA_def_pointer(func, "event", "Event", "", "");
888   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_RNAPTR);
889   /* return */
890   parm = RNA_def_pointer(func, "menu_pie", "UIPieMenu", "", "");
891   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_RNAPTR);
892   RNA_def_function_return(func, parm);
893
894   /* wrap uiPieMenuEnd */
895   func = RNA_def_function(srna, "piemenu_end__internal", "rna_PieMenuEnd");
896   RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_CONTEXT);
897   parm = RNA_def_pointer(func, "menu", "UIPieMenu", "", "");
898   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_RNAPTR | PARM_REQUIRED);
899
900   /* access last operator options (optionally create). */
901   func = RNA_def_function(
902       srna, "operator_properties_last", "rna_WindoManager_operator_properties_last");
903   RNA_def_function_flag(func, FUNC_NO_SELF);
904   parm = RNA_def_string(func, "operator", NULL, 0, "", "");
905   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
906   /* return */
907   parm = RNA_def_pointer(func, "result", "OperatorProperties", "", "");
908   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_RNAPTR);
909   RNA_def_function_return(func, parm);
910
911   RNA_def_function(srna, "print_undo_steps", "rna_WindowManager_print_undo_steps");
912
913   parm = RNA_def_property(srna, "is_interface_locked", PROP_BOOLEAN, PROP_NONE);
914   RNA_def_property_ui_text(
915       parm,
916       "Is Interface Locked",
917       "If true, the interface is currently locked by a running job and data shouldn't be modified "
918       "from application timers. Otherwise, the running job might conflict with the handler "
919       "causing unexpected results or even crashes");
920   RNA_def_property_clear_flag(parm, PROP_EDITABLE);
921 }
922
923 void RNA_api_operator(StructRNA *srna)
924 {
925   FunctionRNA *func;
926   PropertyRNA *parm;
927
928   /* utility, not for registering */
929   func = RNA_def_function(srna, "report", "rna_Operator_report");
930   parm = RNA_def_enum_flag(func, "type", rna_enum_wm_report_items, 0, "Type", "");
931   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
932   parm = RNA_def_string(func, "message", NULL, 0, "Report Message", "");
933   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
934
935   /* utility, not for registering */
936   func = RNA_def_function(srna, "is_repeat", "rna_Operator_is_repeat");
937   RNA_def_function_flag(func, FUNC_USE_CONTEXT);
938   /* return */
939   parm = RNA_def_boolean(func, "result", 0, "result", "");
940   RNA_def_function_return(func, parm);
941
942   /* Registration */
943
944   /* poll */
945   func = RNA_def_function(srna, "poll", NULL);
946   RNA_def_function_ui_description(func, "Test if the operator can be called or not");
947   RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_REGISTER_OPTIONAL);
948   RNA_def_function_return(func, RNA_def_boolean(func, "visible", 1, "", ""));
949   parm = RNA_def_pointer(func, "context", "Context", "", "");
950   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
951
952   /* exec */
953   func = RNA_def_function(srna, "execute", NULL);
954   RNA_def_function_ui_description(func, "Execute the operator");
955   RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL | FUNC_ALLOW_WRITE);
956   parm = RNA_def_pointer(func, "context", "Context", "", "");
957   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
958
959   /* better name? */
960   parm = RNA_def_enum_flag(
961       func, "result", rna_enum_operator_return_items, OPERATOR_FINISHED, "result", "");
962   RNA_def_function_return(func, parm);
963
964   /* check */
965   func = RNA_def_function(srna, "check", NULL);
966   RNA_def_function_ui_description(
967       func, "Check the operator settings, return True to signal a change to redraw");
968   RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL | FUNC_ALLOW_WRITE);
969   parm = RNA_def_pointer(func, "context", "Context", "", "");
970   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
971
972   parm = RNA_def_boolean(func, "result", 0, "result", ""); /* better name? */
973   RNA_def_function_return(func, parm);
974
975   /* invoke */
976   func = RNA_def_function(srna, "invoke", NULL);
977   RNA_def_function_ui_description(func, "Invoke the operator");
978   RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL | FUNC_ALLOW_WRITE);
979   parm = RNA_def_pointer(func, "context", "Context", "", "");
980   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
981   parm = RNA_def_pointer(func, "event", "Event", "", "");
982   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
983
984   /* better name? */
985   parm = RNA_def_enum_flag(
986       func, "result", rna_enum_operator_return_items, OPERATOR_FINISHED, "result", "");
987   RNA_def_function_return(func, parm);
988
989   func = RNA_def_function(srna, "modal", NULL); /* same as invoke */
990   RNA_def_function_ui_description(func, "Modal operator function");
991   RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL | FUNC_ALLOW_WRITE);
992   parm = RNA_def_pointer(func, "context", "Context", "", "");
993   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
994   parm = RNA_def_pointer(func, "event", "Event", "", "");
995   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
996
997   /* better name? */
998   parm = RNA_def_enum_flag(
999       func, "result", rna_enum_operator_return_items, OPERATOR_FINISHED, "result", "");
1000   RNA_def_function_return(func, parm);
1001
1002   /* draw */
1003   func = RNA_def_function(srna, "draw", NULL);
1004   RNA_def_function_ui_description(func, "Draw function for the operator");
1005   RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL);
1006   parm = RNA_def_pointer(func, "context", "Context", "", "");
1007   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
1008
1009   /* cancel */
1010   func = RNA_def_function(srna, "cancel", NULL);
1011   RNA_def_function_ui_description(func, "Called when the operator is canceled");
1012   RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL | FUNC_ALLOW_WRITE);
1013   parm = RNA_def_pointer(func, "context", "Context", "", "");
1014   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
1015
1016   /* description */
1017   func = RNA_def_function(srna, "description", NULL);
1018   RNA_def_function_ui_description(func, "Compute a description string that depends on parameters");
1019   RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_REGISTER_OPTIONAL);
1020   parm = RNA_def_string(func, "result", NULL, 4096, "result", "");
1021   RNA_def_parameter_clear_flags(parm, PROP_NEVER_NULL, 0);
1022   RNA_def_parameter_flags(parm, PROP_THICK_WRAP, 0);
1023   RNA_def_function_output(func, parm);
1024   parm = RNA_def_pointer(func, "context", "Context", "", "");
1025   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
1026   parm = RNA_def_pointer(func, "properties", "OperatorProperties", "", "");
1027   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
1028 }
1029
1030 void RNA_api_macro(StructRNA *srna)
1031 {
1032   FunctionRNA *func;
1033   PropertyRNA *parm;
1034
1035   /* utility, not for registering */
1036   func = RNA_def_function(srna, "report", "rna_Operator_report");
1037   parm = RNA_def_enum_flag(func, "type", rna_enum_wm_report_items, 0, "Type", "");
1038   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1039   parm = RNA_def_string(func, "message", NULL, 0, "Report Message", "");
1040   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1041
1042   /* Registration */
1043
1044   /* poll */
1045   func = RNA_def_function(srna, "poll", NULL);
1046   RNA_def_function_ui_description(func, "Test if the operator can be called or not");
1047   RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_REGISTER_OPTIONAL);
1048   RNA_def_function_return(func, RNA_def_boolean(func, "visible", 1, "", ""));
1049   parm = RNA_def_pointer(func, "context", "Context", "", "");
1050   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
1051
1052   /* draw */
1053   func = RNA_def_function(srna, "draw", NULL);
1054   RNA_def_function_ui_description(func, "Draw function for the operator");
1055   RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL);
1056   parm = RNA_def_pointer(func, "context", "Context", "", "");
1057   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
1058 }
1059
1060 void RNA_api_keyconfig(StructRNA *UNUSED(srna))
1061 {
1062   /* FunctionRNA *func; */
1063   /* PropertyRNA *parm; */
1064 }
1065
1066 void RNA_api_keymap(StructRNA *srna)
1067 {
1068   FunctionRNA *func;
1069   PropertyRNA *parm;
1070
1071   func = RNA_def_function(srna, "active", "rna_keymap_active");
1072   RNA_def_function_flag(func, FUNC_USE_CONTEXT);
1073   parm = RNA_def_pointer(func, "keymap", "KeyMap", "Key Map", "Active key map");
1074   RNA_def_function_return(func, parm);
1075
1076   func = RNA_def_function(srna, "restore_to_default", "rna_keymap_restore_to_default");
1077   RNA_def_function_flag(func, FUNC_USE_CONTEXT);
1078
1079   func = RNA_def_function(srna, "restore_item_to_default", "rna_keymap_restore_item_to_default");
1080   RNA_def_function_flag(func, FUNC_USE_CONTEXT);
1081   parm = RNA_def_pointer(func, "item", "KeyMapItem", "Item", "");
1082   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
1083 }
1084
1085 void RNA_api_keymapitem(StructRNA *srna)
1086 {
1087   FunctionRNA *func;
1088   PropertyRNA *parm;
1089
1090   func = RNA_def_function(srna, "compare", "WM_keymap_item_compare");
1091   parm = RNA_def_pointer(func, "item", "KeyMapItem", "Item", "");
1092   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1093   parm = RNA_def_boolean(func, "result", 0, "Comparison result", "");
1094   RNA_def_function_return(func, parm);
1095
1096   func = RNA_def_function(srna, "to_string", "rna_KeyMapItem_to_string");
1097   RNA_def_boolean(func, "compact", false, "Compact", "");
1098   parm = RNA_def_string(func, "result", NULL, UI_MAX_SHORTCUT_STR, "result", "");
1099   RNA_def_parameter_flags(parm, PROP_THICK_WRAP, 0);
1100   RNA_def_function_output(func, parm);
1101 }
1102
1103 void RNA_api_keymapitems(StructRNA *srna)
1104 {
1105   FunctionRNA *func;
1106   PropertyRNA *parm;
1107
1108   func = RNA_def_function(srna, "new", "rna_KeyMap_item_new");
1109   RNA_def_function_flag(func, FUNC_USE_REPORTS);
1110   parm = RNA_def_string(func, "idname", NULL, 0, "Operator Identifier", "");
1111   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1112   parm = RNA_def_enum(func, "type", rna_enum_event_type_items, 0, "Type", "");
1113   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1114   parm = RNA_def_enum(func, "value", rna_enum_event_value_items, 0, "Value", "");
1115   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1116   RNA_def_boolean(func, "any", 0, "Any", "");
1117   RNA_def_boolean(func, "shift", 0, "Shift", "");
1118   RNA_def_boolean(func, "ctrl", 0, "Ctrl", "");
1119   RNA_def_boolean(func, "alt", 0, "Alt", "");
1120   RNA_def_boolean(func, "oskey", 0, "OS Key", "");
1121   RNA_def_enum(func, "key_modifier", rna_enum_event_type_items, 0, "Key Modifier", "");
1122   RNA_def_boolean(func, "repeat", true, "Repeat", "When set, accept key-repeat events");
1123   RNA_def_boolean(func,
1124                   "head",
1125                   0,
1126                   "At Head",
1127                   "Force item to be added at start (not end) of key map so that "
1128                   "it doesn't get blocked by an existing key map item");
1129   parm = RNA_def_pointer(func, "item", "KeyMapItem", "Item", "Added key map item");
1130   RNA_def_function_return(func, parm);
1131
1132   func = RNA_def_function(srna, "new_modal", "rna_KeyMap_item_new_modal");
1133   RNA_def_function_flag(func, FUNC_USE_REPORTS);
1134   parm = RNA_def_string(func, "propvalue", NULL, 0, "Property Value", "");
1135   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1136   parm = RNA_def_enum(func, "type", rna_enum_event_type_items, 0, "Type", "");
1137   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1138   parm = RNA_def_enum(func, "value", rna_enum_event_value_items, 0, "Value", "");
1139   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1140   RNA_def_boolean(func, "any", 0, "Any", "");
1141   RNA_def_boolean(func, "shift", 0, "Shift", "");
1142   RNA_def_boolean(func, "ctrl", 0, "Ctrl", "");
1143   RNA_def_boolean(func, "alt", 0, "Alt", "");
1144   RNA_def_boolean(func, "oskey", 0, "OS Key", "");
1145   RNA_def_enum(func, "key_modifier", rna_enum_event_type_items, 0, "Key Modifier", "");
1146   RNA_def_boolean(func, "repeat", true, "Repeat", "When set, accept key-repeat events");
1147   parm = RNA_def_pointer(func, "item", "KeyMapItem", "Item", "Added key map item");
1148   RNA_def_function_return(func, parm);
1149
1150   func = RNA_def_function(srna, "new_from_item", "rna_KeyMap_item_new_from_item");
1151   RNA_def_function_flag(func, FUNC_USE_REPORTS);
1152   parm = RNA_def_pointer(func, "item", "KeyMapItem", "Item", "Item to use as a reference");
1153   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
1154   RNA_def_boolean(func, "head", 0, "At Head", "");
1155   parm = RNA_def_pointer(func, "result", "KeyMapItem", "Item", "Added key map item");
1156   RNA_def_function_return(func, parm);
1157
1158   func = RNA_def_function(srna, "remove", "rna_KeyMap_item_remove");
1159   RNA_def_function_flag(func, FUNC_USE_REPORTS);
1160   parm = RNA_def_pointer(func, "item", "KeyMapItem", "Item", "");
1161   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
1162   RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
1163
1164   func = RNA_def_function(srna, "from_id", "WM_keymap_item_find_id");
1165   parm = RNA_def_property(func, "id", PROP_INT, PROP_NONE);
1166   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1167   RNA_def_property_ui_text(parm, "id", "ID of the item");
1168   parm = RNA_def_pointer(func, "item", "KeyMapItem", "Item", "");
1169   RNA_def_function_return(func, parm);
1170
1171   /* Keymap introspection
1172    * Args follow: KeyConfigs.find_item_from_operator */
1173   func = RNA_def_function(srna, "find_from_operator", "rna_KeyMap_item_find_from_operator");
1174   RNA_def_function_flag(func, FUNC_USE_SELF_ID);
1175   parm = RNA_def_string(func, "idname", NULL, 0, "Operator Identifier", "");
1176   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1177   parm = RNA_def_pointer(func, "properties", "OperatorProperties", "", "");
1178   RNA_def_parameter_flags(parm, 0, PARM_RNAPTR);
1179   RNA_def_enum_flag(
1180       func, "include", rna_enum_event_type_mask_items, EVT_TYPE_MASK_ALL, "Include", "");
1181   RNA_def_enum_flag(func, "exclude", rna_enum_event_type_mask_items, 0, "Exclude", "");
1182   parm = RNA_def_pointer(func, "item", "KeyMapItem", "", "");
1183   RNA_def_parameter_flags(parm, 0, PARM_RNAPTR);
1184   RNA_def_function_return(func, parm);
1185
1186   func = RNA_def_function(srna, "match_event", "rna_KeyMap_item_match_event");
1187   RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_USE_CONTEXT);
1188   parm = RNA_def_pointer(func, "event", "Event", "", "");
1189   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1190   parm = RNA_def_pointer(func, "item", "KeyMapItem", "", "");
1191   RNA_def_parameter_flags(parm, 0, PARM_RNAPTR);
1192   RNA_def_function_return(func, parm);
1193 }
1194
1195 void RNA_api_keymaps(StructRNA *srna)
1196 {
1197   FunctionRNA *func;
1198   PropertyRNA *parm;
1199
1200   func = RNA_def_function(srna, "new", "rna_keymap_new"); /* add_keymap */
1201   RNA_def_function_flag(func, FUNC_USE_REPORTS);
1202   parm = RNA_def_string(func, "name", NULL, 0, "Name", "");
1203   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1204   RNA_def_enum(func, "space_type", rna_enum_space_type_items, SPACE_EMPTY, "Space Type", "");
1205   RNA_def_enum(
1206       func, "region_type", rna_enum_region_type_items, RGN_TYPE_WINDOW, "Region Type", "");
1207   RNA_def_boolean(func, "modal", 0, "Modal", "Keymap for modal operators");
1208   RNA_def_boolean(func, "tool", 0, "Tool", "Keymap for active tools");
1209   parm = RNA_def_pointer(func, "keymap", "KeyMap", "Key Map", "Added key map");
1210   RNA_def_function_return(func, parm);
1211
1212   func = RNA_def_function(srna, "remove", "rna_KeyMap_remove"); /* remove_keymap */
1213   RNA_def_function_flag(func, FUNC_USE_REPORTS);
1214   parm = RNA_def_pointer(func, "keymap", "KeyMap", "Key Map", "Removed key map");
1215   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
1216   RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
1217
1218   func = RNA_def_function(srna, "find", "rna_keymap_find"); /* find_keymap */
1219   parm = RNA_def_string(func, "name", NULL, 0, "Name", "");
1220   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1221   RNA_def_enum(func, "space_type", rna_enum_space_type_items, SPACE_EMPTY, "Space Type", "");
1222   RNA_def_enum(
1223       func, "region_type", rna_enum_region_type_items, RGN_TYPE_WINDOW, "Region Type", "");
1224   parm = RNA_def_pointer(func, "keymap", "KeyMap", "Key Map", "Corresponding key map");
1225   RNA_def_function_return(func, parm);
1226
1227   func = RNA_def_function(srna, "find_modal", "rna_keymap_find_modal"); /* find_keymap_modal */
1228   parm = RNA_def_string(func, "name", NULL, 0, "Operator Name", "");
1229   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1230   parm = RNA_def_pointer(func, "keymap", "KeyMap", "Key Map", "Corresponding key map");
1231   RNA_def_function_return(func, parm);
1232 }
1233
1234 void RNA_api_keyconfigs(StructRNA *srna)
1235 {
1236   FunctionRNA *func;
1237   PropertyRNA *parm;
1238
1239   func = RNA_def_function(srna, "new", "WM_keyconfig_new_user"); /* add_keyconfig */
1240   parm = RNA_def_string(func, "name", NULL, 0, "Name", "");
1241   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1242   parm = RNA_def_pointer(
1243       func, "keyconfig", "KeyConfig", "Key Configuration", "Added key configuration");
1244   RNA_def_function_return(func, parm);
1245
1246   func = RNA_def_function(srna, "remove", "rna_KeyConfig_remove"); /* remove_keyconfig */
1247   RNA_def_function_flag(func, FUNC_USE_REPORTS);
1248   parm = RNA_def_pointer(
1249       func, "keyconfig", "KeyConfig", "Key Configuration", "Removed key configuration");
1250   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
1251   RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
1252
1253   /* Helper functions */
1254
1255   /* Keymap introspection */
1256   func = RNA_def_function(
1257       srna, "find_item_from_operator", "rna_KeyConfig_find_item_from_operator");
1258   RNA_def_function_flag(func, FUNC_USE_CONTEXT);
1259   parm = RNA_def_string(func, "idname", NULL, 0, "Operator Identifier", "");
1260   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1261   parm = RNA_def_property(func, "context", PROP_ENUM, PROP_NONE);
1262   RNA_def_property_enum_items(parm, rna_enum_operator_context_items);
1263   parm = RNA_def_pointer(func, "properties", "OperatorProperties", "", "");
1264   RNA_def_parameter_flags(parm, 0, PARM_RNAPTR);
1265   RNA_def_enum_flag(
1266       func, "include", rna_enum_event_type_mask_items, EVT_TYPE_MASK_ALL, "Include", "");
1267   RNA_def_enum_flag(func, "exclude", rna_enum_event_type_mask_items, 0, "Exclude", "");
1268   parm = RNA_def_pointer(func, "keymap", "KeyMap", "", "");
1269   RNA_def_parameter_flags(parm, 0, PARM_RNAPTR | PARM_OUTPUT);
1270   parm = RNA_def_pointer(func, "item", "KeyMapItem", "", "");
1271   RNA_def_parameter_flags(parm, 0, PARM_RNAPTR);
1272   RNA_def_function_return(func, parm);
1273
1274   RNA_def_function(srna, "update", "rna_KeyConfig_update"); /* WM_keyconfig_update */
1275 }
1276
1277 #endif