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