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