Cleanup: use `rna_enum_` prefix for RNA enums
[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 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 /* since event isn't needed... */
91 static void rna_Operator_enum_search_invoke(bContext *C, wmOperator *op)
92 {
93         WM_enum_search_invoke(C, op, NULL);
94         
95 }
96
97 static int rna_event_modal_handler_add(struct bContext *C, struct wmOperator *operator)
98 {
99         return WM_event_add_modal_handler(C, operator) != NULL;
100 }
101
102 /* XXX, need a way for python to know event types, 0x0110 is hard coded */
103 static wmTimer *rna_event_timer_add(struct wmWindowManager *wm, float time_step, wmWindow *win)
104 {
105         return WM_event_add_timer(wm, win, 0x0110, time_step);
106 }
107
108 static void rna_event_timer_remove(struct wmWindowManager *wm, wmTimer *timer)
109 {
110         WM_event_remove_timer(wm, timer->win, timer);
111 }
112
113 /* placeholder data for final implementation of a true progressbar */
114 static struct wmStaticProgress {
115         float min;
116         float max;
117         bool  is_valid;
118 } wm_progress_state = {0, 0, false};
119
120
121 static void rna_progress_begin(struct wmWindowManager *UNUSED(wm), float min, float max)
122 {
123         float range = max - min;
124         if (range != 0) {
125                 wm_progress_state.min = min;
126                 wm_progress_state.max = max;
127                 wm_progress_state.is_valid = true;
128         }
129         else {
130                 wm_progress_state.is_valid = false;
131         }
132 }
133
134 static void rna_progress_update(struct wmWindowManager *wm, float value)
135 {
136         if (wm_progress_state.is_valid) {
137                 /* Map to cursor_time range [0,9999] */
138                 wmWindow *win = wm->winactive;
139                 if (win) {
140                         int val = (int)(10000 * (value - wm_progress_state.min) / (wm_progress_state.max - wm_progress_state.min));
141                         WM_cursor_time(win, val);
142                 }
143         }
144 }
145
146 static void rna_progress_end(struct wmWindowManager *wm)
147 {
148         if (wm_progress_state.is_valid) {
149                 wmWindow *win = wm->winactive;
150                 if (win) {
151                         WM_cursor_modal_restore(win);
152                         wm_progress_state.is_valid = false;
153                 }
154         }
155 }
156
157 /* wrap these because of 'const wmEvent *' */
158 static int rna_Operator_confirm(bContext *C, wmOperator *op, wmEvent *event)
159 {
160         return WM_operator_confirm(C, op, event);
161 }
162 static int rna_Operator_props_popup(bContext *C, wmOperator *op, wmEvent *event)
163 {
164         return WM_operator_props_popup(C, op, event);
165 }
166
167 static wmKeyMapItem *rna_KeyMap_item_new(wmKeyMap *km, ReportList *reports, const char *idname, int type, int value,
168                                          int any, int shift, int ctrl, int alt, int oskey, int keymodifier, int head)
169 {
170 /*      wmWindowManager *wm = CTX_wm_manager(C); */
171         wmKeyMapItem *kmi = NULL;
172         char idname_bl[OP_MAX_TYPENAME];
173         int modifier = 0;
174
175         /* only on non-modal maps */
176         if (km->flag & KEYMAP_MODAL) {
177                 BKE_report(reports, RPT_ERROR, "Not a non-modal keymap");
178                 return NULL;
179         }
180
181         WM_operator_bl_idname(idname_bl, idname);
182
183         if (shift) modifier |= KM_SHIFT;
184         if (ctrl) modifier |= KM_CTRL;
185         if (alt) modifier |= KM_ALT;
186         if (oskey) modifier |= KM_OSKEY;
187
188         if (any) modifier = KM_ANY;
189         
190         /* create keymap item */
191         kmi = WM_keymap_add_item(km, idname_bl, type, value, modifier, keymodifier);
192         
193         /* [#32437] allow scripts to define hotkeys that get added to start of keymap 
194          *          so that they stand a chance against catch-all defines later on
195          */
196         if (head) {
197                 BLI_remlink(&km->items, kmi);
198                 BLI_addhead(&km->items, kmi);
199         }
200         
201         return kmi;
202 }
203
204 static wmKeyMapItem *rna_KeyMap_item_new_modal(wmKeyMap *km, ReportList *reports, const char *propvalue_str,
205                                                int type, int value, int any, int shift, int ctrl, int alt,
206                                                int oskey, int keymodifier)
207 {
208         int modifier = 0;
209         int propvalue = 0;
210
211         /* only modal maps */
212         if ((km->flag & KEYMAP_MODAL) == 0) {
213                 BKE_report(reports, RPT_ERROR, "Not a modal keymap");
214                 return NULL;
215         }
216
217         if (shift) modifier |= KM_SHIFT;
218         if (ctrl) modifier |= KM_CTRL;
219         if (alt) modifier |= KM_ALT;
220         if (oskey) modifier |= KM_OSKEY;
221
222         if (any) modifier = KM_ANY;
223
224         /* not initialized yet, do delayed lookup */
225         if (!km->modal_items)
226                 return WM_modalkeymap_add_item_str(km, type, value, modifier, keymodifier, propvalue_str);
227
228         if (RNA_enum_value_from_id(km->modal_items, propvalue_str, &propvalue) == 0)
229                 BKE_report(reports, RPT_WARNING, "Property value not in enumeration");
230
231         return WM_modalkeymap_add_item(km, type, value, modifier, keymodifier, propvalue);
232 }
233
234 static void rna_KeyMap_item_remove(wmKeyMap *km, ReportList *reports, PointerRNA *kmi_ptr)
235 {
236         wmKeyMapItem *kmi = kmi_ptr->data;
237
238         if (WM_keymap_remove_item(km, kmi) == false) {
239                 BKE_reportf(reports, RPT_ERROR, "KeyMapItem '%s' cannot be removed from '%s'", kmi->idname, km->idname);
240                 return;
241         }
242
243         RNA_POINTER_INVALIDATE(kmi_ptr);
244 }
245
246 static wmKeyMap *rna_keymap_new(wmKeyConfig *keyconf, const char *idname, int spaceid, int regionid, int modal)
247 {
248         if (modal == 0) {
249                 return WM_keymap_find(keyconf, idname, spaceid, regionid);
250         }
251         else {
252                 return WM_modalkeymap_add(keyconf, idname, NULL); /* items will be lazy init */
253         }
254 }
255
256 static wmKeyMap *rna_keymap_find(wmKeyConfig *keyconf, const char *idname, int spaceid, int regionid)
257 {
258         return WM_keymap_list_find(&keyconf->keymaps, idname, spaceid, regionid);
259 }
260
261 static wmKeyMap *rna_keymap_find_modal(wmKeyConfig *UNUSED(keyconf), const char *idname)
262 {
263         wmOperatorType *ot = WM_operatortype_find(idname, 0);
264
265         if (!ot)
266                 return NULL;
267         else
268                 return ot->modalkeymap;
269 }
270
271 static void rna_KeyMap_remove(wmKeyConfig *keyconfig, ReportList *reports, PointerRNA *keymap_ptr)
272 {
273         wmKeyMap *keymap = keymap_ptr->data;
274
275         if (WM_keymap_remove(keyconfig, keymap) == false) {
276                 BKE_reportf(reports, RPT_ERROR, "KeyConfig '%s' cannot be removed", keymap->idname);
277                 return;
278         }
279
280         RNA_POINTER_INVALIDATE(keymap_ptr);
281 }
282
283 static void rna_KeyConfig_remove(wmWindowManager *wm, ReportList *reports, PointerRNA *keyconf_ptr)
284 {
285         wmKeyConfig *keyconf = keyconf_ptr->data;
286
287         if (WM_keyconfig_remove(wm, keyconf) == false) {
288                 BKE_reportf(reports, RPT_ERROR, "KeyConfig '%s' cannot be removed", keyconf->idname);
289                 return;
290         }
291
292         RNA_POINTER_INVALIDATE(keyconf_ptr);
293 }
294
295 /* popup menu wrapper */
296 static PointerRNA rna_PupMenuBegin(bContext *C, const char *title, int icon)
297 {
298         PointerRNA r_ptr;
299         void *data;
300
301         data = (void *)UI_popup_menu_begin(C, title, icon);
302
303         RNA_pointer_create(NULL, &RNA_UIPopupMenu, data, &r_ptr);
304
305         return r_ptr;
306 }
307
308 static void rna_PupMenuEnd(bContext *C, PointerRNA *handle)
309 {
310         UI_popup_menu_end(C, handle->data);
311 }
312
313 /* pie menu wrapper */
314 static PointerRNA rna_PieMenuBegin(bContext *C, const char *title, int icon, PointerRNA *event)
315 {
316         PointerRNA r_ptr;
317         void *data;
318
319         data = (void *)UI_pie_menu_begin(C, title, icon, event->data);
320
321         RNA_pointer_create(NULL, &RNA_UIPieMenu, data, &r_ptr);
322
323         return r_ptr;
324 }
325
326 static void rna_PieMenuEnd(bContext *C, PointerRNA *handle)
327 {
328         UI_pie_menu_end(C, handle->data);
329 }
330
331 #else
332
333 #define WM_GEN_INVOKE_EVENT (1 << 0)
334 #define WM_GEN_INVOKE_SIZE (1 << 1)
335 #define WM_GEN_INVOKE_RETURN (1 << 2)
336
337 static void rna_generic_op_invoke(FunctionRNA *func, int flag)
338 {
339         PropertyRNA *parm;
340
341         RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_CONTEXT);
342         parm = RNA_def_pointer(func, "operator", "Operator", "", "Operator to call");
343         RNA_def_property_flag(parm, PROP_REQUIRED);
344
345         if (flag & WM_GEN_INVOKE_EVENT) {
346                 parm = RNA_def_pointer(func, "event", "Event", "", "Event");
347                 RNA_def_property_flag(parm, PROP_REQUIRED);
348         }
349
350         if (flag & WM_GEN_INVOKE_SIZE) {
351                 RNA_def_int(func, "width", 300, 0, INT_MAX, "", "Width of the popup", 0, INT_MAX);
352                 RNA_def_int(func, "height", 20, 0, INT_MAX, "", "Height of the popup", 0, INT_MAX);
353         }
354
355         if (flag & WM_GEN_INVOKE_RETURN) {
356                 parm = RNA_def_enum_flag(func, "result", rna_enum_operator_return_items, OPERATOR_CANCELLED, "result", "");
357                 RNA_def_function_return(func, parm);
358         }
359 }
360
361 void RNA_api_window(StructRNA *srna)
362 {
363         FunctionRNA *func;
364         PropertyRNA *parm;
365
366         func = RNA_def_function(srna, "cursor_warp", "WM_cursor_warp");
367         parm = RNA_def_int(func, "x", 0, INT_MIN, INT_MAX, "", "", INT_MIN, INT_MAX);
368         RNA_def_property_flag(parm, PROP_REQUIRED);
369         parm = RNA_def_int(func, "y", 0, INT_MIN, INT_MAX, "", "", INT_MIN, INT_MAX);
370         RNA_def_property_flag(parm, PROP_REQUIRED);
371         RNA_def_function_ui_description(func, "Set the cursor position");
372
373         func = RNA_def_function(srna, "cursor_set", "WM_cursor_set");
374         parm = RNA_def_property(func, "cursor", PROP_ENUM, PROP_NONE);
375         RNA_def_property_enum_items(parm, rna_enum_window_cursor_items);
376         RNA_def_property_flag(parm, PROP_REQUIRED);
377         RNA_def_function_ui_description(func, "Set the cursor");
378
379         func = RNA_def_function(srna, "cursor_modal_set", "WM_cursor_modal_set");
380         parm = RNA_def_property(func, "cursor", PROP_ENUM, PROP_NONE);
381         RNA_def_property_enum_items(parm, rna_enum_window_cursor_items);
382         RNA_def_property_flag(parm, PROP_REQUIRED);
383         RNA_def_function_ui_description(func, "Set the cursor, so the previous cursor can be restored");
384
385         RNA_def_function(srna, "cursor_modal_restore", "WM_cursor_modal_restore");
386         RNA_def_function_ui_description(func, "Restore the previous cursor after calling ``cursor_modal_set``");
387 }
388
389 void RNA_api_wm(StructRNA *srna)
390 {
391         FunctionRNA *func;
392         PropertyRNA *parm;
393
394         func = RNA_def_function(srna, "fileselect_add", "WM_event_add_fileselect");
395         RNA_def_function_ui_description(func, "Opens a file selector with an operator. "
396                                         "The string properties 'filepath', 'filename', 'directory' and a 'files' "
397                                         "collection are assigned when present in the operator");
398         rna_generic_op_invoke(func, 0);
399
400         func = RNA_def_function(srna, "modal_handler_add", "rna_event_modal_handler_add");
401         RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_CONTEXT);
402         parm = RNA_def_pointer(func, "operator", "Operator", "", "Operator to call");
403         RNA_def_property_flag(parm, PROP_REQUIRED);
404         RNA_def_function_return(func, RNA_def_boolean(func, "handle", 1, "", ""));
405
406
407         func = RNA_def_function(srna, "event_timer_add", "rna_event_timer_add");
408         parm = RNA_def_property(func, "time_step", PROP_FLOAT, PROP_NONE);
409         RNA_def_property_flag(parm, PROP_REQUIRED);
410         RNA_def_property_range(parm, 0.0, FLT_MAX);
411         RNA_def_property_ui_text(parm, "Time Step", "Interval in seconds between timer events");
412         RNA_def_pointer(func, "window", "Window", "", "Window to attach the timer to or None");
413         parm = RNA_def_pointer(func, "result", "Timer", "", "");
414         RNA_def_function_return(func, parm);
415
416
417         func = RNA_def_function(srna, "event_timer_remove", "rna_event_timer_remove");
418         parm = RNA_def_pointer(func, "timer", "Timer", "", "");
419         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL);
420
421         /* Progress bar interface */
422         func = RNA_def_function(srna, "progress_begin", "rna_progress_begin");
423         RNA_def_function_ui_description(func, "Start progress report");
424
425         parm = RNA_def_property(func, "min", PROP_FLOAT, PROP_NONE);
426         RNA_def_property_ui_text(parm, "min", "any value in range [0,9999]");
427         RNA_def_property_flag(parm, PROP_REQUIRED);
428
429         parm = RNA_def_property(func, "max", PROP_FLOAT, PROP_NONE);
430         RNA_def_property_flag(parm, PROP_REQUIRED);
431         RNA_def_property_ui_text(parm, "max", "any value in range [min+1,9998]");
432
433         func = RNA_def_function(srna, "progress_update", "rna_progress_update");
434         parm = RNA_def_property(func, "value", PROP_FLOAT, PROP_NONE);
435         RNA_def_property_flag(parm, PROP_REQUIRED);
436         RNA_def_property_ui_text(parm, "value", "any value between min and max as set in progress_begin()");
437
438         func = RNA_def_function(srna, "progress_end", "rna_progress_end");
439         RNA_def_function_ui_description(func, "Terminate progress report");
440
441         /* invoke functions, for use with python */
442         func = RNA_def_function(srna, "invoke_props_popup", "rna_Operator_props_popup");
443         RNA_def_function_ui_description(func, "Operator popup invoke");
444         rna_generic_op_invoke(func, WM_GEN_INVOKE_EVENT | WM_GEN_INVOKE_RETURN);
445
446         /* invoked dialog opens popup with OK button, does not auto-exec operator. */
447         func = RNA_def_function(srna, "invoke_props_dialog", "WM_operator_props_dialog_popup");
448         RNA_def_function_ui_description(func, "Operator dialog (non-autoexec popup) invoke");
449         rna_generic_op_invoke(func, WM_GEN_INVOKE_SIZE | WM_GEN_INVOKE_RETURN);
450
451         /* invoke enum */
452         func = RNA_def_function(srna, "invoke_search_popup", "rna_Operator_enum_search_invoke");
453         rna_generic_op_invoke(func, 0);
454
455         /* invoke functions, for use with python */
456         func = RNA_def_function(srna, "invoke_popup", "WM_operator_ui_popup");
457         RNA_def_function_ui_description(func, "Operator popup invoke");
458         rna_generic_op_invoke(func, WM_GEN_INVOKE_SIZE | WM_GEN_INVOKE_RETURN);
459
460         func = RNA_def_function(srna, "invoke_confirm", "rna_Operator_confirm");
461         RNA_def_function_ui_description(func, "Operator confirmation");
462         rna_generic_op_invoke(func, WM_GEN_INVOKE_EVENT | WM_GEN_INVOKE_RETURN);
463
464
465         /* wrap UI_popup_menu_begin */
466         func = RNA_def_function(srna, "pupmenu_begin__internal", "rna_PupMenuBegin");
467         RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_CONTEXT);
468         parm = RNA_def_string(func, "title", NULL, 0, "", "");
469         RNA_def_property_flag(parm, PROP_REQUIRED);
470         parm = RNA_def_property(func, "icon", PROP_ENUM, PROP_NONE);
471         RNA_def_property_enum_items(parm, rna_enum_icon_items);
472         /* return */
473         parm = RNA_def_pointer(func, "menu", "UIPopupMenu", "", "");
474         RNA_def_property_flag(parm, PROP_RNAPTR | PROP_NEVER_NULL);
475         RNA_def_function_return(func, parm);
476
477         /* wrap UI_popup_menu_end */
478         func = RNA_def_function(srna, "pupmenu_end__internal", "rna_PupMenuEnd");
479         RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_CONTEXT);
480         parm = RNA_def_pointer(func, "menu", "UIPopupMenu", "", "");
481         RNA_def_property_flag(parm, PROP_RNAPTR | PROP_NEVER_NULL);
482
483         /* wrap uiPieMenuBegin */
484         func = RNA_def_function(srna, "piemenu_begin__internal", "rna_PieMenuBegin");
485         RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_CONTEXT);
486         parm = RNA_def_string(func, "title", NULL, 0, "", "");
487         RNA_def_property_flag(parm, PROP_REQUIRED);
488         parm = RNA_def_property(func, "icon", PROP_ENUM, PROP_NONE);
489         RNA_def_property_enum_items(parm, rna_enum_icon_items);
490         parm = RNA_def_pointer(func, "event", "Event", "", "");
491         RNA_def_property_flag(parm, PROP_RNAPTR | PROP_NEVER_NULL);
492         /* return */
493         parm = RNA_def_pointer(func, "menu_pie", "UIPieMenu", "", "");
494         RNA_def_property_flag(parm, PROP_RNAPTR | PROP_NEVER_NULL);
495         RNA_def_function_return(func, parm);
496
497         /* wrap uiPieMenuEnd */
498         func = RNA_def_function(srna, "piemenu_end__internal", "rna_PieMenuEnd");
499         RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_CONTEXT);
500         parm = RNA_def_pointer(func, "menu", "UIPieMenu", "", "");
501         RNA_def_property_flag(parm, PROP_RNAPTR | PROP_NEVER_NULL);
502 }
503
504 void RNA_api_operator(StructRNA *srna)
505 {
506         FunctionRNA *func;
507         PropertyRNA *parm;
508
509         /* utility, not for registering */
510         func = RNA_def_function(srna, "report", "rna_Operator_report");
511         parm = RNA_def_enum_flag(func, "type", rna_enum_wm_report_items, 0, "Type", "");
512         RNA_def_property_flag(parm, PROP_REQUIRED);
513         parm = RNA_def_string(func, "message", NULL, 0, "Report Message", "");
514         RNA_def_property_flag(parm, PROP_REQUIRED);
515
516
517         /* Registration */
518
519         /* poll */
520         func = RNA_def_function(srna, "poll", NULL);
521         RNA_def_function_ui_description(func, "Test if the operator can be called or not");
522         RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_REGISTER_OPTIONAL);
523         RNA_def_function_return(func, RNA_def_boolean(func, "visible", 1, "", ""));
524         parm = RNA_def_pointer(func, "context", "Context", "", "");
525         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL);
526
527         /* exec */
528         func = RNA_def_function(srna, "execute", NULL);
529         RNA_def_function_ui_description(func, "Execute the operator");
530         RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL | FUNC_ALLOW_WRITE);
531         parm = RNA_def_pointer(func, "context", "Context", "", "");
532         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL);
533
534         /* better name? */
535         parm = RNA_def_enum_flag(func, "result", rna_enum_operator_return_items, OPERATOR_CANCELLED, "result", "");
536         RNA_def_function_return(func, parm);
537
538         /* check */
539         func = RNA_def_function(srna, "check", NULL);
540         RNA_def_function_ui_description(func, "Check the operator settings, return True to signal a change to redraw");
541         RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL | FUNC_ALLOW_WRITE);
542         parm = RNA_def_pointer(func, "context", "Context", "", "");
543         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL);
544
545         parm = RNA_def_boolean(func, "result", 0, "result", ""); /* better name? */
546         RNA_def_function_return(func, parm);
547         
548         /* invoke */
549         func = RNA_def_function(srna, "invoke", NULL);
550         RNA_def_function_ui_description(func, "Invoke the operator");
551         RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL | FUNC_ALLOW_WRITE);
552         parm = RNA_def_pointer(func, "context", "Context", "", "");
553         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL);
554         parm = RNA_def_pointer(func, "event", "Event", "", "");
555         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL);
556
557         /* better name? */
558         parm = RNA_def_enum_flag(func, "result", rna_enum_operator_return_items, OPERATOR_CANCELLED, "result", "");
559         RNA_def_function_return(func, parm);
560
561         func = RNA_def_function(srna, "modal", NULL); /* same as invoke */
562         RNA_def_function_ui_description(func, "Modal operator function");
563         RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL | FUNC_ALLOW_WRITE);
564         parm = RNA_def_pointer(func, "context", "Context", "", "");
565         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL);
566         parm = RNA_def_pointer(func, "event", "Event", "", "");
567         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL);
568
569         /* better name? */
570         parm = RNA_def_enum_flag(func, "result", rna_enum_operator_return_items, OPERATOR_CANCELLED, "result", "");
571         RNA_def_function_return(func, parm);
572
573         /* draw */
574         func = RNA_def_function(srna, "draw", NULL);
575         RNA_def_function_ui_description(func, "Draw function for the operator");
576         RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL);
577         parm = RNA_def_pointer(func, "context", "Context", "", "");
578         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL);
579
580         /* cancel */
581         func = RNA_def_function(srna, "cancel", NULL);
582         RNA_def_function_ui_description(func, "Called when the operator is canceled");
583         RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL | FUNC_ALLOW_WRITE);
584         parm = RNA_def_pointer(func, "context", "Context", "", "");
585         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL);
586 }
587
588 void RNA_api_macro(StructRNA *srna)
589 {
590         FunctionRNA *func;
591         PropertyRNA *parm;
592
593         /* utility, not for registering */
594         func = RNA_def_function(srna, "report", "rna_Operator_report");
595         parm = RNA_def_enum_flag(func, "type", rna_enum_wm_report_items, 0, "Type", "");
596         RNA_def_property_flag(parm, PROP_REQUIRED);
597         parm = RNA_def_string(func, "message", NULL, 0, "Report Message", "");
598         RNA_def_property_flag(parm, PROP_REQUIRED);
599
600
601         /* Registration */
602
603         /* poll */
604         func = RNA_def_function(srna, "poll", NULL);
605         RNA_def_function_ui_description(func, "Test if the operator can be called or not");
606         RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_REGISTER_OPTIONAL);
607         RNA_def_function_return(func, RNA_def_boolean(func, "visible", 1, "", ""));
608         parm = RNA_def_pointer(func, "context", "Context", "", "");
609         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL);
610
611         /* draw */
612         func = RNA_def_function(srna, "draw", NULL);
613         RNA_def_function_ui_description(func, "Draw function for the operator");
614         RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL);
615         parm = RNA_def_pointer(func, "context", "Context", "", "");
616         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL);
617 }
618
619 void RNA_api_keyconfig(StructRNA *UNUSED(srna))
620 {
621         /* FunctionRNA *func; */
622         /* PropertyRNA *parm; */
623 }
624
625 void RNA_api_keymap(StructRNA *srna)
626 {
627         FunctionRNA *func;
628         PropertyRNA *parm;
629
630         func = RNA_def_function(srna, "active", "rna_keymap_active");
631         RNA_def_function_flag(func, FUNC_USE_CONTEXT);
632         parm = RNA_def_pointer(func, "keymap", "KeyMap", "Key Map", "Active key map");
633         RNA_def_function_return(func, parm);
634
635         func = RNA_def_function(srna, "restore_to_default", "WM_keymap_restore_to_default");
636         RNA_def_function_flag(func, FUNC_USE_CONTEXT);
637
638         func = RNA_def_function(srna, "restore_item_to_default", "rna_keymap_restore_item_to_default");
639         RNA_def_function_flag(func, FUNC_USE_CONTEXT);
640         parm = RNA_def_pointer(func, "item", "KeyMapItem", "Item", "");
641         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL);
642 }
643
644 void RNA_api_keymapitem(StructRNA *srna)
645 {
646         FunctionRNA *func;
647         PropertyRNA *parm;
648
649         func = RNA_def_function(srna, "compare", "WM_keymap_item_compare");
650         parm = RNA_def_pointer(func, "item", "KeyMapItem", "Item", "");
651         RNA_def_property_flag(parm, PROP_REQUIRED);
652         parm = RNA_def_boolean(func, "result", 0, "Comparison result", "");
653         RNA_def_function_return(func, parm);
654 }
655
656 void RNA_api_keymapitems(StructRNA *srna)
657 {
658         FunctionRNA *func;
659         PropertyRNA *parm;
660
661         func = RNA_def_function(srna, "new", "rna_KeyMap_item_new");
662         RNA_def_function_flag(func, FUNC_USE_REPORTS);
663         parm = RNA_def_string(func, "idname", NULL, 0, "Operator Identifier", "");
664         RNA_def_property_flag(parm, PROP_REQUIRED);
665         parm = RNA_def_enum(func, "type", rna_enum_event_type_items, 0, "Type", "");
666         RNA_def_property_flag(parm, PROP_REQUIRED);
667         parm = RNA_def_enum(func, "value", rna_enum_event_value_items, 0, "Value", "");
668         RNA_def_property_flag(parm, PROP_REQUIRED);
669         RNA_def_boolean(func, "any", 0, "Any", "");
670         RNA_def_boolean(func, "shift", 0, "Shift", "");
671         RNA_def_boolean(func, "ctrl", 0, "Ctrl", "");
672         RNA_def_boolean(func, "alt", 0, "Alt", "");
673         RNA_def_boolean(func, "oskey", 0, "OS Key", "");
674         RNA_def_enum(func, "key_modifier", rna_enum_event_type_items, 0, "Key Modifier", "");
675         RNA_def_boolean(func, "head", 0, "At Head", 
676                         "Force item to be added at start (not end) of key map so that "
677                         "it doesn't get blocked by an existing key map item");
678         parm = RNA_def_pointer(func, "item", "KeyMapItem", "Item", "Added key map item");
679         RNA_def_function_return(func, parm);
680
681         func = RNA_def_function(srna, "new_modal", "rna_KeyMap_item_new_modal");
682         RNA_def_function_flag(func, FUNC_USE_REPORTS);
683         parm = RNA_def_string(func, "propvalue", NULL, 0, "Property Value", "");
684         RNA_def_property_flag(parm, PROP_REQUIRED);
685         parm = RNA_def_enum(func, "type", rna_enum_event_type_items, 0, "Type", "");
686         RNA_def_property_flag(parm, PROP_REQUIRED);
687         parm = RNA_def_enum(func, "value", rna_enum_event_value_items, 0, "Value", "");
688         RNA_def_property_flag(parm, PROP_REQUIRED);
689         RNA_def_boolean(func, "any", 0, "Any", "");
690         RNA_def_boolean(func, "shift", 0, "Shift", "");
691         RNA_def_boolean(func, "ctrl", 0, "Ctrl", "");
692         RNA_def_boolean(func, "alt", 0, "Alt", "");
693         RNA_def_boolean(func, "oskey", 0, "OS Key", "");
694         RNA_def_enum(func, "key_modifier", rna_enum_event_type_items, 0, "Key Modifier", "");
695         parm = RNA_def_pointer(func, "item", "KeyMapItem", "Item", "Added key map item");
696         RNA_def_function_return(func, parm);
697         
698         func = RNA_def_function(srna, "remove", "rna_KeyMap_item_remove");
699         RNA_def_function_flag(func, FUNC_USE_REPORTS);
700         parm = RNA_def_pointer(func, "item", "KeyMapItem", "Item", "");
701         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
702         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
703
704         func = RNA_def_function(srna, "from_id", "WM_keymap_item_find_id");
705         parm = RNA_def_property(func, "id", PROP_INT, PROP_NONE);
706         RNA_def_property_flag(parm, PROP_REQUIRED);
707         RNA_def_property_ui_text(parm, "id", "ID of the item");
708         parm = RNA_def_pointer(func, "item", "KeyMapItem", "Item", "");
709         RNA_def_function_return(func, parm);
710 }
711
712 void RNA_api_keymaps(StructRNA *srna)
713 {
714         FunctionRNA *func;
715         PropertyRNA *parm;
716
717         func = RNA_def_function(srna, "new", "rna_keymap_new"); /* add_keymap */
718         parm = RNA_def_string(func, "name", NULL, 0, "Name", "");
719         RNA_def_property_flag(parm, PROP_REQUIRED);
720         RNA_def_enum(func, "space_type", rna_enum_space_type_items, SPACE_EMPTY, "Space Type", "");
721         RNA_def_enum(func, "region_type", rna_enum_region_type_items, RGN_TYPE_WINDOW, "Region Type", "");
722         RNA_def_boolean(func, "modal", 0, "Modal", "");
723         parm = RNA_def_pointer(func, "keymap", "KeyMap", "Key Map", "Added key map");
724         RNA_def_function_return(func, parm);
725
726         func = RNA_def_function(srna, "remove", "rna_KeyMap_remove"); /* remove_keymap */
727         RNA_def_function_flag(func, FUNC_USE_REPORTS);
728         parm = RNA_def_pointer(func, "keymap", "KeyMap", "Key Map", "Removed key map");
729         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
730         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
731
732         func = RNA_def_function(srna, "find", "rna_keymap_find"); /* find_keymap */
733         parm = RNA_def_string(func, "name", NULL, 0, "Name", "");
734         RNA_def_property_flag(parm, PROP_REQUIRED);
735         RNA_def_enum(func, "space_type", rna_enum_space_type_items, SPACE_EMPTY, "Space Type", "");
736         RNA_def_enum(func, "region_type", rna_enum_region_type_items, RGN_TYPE_WINDOW, "Region Type", "");
737         parm = RNA_def_pointer(func, "keymap", "KeyMap", "Key Map", "Corresponding key map");
738         RNA_def_function_return(func, parm);
739
740         func = RNA_def_function(srna, "find_modal", "rna_keymap_find_modal"); /* find_keymap_modal */
741         parm = RNA_def_string(func, "name", NULL, 0, "Operator Name", "");
742         RNA_def_property_flag(parm, PROP_REQUIRED);
743         parm = RNA_def_pointer(func, "keymap", "KeyMap", "Key Map", "Corresponding key map");
744         RNA_def_function_return(func, parm);
745 }
746
747 void RNA_api_keyconfigs(StructRNA *srna)
748 {
749         FunctionRNA *func;
750         PropertyRNA *parm;
751
752         func = RNA_def_function(srna, "new", "WM_keyconfig_new_user"); /* add_keyconfig */
753         parm = RNA_def_string(func, "name", NULL, 0, "Name", "");
754         RNA_def_property_flag(parm, PROP_REQUIRED);
755         parm = RNA_def_pointer(func, "keyconfig", "KeyConfig", "Key Configuration", "Added key configuration");
756         RNA_def_function_return(func, parm);
757
758         func = RNA_def_function(srna, "remove", "rna_KeyConfig_remove"); /* remove_keyconfig */
759         RNA_def_function_flag(func, FUNC_USE_REPORTS);
760         parm = RNA_def_pointer(func, "keyconfig", "KeyConfig", "Key Configuration", "Removed key configuration");
761         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
762         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
763 }
764
765 #endif