2420310c774a627cc48bd39b39d740a22078fb70
[blender.git] / source / blender / makesrna / intern / rna_wm.c
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19  *
20  * Contributor(s): Blender Foundation (2008).
21  *
22  * ***** END GPL LICENSE BLOCK *****
23  */
24
25 #include <stdlib.h>
26
27 #include "RNA_access.h"
28 #include "RNA_define.h"
29 #include "RNA_enum_types.h"
30
31 #include "rna_internal.h"
32
33 #include "DNA_screen_types.h"
34 #include "DNA_space_types.h"
35 #include "DNA_userdef_types.h"
36 #include "DNA_windowmanager_types.h"
37
38 #include "WM_types.h"
39
40 EnumPropertyItem event_keymouse_value_items[] = {
41         {KM_ANY, "ANY", 0, "Any", ""},
42         {KM_PRESS, "PRESS", 0, "Press", ""},
43         {KM_RELEASE, "RELEASE", 0, "Release", ""},
44         {KM_CLICK, "CLICK", 0, "Click", ""},
45         {KM_DBL_CLICK, "DOUBLE_CLICK", 0, "Double Click", ""},
46         {0, NULL, 0, NULL, NULL}};
47
48 EnumPropertyItem event_tweak_value_items[]= {
49         {KM_ANY, "ANY", 0, "Any", ""},
50         {EVT_GESTURE_N, "NORTH", 0, "North", ""},
51         {EVT_GESTURE_NE, "NORTH_EAST", 0, "North-East", ""},
52         {EVT_GESTURE_E, "EAST", 0, "East", ""},
53         {EVT_GESTURE_SE, "SOUTH_EAST", 0, "South-East", ""},
54         {EVT_GESTURE_S, "SOUTH", 0, "South", ""},
55         {EVT_GESTURE_SW, "SOUTH_WEST", 0, "South-West", ""},
56         {EVT_GESTURE_W, "WEST", 0, "West", ""},
57         {EVT_GESTURE_NW, "NORTH_WEST", 0, "North-West", ""},
58         {0, NULL, 0, NULL, NULL}};
59
60 EnumPropertyItem event_value_items[] = {
61         {KM_ANY, "ANY", 0, "Any", ""},
62         {KM_NOTHING, "NOTHING", 0, "Nothing", ""},
63         {KM_PRESS, "PRESS", 0, "Press", ""},
64         {KM_RELEASE, "RELEASE", 0, "Release", ""},
65         {KM_CLICK, "CLICK", 0, "Click", ""},
66         {KM_DBL_CLICK, "DOUBLE_CLICK", 0, "Double Click", ""},
67         {0, NULL, 0, NULL, NULL}};
68
69 EnumPropertyItem event_tweak_type_items[]= {
70         {EVT_TWEAK_L, "EVT_TWEAK_L", 0, "Left", ""},
71         {EVT_TWEAK_M, "EVT_TWEAK_M", 0, "Middle", ""},
72         {EVT_TWEAK_R, "EVT_TWEAK_R", 0, "Right", ""},
73         {EVT_TWEAK_A, "EVT_TWEAK_A", 0, "Action", ""},
74         {EVT_TWEAK_S, "EVT_TWEAK_S", 0, "Select", ""},
75         {0, NULL, 0, NULL, NULL}};
76
77 EnumPropertyItem event_mouse_type_items[]= {
78         {LEFTMOUSE, "LEFTMOUSE", 0, "Left", ""},
79         {MIDDLEMOUSE, "MIDDLEMOUSE", 0, "Middle", ""},
80         {RIGHTMOUSE, "RIGHTMOUSE", 0, "Right", ""},
81         {BUTTON4MOUSE, "BUTTON4MOUSE", 0, "Button4", ""},
82         {BUTTON5MOUSE, "BUTTON5MOUSE", 0, "Button5", ""},
83         {ACTIONMOUSE, "ACTIONMOUSE", 0, "Action", ""},
84         {SELECTMOUSE, "SELECTMOUSE", 0, "Select", ""},
85         {0, "", 0, NULL, NULL},
86         {MOUSEMOVE, "MOUSEMOVE", 0, "Move", ""},
87         {MOUSEPAN, "TRACKPADPAN", 0, "Mouse/Trackpad Pan", ""},
88         {MOUSEZOOM, "TRACKPADZOOM", 0, "Mouse/Trackpad Zoom", ""},
89         {MOUSEROTATE, "MOUSEROTATE", 0, "Mouse/Trackpad Rotate", ""},
90         {0, "", 0, NULL, NULL},
91         {WHEELUPMOUSE, "WHEELUPMOUSE", 0, "Wheel Up", ""},
92         {WHEELDOWNMOUSE, "WHEELDOWNMOUSE", 0, "Wheel Down", ""},
93         {WHEELINMOUSE, "WHEELINMOUSE", 0, "Wheel In", ""},
94         {WHEELOUTMOUSE, "WHEELOUTMOUSE", 0, "Wheel Out", ""},
95         {0, NULL, 0, NULL, NULL}};
96
97 EnumPropertyItem event_timer_type_items[]= {
98         {TIMER, "TIMER", 0, "Timer", ""},
99         {TIMER0, "TIMER0", 0, "Timer 0", ""},
100         {TIMER1, "TIMER1", 0, "Timer 1", ""},
101         {TIMER2, "TIMER2", 0, "Timer 2", ""},
102         {0, NULL, 0, NULL, NULL}};
103
104 /* not returned: CAPSLOCKKEY, UNKNOWNKEY, GRLESSKEY */
105 EnumPropertyItem event_type_items[] = {
106
107         {0, "NONE", 0, "", ""},
108         {LEFTMOUSE, "LEFTMOUSE", 0, "Left Mouse", ""},
109         {MIDDLEMOUSE, "MIDDLEMOUSE", 0, "Middle Mouse", ""},
110         {RIGHTMOUSE, "RIGHTMOUSE", 0, "Right Mouse", ""},
111         {BUTTON4MOUSE, "BUTTON4MOUSE", 0, "Button4 Mouse", ""},
112         {BUTTON5MOUSE, "BUTTON5MOUSE", 0, "Button5 Mouse", ""},
113         {ACTIONMOUSE, "ACTIONMOUSE", 0, "Action Mouse", ""},
114         {SELECTMOUSE, "SELECTMOUSE", 0, "Select Mouse", ""},
115         {0, "", 0, NULL, NULL},
116         {MOUSEMOVE, "MOUSEMOVE", 0, "Mouse Move", ""},
117         {MOUSEPAN, "TRACKPADPAN", 0, "Mouse/Trackpad Pan", ""},
118         {MOUSEZOOM, "TRACKPADZOOM", 0, "Mouse/Trackpad Zoom", ""},
119         {MOUSEROTATE, "MOUSEROTATE", 0, "Mouse/Trackpad Rotate", ""},
120         {0, "", 0, NULL, NULL},
121         {WHEELUPMOUSE, "WHEELUPMOUSE", 0, "Wheel Up", ""},
122         {WHEELDOWNMOUSE, "WHEELDOWNMOUSE", 0, "Wheel Down", ""},
123         {WHEELINMOUSE, "WHEELINMOUSE", 0, "Wheel In", ""},
124         {WHEELOUTMOUSE, "WHEELOUTMOUSE", 0, "Wheel Out", ""},
125         {0, "", 0, NULL, NULL},
126         {EVT_TWEAK_L, "EVT_TWEAK_L", 0, "Tweak Left", ""},
127         {EVT_TWEAK_M, "EVT_TWEAK_M", 0, "Tweak Middle", ""},
128         {EVT_TWEAK_R, "EVT_TWEAK_R", 0, "Tweak Right", ""},
129         {EVT_TWEAK_A, "EVT_TWEAK_A", 0, "Tweak Action", ""},
130         {EVT_TWEAK_S, "EVT_TWEAK_S", 0, "Tweak Select", ""},
131         {0, "", 0, NULL, NULL},
132         {AKEY, "A", 0, "A", ""},
133         {BKEY, "B", 0, "B", ""},
134         {CKEY, "C", 0, "C", ""},
135         {DKEY, "D", 0, "D", ""},
136         {EKEY, "E", 0, "E", ""},
137         {FKEY, "F", 0, "F", ""},
138         {GKEY, "G", 0, "G", ""},
139         {HKEY, "H", 0, "H", ""},
140         {IKEY, "I", 0, "I", ""},
141         {JKEY, "J", 0, "J", ""},
142         {KKEY, "K", 0, "K", ""},
143         {LKEY, "L", 0, "L", ""},
144         {MKEY, "M", 0, "M", ""},
145         {NKEY, "N", 0, "N", ""},
146         {OKEY, "O", 0, "O", ""},
147         {PKEY, "P", 0, "P", ""},
148         {QKEY, "Q", 0, "Q", ""},
149         {RKEY, "R", 0, "R", ""},
150         {SKEY, "S", 0, "S", ""},
151         {TKEY, "T", 0, "T", ""},
152         {UKEY, "U", 0, "U", ""},
153         {VKEY, "V", 0, "V", ""},
154         {WKEY, "W", 0, "W", ""},
155         {XKEY, "X", 0, "X", ""},
156         {YKEY, "Y", 0, "Y", ""},
157         {ZKEY, "Z", 0, "Z", ""},
158         {0, "", 0, NULL, NULL},
159         {ZEROKEY, "ZERO",       0, "0", ""},
160         {ONEKEY, "ONE",         0, "1", ""},
161         {TWOKEY, "TWO",         0, "2", ""},
162         {THREEKEY, "THREE",     0, "3", ""},
163         {FOURKEY, "FOUR",       0, "4", ""},
164         {FIVEKEY, "FIVE",       0, "5", ""},
165         {SIXKEY, "SIX",         0, "6", ""},
166         {SEVENKEY, "SEVEN",     0, "7", ""},
167         {EIGHTKEY, "EIGHT",     0, "8", ""},
168         {NINEKEY, "NINE",       0, "9", ""},
169         {0, "", 0, NULL, NULL},
170         {LEFTCTRLKEY,   "LEFT_CTRL",    0, "Left Ctrl", ""},
171         {LEFTALTKEY,    "LEFT_ALT",             0, "Left Alt", ""},
172         {LEFTSHIFTKEY,  "LEFT_SHIFT",   0, "Left Shift", ""},
173         {RIGHTALTKEY,   "RIGHT_ALT",    0, "Right Alt", ""},
174         {RIGHTCTRLKEY,  "RIGHT_CTRL",   0, "Right Ctrl", ""},
175         {RIGHTSHIFTKEY, "RIGHT_SHIFT",  0, "Right Shift", ""},
176         {0, "", 0, NULL, NULL},
177         {COMMANDKEY,    "COMMAND",      0, "Command", ""},
178         {0, "", 0, NULL, NULL},
179         {ESCKEY, "ESC", 0, "Esc", ""},
180         {TABKEY, "TAB", 0, "Tab", ""},
181         {RETKEY, "RET", 0, "Return", ""},
182         {SPACEKEY, "SPACE", 0, "Spacebar", ""},
183         {LINEFEEDKEY, "LINE_FEED", 0, "Line Feed", ""},
184         {BACKSPACEKEY, "BACK_SPACE", 0, "Back Space", ""},
185         {DELKEY, "DEL", 0, "Delete", ""},
186         {SEMICOLONKEY, "SEMI_COLON", 0, ";", ""},
187         {PERIODKEY, "PERIOD", 0, ".", ""},
188         {COMMAKEY, "COMMA", 0, ",", ""},
189         {QUOTEKEY, "QUOTE", 0, "\"", ""},
190         {ACCENTGRAVEKEY, "ACCENT_GRAVE", 0, "`", ""},
191         {MINUSKEY, "MINUS", 0, "-", ""},
192         {SLASHKEY, "SLASH", 0, "/", ""},
193         {BACKSLASHKEY, "BACK_SLASH", 0, "\\", ""},
194         {EQUALKEY, "EQUAL", 0, "=", ""},
195         {LEFTBRACKETKEY, "LEFT_BRACKET", 0, "[", ""},
196         {RIGHTBRACKETKEY, "RIGHT_BRACKET", 0, "]", ""},
197         {LEFTARROWKEY, "LEFT_ARROW", 0, "Left Arrow", ""},
198         {DOWNARROWKEY, "DOWN_ARROW", 0, "Down Arrow", ""},
199         {RIGHTARROWKEY, "RIGHT_ARROW", 0, "Right Arrow", ""},
200         {UPARROWKEY, "UP_ARROW", 0, "Up Arrow", ""},
201         {PAD2, "NUMPAD_2", 0, "Numpad 2", ""},
202         {PAD4, "NUMPAD_4", 0, "Numpad 4", ""},
203         {PAD6, "NUMPAD_6", 0, "Numpad 6", ""},
204         {PAD8, "NUMPAD_8", 0, "Numpad 8", ""},
205         {PAD1, "NUMPAD_1", 0, "Numpad 1", ""},
206         {PAD3, "NUMPAD_3", 0, "Numpad 3", ""},
207         {PAD5, "NUMPAD_5", 0, "Numpad 5", ""},
208         {PAD7, "NUMPAD_7", 0, "Numpad 7", ""},
209         {PAD9, "NUMPAD_9", 0, "Numpad 9", ""},
210         {PADPERIOD, "NUMPAD_PERIOD", 0, "Numpad .", ""},
211         {PADSLASHKEY, "NUMPAD_SLASH", 0, "Numpad /", ""},
212         {PADASTERKEY, "NUMPAD_ASTERIX", 0, "Numpad *", ""},
213         {PAD0, "NUMPAD_0", 0, "Numpad 0", ""},
214         {PADMINUS, "NUMPAD_MINUS", 0, "Numpad -", ""},
215         {PADENTER, "NUMPAD_ENTER", 0, "Numpad Enter", ""},
216         {PADPLUSKEY, "NUMPAD_PLUS", 0, "Numpad +", ""},
217         {F1KEY, "F1", 0, "F1", ""},
218         {F2KEY, "F2", 0, "F2", ""},
219         {F3KEY, "F3", 0, "F3", ""},
220         {F4KEY, "F4", 0, "F4", ""},
221         {F5KEY, "F5", 0, "F5", ""},
222         {F6KEY, "F6", 0, "F6", ""},
223         {F7KEY, "F7", 0, "F7", ""},
224         {F8KEY, "F8", 0, "F8", ""},
225         {F9KEY, "F9", 0, "F9", ""},
226         {F10KEY, "F10", 0, "F10", ""},
227         {F11KEY, "F11", 0, "F11", ""},
228         {F12KEY, "F12", 0, "F12", ""},
229         {PAUSEKEY, "PAUSE", 0, "Pause", ""},
230         {INSERTKEY, "INSERT", 0, "Insert", ""},
231         {HOMEKEY, "HOME", 0, "Home", ""},
232         {PAGEUPKEY, "PAGE_UP", 0, "Page Up", ""},
233         {PAGEDOWNKEY, "PAGE_DOWN", 0, "Page Down", ""},
234         {ENDKEY, "END", 0, "End", ""},
235         {0, "", 0, NULL, NULL},
236         {WINDEACTIVATE, "WINDOW_DEACTIVATE", 0, "Window Deactivate", ""},
237         {TIMER, "TIMER", 0, "Timer", ""},
238         {TIMER0, "TIMER0", 0, "Timer 0", ""},
239         {TIMER1, "TIMER1", 0, "Timer 1", ""},
240         {TIMER2, "TIMER2", 0, "Timer 2", ""},
241         {0, NULL, 0, NULL, NULL}};      
242
243 EnumPropertyItem keymap_propvalue_items[] = {
244                 {0, "NONE", 0, "", ""},
245                 {0, NULL, 0, NULL, NULL}};
246
247 EnumPropertyItem keymap_modifiers_items[] = {
248                 {KM_ANY, "ANY", 0, "Any", ""},
249                 {0, "NONE", 0, "None", ""},
250                 {1, "FIRST", 0, "First", ""},
251                 {2, "SECOND", 0, "Second", ""},
252                 {0, NULL, 0, NULL, NULL}};
253
254 EnumPropertyItem operator_flag_items[] = {
255                 {OPTYPE_REGISTER, "REGISTER", 0, "Register", ""},
256                 {OPTYPE_UNDO, "UNDO", 0, "Undo", ""},
257                 {OPTYPE_BLOCKING, "BLOCKING", 0, "Finished", ""},
258                 {OPTYPE_MACRO, "MACRO", 0, "Macro", ""},
259                 {OPTYPE_GRAB_POINTER, "GRAB_POINTER", 0, "Grab Pointer", ""},
260                 {0, NULL, 0, NULL, NULL}};
261
262 EnumPropertyItem operator_return_items[] = {
263                 {OPERATOR_RUNNING_MODAL, "RUNNING_MODAL", 0, "Running Modal", ""},
264                 {OPERATOR_CANCELLED, "CANCELLED", 0, "Cancelled", ""},
265                 {OPERATOR_FINISHED, "FINISHED", 0, "Finished", ""},
266                 {OPERATOR_PASS_THROUGH, "PASS_THROUGH", 0, "Pass Through", ""}, // used as a flag
267                 {0, NULL, 0, NULL, NULL}};
268
269 /* flag/enum */
270 EnumPropertyItem wm_report_items[] = {
271                 {RPT_DEBUG, "DEBUG", 0, "Debug", ""},
272                 {RPT_INFO, "INFO", 0, "Info", ""},
273                 {RPT_OPERATOR, "OPERATOR", 0, "Operator", ""},
274                 {RPT_WARNING, "WARNING", 0, "Warning", ""},
275                 {RPT_ERROR, "ERROR", 0, "Error", ""},
276                 {RPT_ERROR_INVALID_INPUT, "ERROR_INVALID_INPUT", 0, "Invalid Input", ""},\
277                 {RPT_ERROR_INVALID_CONTEXT, "ERROR_INVALID_CONTEXT", 0, "Invalid Context", ""},
278                 {RPT_ERROR_OUT_OF_MEMORY, "ERROR_OUT_OF_MEMORY", 0, "Out of Memory", ""},
279                 {0, NULL, 0, NULL, NULL}};
280
281 #define KMI_TYPE_KEYBOARD       0
282 #define KMI_TYPE_MOUSE          1
283 #define KMI_TYPE_TWEAK          2
284 #define KMI_TYPE_TEXTINPUT      3
285 #define KMI_TYPE_TIMER          4
286
287 #ifdef RNA_RUNTIME
288
289 #include "WM_api.h"
290
291 #include "BKE_idprop.h"
292
293 #include "MEM_guardedalloc.h"
294
295 static wmOperator *rna_OperatorProperties_find_operator(PointerRNA *ptr)
296 {
297         wmWindowManager *wm= ptr->id.data;
298         IDProperty *properties= (IDProperty*)ptr->data;
299         wmOperator *op;
300
301         if(wm)
302                 for(op=wm->operators.first; op; op=op->next)
303                         if(op->properties == properties)
304                                 return op;
305         
306         return NULL;
307 }
308
309 static StructRNA *rna_OperatorProperties_refine(PointerRNA *ptr)
310 {
311         wmOperator *op= rna_OperatorProperties_find_operator(ptr);
312
313         if(op)
314                 return op->type->srna;
315         else
316                 return ptr->type;
317 }
318
319 static IDProperty *rna_OperatorProperties_idproperties(PointerRNA *ptr, int create)
320 {
321         if(create && !ptr->data) {
322                 IDPropertyTemplate val = {0};
323                 ptr->data= IDP_New(IDP_GROUP, val, "RNA_OperatorProperties group");
324         }
325
326         return ptr->data;
327 }
328
329 static void rna_Operator_name_get(PointerRNA *ptr, char *value)
330 {
331         wmOperator *op= (wmOperator*)ptr->data;
332         strcpy(value, op->type->name);
333 }
334
335 static int rna_Operator_name_length(PointerRNA *ptr)
336 {
337         wmOperator *op= (wmOperator*)ptr->data;
338         return strlen(op->type->name);
339 }
340
341 static int rna_Operator_has_reports_get(PointerRNA *ptr)
342 {
343         wmOperator *op= (wmOperator*)ptr->data;
344         return (op->reports && op->reports->list.first);
345 }
346
347 static PointerRNA rna_Operator_properties_get(PointerRNA *ptr)
348 {
349         wmOperator *op= (wmOperator*)ptr->data;
350         return rna_pointer_inherit_refine(ptr, op->type->srna, op->properties);
351 }
352
353 static PointerRNA rna_OperatorTypeMacro_properties_get(PointerRNA *ptr)
354 {
355         wmOperatorTypeMacro *otmacro= (wmOperatorTypeMacro*)ptr->data;
356         wmOperatorType *ot = WM_operatortype_exists(otmacro->idname);
357         return rna_pointer_inherit_refine(ptr, ot->srna, otmacro->properties);
358 }
359
360 static void rna_Event_ascii_get(PointerRNA *ptr, char *value)
361 {
362         wmEvent *event= (wmEvent*)ptr->id.data;
363         value[0]= event->ascii;
364         value[1]= '\0';
365 }
366
367 static int rna_Event_ascii_length(PointerRNA *ptr)
368 {
369         wmEvent *event= (wmEvent*)ptr->id.data;
370         return (event->ascii)? 1 : 0;
371 }
372
373 static void rna_Window_screen_set(PointerRNA *ptr, PointerRNA value)
374 {
375         wmWindow *win= (wmWindow*)ptr->data;
376
377         if(value.data == NULL)
378                 return;
379
380         /* exception: can't set screens inside of area/region handers */
381         win->newscreen= value.data;
382 }
383
384 static void rna_Window_screen_update(bContext *C, PointerRNA *ptr)
385 {
386         wmWindow *win= (wmWindow*)ptr->data;
387
388         /* exception: can't set screens inside of area/region handers */
389         if(win->newscreen) {
390                 WM_event_add_notifier(C, NC_SCREEN|ND_SCREENBROWSE, win->newscreen);
391                 win->newscreen= NULL;
392         }
393 }
394
395 static PointerRNA rna_KeyMapItem_properties_get(PointerRNA *ptr)
396 {
397         wmKeyMapItem *kmi= ptr->data;
398
399         if(kmi->ptr)
400                 return *(kmi->ptr);
401         
402         //return rna_pointer_inherit_refine(ptr, &RNA_OperatorProperties, op->properties);
403         return PointerRNA_NULL;
404 }
405
406 static int rna_wmKeyMapItem_map_type_get(PointerRNA *ptr)
407 {
408         wmKeyMapItem *kmi= ptr->data;
409
410         if(ISTIMER(kmi->type)) return KMI_TYPE_TIMER;
411         if(ISKEYBOARD(kmi->type)) return KMI_TYPE_KEYBOARD;
412         if(ISTWEAK(kmi->type)) return KMI_TYPE_TWEAK;
413         if(ISMOUSE(kmi->type)) return KMI_TYPE_MOUSE;
414         if(kmi->type == KM_TEXTINPUT) return KMI_TYPE_TEXTINPUT;
415         return KMI_TYPE_KEYBOARD;
416 }
417
418 static void rna_wmKeyMapItem_map_type_set(PointerRNA *ptr, int value)
419 {
420         wmKeyMapItem *kmi= ptr->data;
421         int map_type= rna_wmKeyMapItem_map_type_get(ptr);
422
423         if(value != map_type) {
424                 switch(value) {
425                 case KMI_TYPE_KEYBOARD:
426                         kmi->type= AKEY;
427                         kmi->val= KM_PRESS;
428                         break;
429                 case KMI_TYPE_TWEAK:
430                         kmi->type= EVT_TWEAK_L;
431                         kmi->val= KM_ANY;
432                         break;
433                 case KMI_TYPE_MOUSE:
434                         kmi->type= LEFTMOUSE;
435                         kmi->val= KM_PRESS;
436                         break;
437                 case KMI_TYPE_TEXTINPUT:
438                         kmi->type= KM_TEXTINPUT;
439                         kmi->val= KM_NOTHING;
440                         break;
441                 case KMI_TYPE_TIMER:
442                         kmi->type= TIMER;
443                         kmi->val= KM_NOTHING;
444                         break;
445                 }
446         }
447 }
448
449 static EnumPropertyItem *rna_KeyMapItem_type_itemf(bContext *C, PointerRNA *ptr, int *free)
450 {
451         int map_type= rna_wmKeyMapItem_map_type_get(ptr);
452
453         if(map_type == KMI_TYPE_MOUSE) return event_mouse_type_items;
454         if(map_type == KMI_TYPE_TWEAK) return event_tweak_type_items;
455         if(map_type == KMI_TYPE_TIMER) return event_timer_type_items;
456         else return event_type_items;
457 }
458
459 static EnumPropertyItem *rna_KeyMapItem_value_itemf(bContext *C, PointerRNA *ptr, int *free)
460 {
461         int map_type= rna_wmKeyMapItem_map_type_get(ptr);
462
463         if(map_type == KMI_TYPE_MOUSE || map_type == KMI_TYPE_KEYBOARD) return event_keymouse_value_items;
464         if(map_type == KMI_TYPE_TWEAK) return event_tweak_value_items;
465         else return event_value_items;
466 }
467
468 static EnumPropertyItem *rna_KeyMapItem_propvalue_itemf(bContext *C, PointerRNA *ptr, int *free)
469 {
470         wmWindowManager *wm = CTX_wm_manager(C);
471         wmKeyConfig *kc;
472         wmKeyMap *km;
473
474         /* check user keymaps */
475         for(km=U.keymaps.first; km; km=km->next) {
476                 wmKeyMapItem *kmi;
477                 for (kmi=km->items.first; kmi; kmi=kmi->next) {
478                         if (kmi == ptr->data) {
479                                 if (!km->modal_items) {
480                                         if (!WM_keymap_user_init(wm, km)) {
481                                                 return keymap_propvalue_items; /* ERROR */
482                                         }
483                                 }
484
485                                 return km->modal_items;
486                         }
487                 }
488         }
489
490         for(kc=wm->keyconfigs.first; kc; kc=kc->next) {
491                 for(km=kc->keymaps.first; km; km=km->next) {
492                         /* only check if it's a modal keymap */
493                         if (km->modal_items) {
494                                 wmKeyMapItem *kmi;
495                                 for (kmi=km->items.first; kmi; kmi=kmi->next) {
496                                         if (kmi == ptr->data) {
497                                                 return km->modal_items;
498                                         }
499                                 }
500                         }
501                 }
502         }
503
504
505         return keymap_propvalue_items; /* ERROR */
506 }
507
508 static int rna_KeyMapItem_any_getf(PointerRNA *ptr)
509 {
510         wmKeyMapItem *kmi = (wmKeyMapItem*)ptr->data;
511
512         if (kmi->shift == KM_ANY &&
513                 kmi->ctrl == KM_ANY &&
514                 kmi->alt == KM_ANY &&
515                 kmi->oskey == KM_ANY)
516
517                 return 1;
518         else
519                 return 0;
520 }
521
522 static void rna_KeyMapItem_any_setf(PointerRNA *ptr, int value)
523 {
524         wmKeyMapItem *kmi = (wmKeyMapItem*)ptr->data;
525
526         if(value) {
527                 kmi->shift= kmi->ctrl= kmi->alt= kmi->oskey= KM_ANY;
528         }
529         else {
530                 kmi->shift= kmi->ctrl= kmi->alt= kmi->oskey= 0;
531         }
532 }
533
534
535 static PointerRNA rna_WindowManager_active_keyconfig_get(PointerRNA *ptr)
536 {
537         wmWindowManager *wm= ptr->data;
538         wmKeyConfig *kc;
539
540         for(kc=wm->keyconfigs.first; kc; kc=kc->next)
541                 if(strcmp(kc->idname, U.keyconfigstr) == 0)
542                         break;
543         
544         if(!kc)
545                 kc= wm->defaultconf;
546         
547         return rna_pointer_inherit_refine(ptr, &RNA_KeyConfig, kc);
548 }
549
550 static void rna_WindowManager_active_keyconfig_set(PointerRNA *ptr, PointerRNA value)
551 {
552         wmKeyConfig *kc= value.data;
553
554         if(kc)
555                 BLI_strncpy(U.keyconfigstr, kc->idname, sizeof(U.keyconfigstr));
556 }
557
558 static void rna_wmKeyMapItem_idname_get(PointerRNA *ptr, char *value)
559 {
560         wmKeyMapItem *kmi= ptr->data;
561         WM_operator_py_idname(value, kmi->idname);
562 }
563
564 static int rna_wmKeyMapItem_idname_length(PointerRNA *ptr)
565 {
566         wmKeyMapItem *kmi= ptr->data;
567         char pyname[OP_MAX_TYPENAME];
568
569         WM_operator_py_idname(pyname, kmi->idname);
570         return strlen(pyname);
571 }
572
573 static void rna_wmKeyMapItem_idname_set(PointerRNA *ptr, const char *value)
574 {
575         wmKeyMapItem *kmi= ptr->data;
576         char idname[OP_MAX_TYPENAME];
577
578         WM_operator_bl_idname(idname, value);
579
580         if(strcmp(idname, kmi->idname) != 0) {
581                 BLI_strncpy(kmi->idname, idname, sizeof(kmi->idname));
582
583                 WM_keymap_properties_reset(kmi);
584         }
585 }
586
587 static void rna_wmKeyMapItem_name_get(PointerRNA *ptr, char *value)
588 {
589         wmKeyMapItem *kmi= ptr->data;
590         wmOperatorType *ot= WM_operatortype_find(kmi->idname, 1);
591         
592         if (ot)
593                 strcpy(value, ot->name);
594 }
595
596 static int rna_wmKeyMapItem_name_length(PointerRNA *ptr)
597 {
598         wmKeyMapItem *kmi= ptr->data;
599         wmOperatorType *ot= WM_operatortype_find(kmi->idname, 1);
600         
601         if (ot)
602                 return strlen(ot->name);
603         else
604                 return 0;
605 }
606
607 static void rna_Operator_unregister(const bContext *C, StructRNA *type)
608 {
609         char *idname;
610         wmOperatorType *ot= RNA_struct_blender_type_get(type);
611
612         if(!ot)
613                 return;
614
615         RNA_struct_free_extension(type, &ot->ext);
616
617         idname= ot->idname;
618         WM_operatortype_remove(ot->idname);
619         MEM_freeN(idname);
620
621         /* not to be confused with the RNA_struct_free that WM_operatortype_remove calls, they are 2 different srna's */
622         RNA_struct_free(&BLENDER_RNA, type);
623
624         /* update while blender is running */
625         if(C)
626                 WM_main_add_notifier(NC_SCREEN|NA_EDITED, NULL);
627 }
628
629 static int operator_poll(bContext *C, wmOperatorType *ot)
630 {
631         PointerRNA ptr;
632         ParameterList list;
633         FunctionRNA *func;
634         void *ret;
635         int visible;
636
637         RNA_pointer_create(NULL, ot->ext.srna, NULL, &ptr); /* dummy */
638         func= RNA_struct_find_function(&ptr, "poll");
639
640         RNA_parameter_list_create(&list, &ptr, func);
641         RNA_parameter_set_lookup(&list, "context", &C);
642         ot->ext.call(&ptr, func, &list);
643
644         RNA_parameter_get_lookup(&list, "visible", &ret);
645         visible= *(int*)ret;
646
647         RNA_parameter_list_free(&list);
648
649         return visible;
650 }
651
652 static int operator_exec(bContext *C, wmOperator *op)
653 {
654         PointerRNA opr;
655         ParameterList list;
656         FunctionRNA *func;
657         void *ret;
658         int result;
659
660         RNA_pointer_create(&CTX_wm_screen(C)->id, op->type->ext.srna, op, &opr);
661         func= RNA_struct_find_function(&opr, "execute");
662
663         RNA_parameter_list_create(&list, &opr, func);
664         RNA_parameter_set_lookup(&list, "context", &C);
665         op->type->ext.call(&opr, func, &list);
666
667         RNA_parameter_get_lookup(&list, "result", &ret);
668         result= *(int*)ret;
669
670         RNA_parameter_list_free(&list);
671
672         return result;
673 }
674
675 static int operator_invoke(bContext *C, wmOperator *op, wmEvent *event)
676 {
677         PointerRNA opr;
678         ParameterList list;
679         FunctionRNA *func;
680         void *ret;
681         int result;
682
683         RNA_pointer_create(&CTX_wm_screen(C)->id, op->type->ext.srna, op, &opr);
684         func= RNA_struct_find_function(&opr, "invoke");
685
686         RNA_parameter_list_create(&list, &opr, func);
687         RNA_parameter_set_lookup(&list, "context", &C);
688         RNA_parameter_set_lookup(&list, "event", &event);
689         op->type->ext.call(&opr, func, &list);
690
691         RNA_parameter_get_lookup(&list, "result", &ret);
692         result= *(int*)ret;
693
694         RNA_parameter_list_free(&list);
695
696         return result;
697 }
698
699 /* same as invoke */
700 static int operator_modal(bContext *C, wmOperator *op, wmEvent *event)
701 {
702         PointerRNA opr;
703         ParameterList list;
704         FunctionRNA *func;
705         void *ret;
706         int result;
707
708         RNA_pointer_create(&CTX_wm_screen(C)->id, op->type->ext.srna, op, &opr);
709         func= RNA_struct_find_function(&opr, "modal");
710
711         RNA_parameter_list_create(&list, &opr, func);
712         RNA_parameter_set_lookup(&list, "context", &C);
713         RNA_parameter_set_lookup(&list, "event", &event);
714         op->type->ext.call(&opr, func, &list);
715
716         RNA_parameter_get_lookup(&list, "result", &ret);
717         result= *(int*)ret;
718
719         RNA_parameter_list_free(&list);
720
721         return result;
722 }
723
724 static void operator_draw(bContext *C, wmOperator *op)
725 {
726         PointerRNA opr;
727         ParameterList list;
728         FunctionRNA *func;
729
730         RNA_pointer_create(&CTX_wm_screen(C)->id, op->type->ext.srna, op, &opr);
731         func= RNA_struct_find_function(&opr, "draw");
732
733         RNA_parameter_list_create(&list, &opr, func);
734         RNA_parameter_set_lookup(&list, "context", &C);
735         op->type->ext.call(&opr, func, &list);
736
737         RNA_parameter_list_free(&list);
738 }
739
740 #ifndef DISABLE_PYTHON
741 void operator_wrapper(wmOperatorType *ot, void *userdata);
742 void macro_wrapper(wmOperatorType *ot, void *userdata);
743
744 static char _operator_idname[OP_MAX_TYPENAME];
745 static char _operator_name[OP_MAX_TYPENAME];
746 static char _operator_descr[1024];
747 static StructRNA *rna_Operator_register(const bContext *C, ReportList *reports, void *data, const char *identifier, StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
748 {
749         wmOperatorType dummyot = {0};
750         wmOperator dummyop= {0};
751         PointerRNA dummyotr;
752         int have_function[5];
753
754         /* setup dummy operator & operator type to store static properties in */
755         dummyop.type= &dummyot;
756         dummyot.idname= _operator_idname; /* only assigne the pointer, string is NULL'd */
757         dummyot.name= _operator_name; /* only assigne the pointer, string is NULL'd */
758         dummyot.description= _operator_descr; /* only assigne the pointer, string is NULL'd */
759         RNA_pointer_create(NULL, &RNA_Operator, &dummyop, &dummyotr);
760
761         /* validate the python class */
762         if(validate(&dummyotr, data, have_function) != 0)
763                 return NULL;
764
765         {       /* convert foo.bar to FOO_OT_bar
766                  * allocate the description and the idname in 1 go */
767                 int idlen = strlen(_operator_idname) + 4;
768                 int namelen = strlen(_operator_name) + 1;
769                 int desclen = strlen(_operator_descr) + 1;
770                 char *ch, *ch_arr;
771                 ch_arr= ch= MEM_callocN(sizeof(char) * (idlen + namelen + desclen), "_operator_idname"); /* 2 terminators and 3 to convert a.b -> A_OT_b */
772                 WM_operator_bl_idname(ch, _operator_idname); /* convert the idname from python */
773                 dummyot.idname= ch;
774                 ch += idlen;
775                 strcpy(ch, _operator_name);
776                 dummyot.name = ch;
777                 ch += namelen;
778                 strcpy(ch, _operator_descr);
779                 dummyot.description = ch;
780         }
781
782         if(strlen(identifier) >= sizeof(dummyop.idname)) {
783                 BKE_reportf(reports, RPT_ERROR, "registering operator class: '%s' is too long, maximum length is %d.", identifier, sizeof(dummyop.idname));
784                 return NULL;
785         }
786
787         /* check if we have registered this operator type before, and remove it */
788         {
789                 wmOperatorType *ot= WM_operatortype_exists(dummyot.idname);
790                 if(ot && ot->ext.srna)
791                         rna_Operator_unregister(C, ot->ext.srna);
792         }
793
794         /* create a new menu type */
795         dummyot.ext.srna= RNA_def_struct(&BLENDER_RNA, dummyot.idname, "Operator");
796         dummyot.ext.data= data;
797         dummyot.ext.call= call;
798         dummyot.ext.free= free;
799
800         dummyot.pyop_poll=      (have_function[0])? operator_poll: NULL;
801         dummyot.exec=           (have_function[1])? operator_exec: NULL;
802         dummyot.invoke=         (have_function[2])? operator_invoke: NULL;
803         dummyot.modal=          (have_function[3])? operator_modal: NULL;
804         dummyot.ui=                     (have_function[4])? operator_draw: NULL;
805
806         WM_operatortype_append_ptr(operator_wrapper, (void *)&dummyot);
807
808         /* update while blender is running */
809         if(C)
810                 WM_main_add_notifier(NC_SCREEN|NA_EDITED, NULL);
811
812         return dummyot.ext.srna;
813 }
814
815
816 static StructRNA *rna_MacroOperator_register(const bContext *C, ReportList *reports, void *data, const char *identifier, StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
817 {
818         wmOperatorType dummyot = {0};
819         wmOperator dummyop= {0};
820         PointerRNA dummyotr;
821         int have_function[4];
822
823         /* setup dummy operator & operator type to store static properties in */
824         dummyop.type= &dummyot;
825         dummyot.idname= _operator_idname; /* only assigne the pointer, string is NULL'd */
826         dummyot.name= _operator_name; /* only assigne the pointer, string is NULL'd */
827         dummyot.description= _operator_descr; /* only assigne the pointer, string is NULL'd */
828         RNA_pointer_create(NULL, &RNA_Macro, &dummyop, &dummyotr);
829
830         /* validate the python class */
831         if(validate(&dummyotr, data, have_function) != 0)
832                 return NULL;
833
834         {       /* convert foo.bar to FOO_OT_bar
835                  * allocate the description and the idname in 1 go */
836                 int idlen = strlen(_operator_idname) + 4;
837                 int namelen = strlen(_operator_name) + 1;
838                 int desclen = strlen(_operator_descr) + 1;
839                 char *ch, *ch_arr;
840                 ch_arr= ch= MEM_callocN(sizeof(char) * (idlen + namelen + desclen), "_operator_idname"); /* 2 terminators and 3 to convert a.b -> A_OT_b */
841                 WM_operator_bl_idname(ch, _operator_idname); /* convert the idname from python */
842                 dummyot.idname= ch;
843                 ch += idlen;
844                 strcpy(ch, _operator_name);
845                 dummyot.name = ch;
846                 ch += namelen;
847                 strcpy(ch, _operator_descr);
848                 dummyot.description = ch;
849         }
850
851         if(strlen(identifier) >= sizeof(dummyop.idname)) {
852                 BKE_reportf(reports, RPT_ERROR, "registering operator class: '%s' is too long, maximum length is %d.", identifier, sizeof(dummyop.idname));
853                 return NULL;
854         }
855
856         /* check if we have registered this operator type before, and remove it */
857         {
858                 wmOperatorType *ot= WM_operatortype_exists(dummyot.idname);
859                 if(ot && ot->ext.srna)
860                         rna_Operator_unregister(C, ot->ext.srna);
861         }
862
863         /* create a new menu type */
864         dummyot.ext.srna= RNA_def_struct(&BLENDER_RNA, dummyot.idname, "Operator");
865         dummyot.ext.data= data;
866         dummyot.ext.call= call;
867         dummyot.ext.free= free;
868
869         dummyot.pyop_poll=      (have_function[0])? operator_poll: NULL;
870         dummyot.ui=                     (have_function[3])? operator_draw: NULL;
871
872         WM_operatortype_append_macro_ptr(macro_wrapper, (void *)&dummyot);
873
874         /* update while blender is running */
875         if(C)
876                 WM_main_add_notifier(NC_SCREEN|NA_EDITED, NULL);
877
878         return dummyot.ext.srna;
879 }
880 #endif
881
882 static StructRNA* rna_Operator_refine(PointerRNA *opr)
883 {
884         wmOperator *op= (wmOperator*)opr->data;
885         return (op->type && op->type->ext.srna)? op->type->ext.srna: &RNA_Operator;
886 }
887
888 static StructRNA* rna_MacroOperator_refine(PointerRNA *opr)
889 {
890         wmOperator *op= (wmOperator*)opr->data;
891         return (op->type && op->type->ext.srna)? op->type->ext.srna: &RNA_Macro;
892 }
893
894 static wmKeyMapItem *rna_KeyMap_add_item(wmKeyMap *km, ReportList *reports, char *idname, int type, int value, int any, int shift, int ctrl, int alt, int oskey, int keymodifier)
895 {
896 //      wmWindowManager *wm = CTX_wm_manager(C);
897         int modifier= 0;
898
899         /* only on non-modal maps */
900         if (km->flag & KEYMAP_MODAL) {
901                 BKE_report(reports, RPT_ERROR, "Not a non-modal keymap.");
902                 return NULL;
903         }
904
905         if(shift) modifier |= KM_SHIFT;
906         if(ctrl) modifier |= KM_CTRL;
907         if(alt) modifier |= KM_ALT;
908         if(oskey) modifier |= KM_OSKEY;
909
910         if(any) modifier = KM_ANY;
911
912         return WM_keymap_add_item(km, idname, type, value, modifier, keymodifier);
913 }
914
915 static wmKeyMapItem *rna_KeyMap_add_modal_item(wmKeyMap *km, bContext *C, ReportList *reports, char* propvalue_str, int type, int value, int any, int shift, int ctrl, int alt, int oskey, int keymodifier)
916 {
917         wmWindowManager *wm = CTX_wm_manager(C);
918         int modifier= 0;
919         int propvalue = 0;
920
921         /* only modal maps */
922         if ((km->flag & KEYMAP_MODAL) == 0) {
923                 BKE_report(reports, RPT_ERROR, "Not a modal keymap.");
924                 return NULL;
925         }
926
927         if (!km->modal_items) {
928                 if(!WM_keymap_user_init(wm, km)) {
929                         BKE_report(reports, RPT_ERROR, "User defined keymap doesn't correspond to a system keymap.");
930                         return NULL;
931                 }
932         }
933
934         if (!km->modal_items) {
935                 BKE_report(reports, RPT_ERROR, "No property values defined.");
936                 return NULL;
937         }
938
939
940         if(RNA_enum_value_from_id(km->modal_items, propvalue_str, &propvalue)==0) {
941                 BKE_report(reports, RPT_WARNING, "Property value not in enumeration.");
942         }
943
944         if(shift) modifier |= KM_SHIFT;
945         if(ctrl) modifier |= KM_CTRL;
946         if(alt) modifier |= KM_ALT;
947         if(oskey) modifier |= KM_OSKEY;
948
949         if(any) modifier = KM_ANY;
950
951         return WM_modalkeymap_add_item(km, type, value, modifier, keymodifier, propvalue);
952 }
953
954 #else
955
956 static void rna_def_operator(BlenderRNA *brna)
957 {
958         StructRNA *srna;
959         PropertyRNA *prop;
960
961         srna= RNA_def_struct(brna, "Operator", NULL);
962         RNA_def_struct_ui_text(srna, "Operator", "Storage of an operator being executed, or registered after execution");
963         RNA_def_struct_sdna(srna, "wmOperator");
964         RNA_def_struct_refine_func(srna, "rna_Operator_refine");
965 #ifndef DISABLE_PYTHON
966         RNA_def_struct_register_funcs(srna, "rna_Operator_register", "rna_Operator_unregister");
967 #endif
968
969         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
970         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
971         RNA_def_property_string_funcs(prop, "rna_Operator_name_get", "rna_Operator_name_length", NULL);
972         RNA_def_property_ui_text(prop, "Name", "");
973         RNA_def_struct_name_property(srna, prop);
974
975         prop= RNA_def_property(srna, "properties", PROP_POINTER, PROP_NONE);
976         RNA_def_property_flag(prop, PROP_NEVER_NULL);
977         RNA_def_property_struct_type(prop, "OperatorProperties");
978         RNA_def_property_ui_text(prop, "Properties", "");
979         RNA_def_property_pointer_funcs(prop, "rna_Operator_properties_get", NULL, NULL);
980         
981         prop= RNA_def_property(srna, "has_reports", PROP_BOOLEAN, PROP_NONE);
982         RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* this is 'virtual' property */
983         RNA_def_property_boolean_funcs(prop, "rna_Operator_has_reports_get", NULL);
984         RNA_def_property_ui_text(prop, "Has Reports", "Operator has a set of reports (warnings and errors) from last execution");
985         
986         prop= RNA_def_property(srna, "layout", PROP_POINTER, PROP_NONE);
987         RNA_def_property_struct_type(prop, "UILayout");
988
989         /* Registration */
990         prop= RNA_def_property(srna, "bl_idname", PROP_STRING, PROP_NONE);
991         RNA_def_property_string_sdna(prop, NULL, "type->idname");
992         RNA_def_property_string_maxlength(prop, OP_MAX_TYPENAME); /* else it uses the pointer size! */
993         RNA_def_property_flag(prop, PROP_REGISTER);
994
995         prop= RNA_def_property(srna, "bl_label", PROP_STRING, PROP_NONE);
996         RNA_def_property_string_sdna(prop, NULL, "type->name");
997         RNA_def_property_string_maxlength(prop, 1024); /* else it uses the pointer size! */
998         RNA_def_property_flag(prop, PROP_REGISTER);
999
1000         prop= RNA_def_property(srna, "bl_description", PROP_STRING, PROP_NONE);
1001         RNA_def_property_string_sdna(prop, NULL, "type->description");
1002         RNA_def_property_string_maxlength(prop, 1024); /* else it uses the pointer size! */
1003         RNA_def_property_flag(prop, PROP_REGISTER);
1004
1005         prop= RNA_def_property(srna, "bl_options", PROP_ENUM, PROP_NONE);
1006         RNA_def_property_enum_sdna(prop, NULL, "type->flag");
1007         RNA_def_property_enum_items(prop, operator_flag_items);
1008         RNA_def_property_flag(prop, PROP_REGISTER_OPTIONAL|PROP_ENUM_FLAG);
1009         RNA_def_property_ui_text(prop, "Options",  "Options for this operator type");
1010
1011         RNA_api_operator(srna);
1012
1013         srna= RNA_def_struct(brna, "OperatorProperties", NULL);
1014         RNA_def_struct_ui_text(srna, "Operator Properties", "Input properties of an Operator");
1015         RNA_def_struct_refine_func(srna, "rna_OperatorProperties_refine");
1016         RNA_def_struct_idproperties_func(srna, "rna_OperatorProperties_idproperties");
1017 }
1018
1019 static void rna_def_macro_operator(BlenderRNA *brna)
1020 {
1021         StructRNA *srna;
1022         PropertyRNA *prop;
1023
1024         srna= RNA_def_struct(brna, "Macro", NULL);
1025         RNA_def_struct_ui_text(srna, "Macro Operator", "Storage of a macro operator being executed, or registered after execution");
1026         RNA_def_struct_sdna(srna, "wmOperator");
1027         RNA_def_struct_refine_func(srna, "rna_MacroOperator_refine");
1028 #ifndef DISABLE_PYTHON
1029         RNA_def_struct_register_funcs(srna, "rna_MacroOperator_register", "rna_Operator_unregister");
1030 #endif
1031     
1032         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1033         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1034         RNA_def_property_string_funcs(prop, "rna_Operator_name_get", "rna_Operator_name_length", NULL);
1035         RNA_def_property_ui_text(prop, "Name", "");
1036         RNA_def_struct_name_property(srna, prop);
1037
1038         prop= RNA_def_property(srna, "properties", PROP_POINTER, PROP_NONE);
1039         RNA_def_property_flag(prop, PROP_NEVER_NULL);
1040         RNA_def_property_struct_type(prop, "OperatorProperties");
1041         RNA_def_property_ui_text(prop, "Properties", "");
1042         RNA_def_property_pointer_funcs(prop, "rna_Operator_properties_get", NULL, NULL);
1043
1044         /* Registration */
1045         prop= RNA_def_property(srna, "bl_idname", PROP_STRING, PROP_NONE);
1046         RNA_def_property_string_sdna(prop, NULL, "type->idname");
1047         RNA_def_property_string_maxlength(prop, OP_MAX_TYPENAME); /* else it uses the pointer size! */
1048         RNA_def_property_flag(prop, PROP_REGISTER);
1049
1050         prop= RNA_def_property(srna, "bl_label", PROP_STRING, PROP_NONE);
1051         RNA_def_property_string_sdna(prop, NULL, "type->name");
1052         RNA_def_property_string_maxlength(prop, 1024); /* else it uses the pointer size! */
1053         RNA_def_property_flag(prop, PROP_REGISTER);
1054
1055         prop= RNA_def_property(srna, "bl_description", PROP_STRING, PROP_NONE);
1056         RNA_def_property_string_sdna(prop, NULL, "type->description");
1057         RNA_def_property_string_maxlength(prop, 1024); /* else it uses the pointer size! */
1058         RNA_def_property_flag(prop, PROP_REGISTER);
1059
1060         prop= RNA_def_property(srna, "bl_options", PROP_ENUM, PROP_NONE);
1061         RNA_def_property_enum_sdna(prop, NULL, "type->flag");
1062         RNA_def_property_enum_items(prop, operator_flag_items);
1063         RNA_def_property_flag(prop, PROP_REGISTER_OPTIONAL|PROP_ENUM_FLAG);
1064         RNA_def_property_ui_text(prop, "Options",  "Options for this operator type");
1065
1066         RNA_api_macro(srna);
1067 }
1068
1069 static void rna_def_operator_type_macro(BlenderRNA *brna)
1070 {
1071         StructRNA *srna;
1072         PropertyRNA *prop;
1073
1074         srna= RNA_def_struct(brna, "OperatorTypeMacro", NULL);
1075         RNA_def_struct_ui_text(srna, "OperatorTypeMacro", "Storage of a sub operator in a macro after it has been added");
1076         RNA_def_struct_sdna(srna, "wmOperatorTypeMacro");
1077
1078 //      prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1079 //      RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1080 //      RNA_def_property_string_sdna(prop, NULL, "idname");
1081 //      RNA_def_property_ui_text(prop, "Name", "Name of the sub operator");
1082 //      RNA_def_struct_name_property(srna, prop);
1083
1084         prop= RNA_def_property(srna, "properties", PROP_POINTER, PROP_NONE);
1085         RNA_def_property_flag(prop, PROP_NEVER_NULL);
1086         RNA_def_property_struct_type(prop, "OperatorProperties");
1087         RNA_def_property_ui_text(prop, "Properties", "");
1088         RNA_def_property_pointer_funcs(prop, "rna_OperatorTypeMacro_properties_get", NULL, NULL);
1089 }
1090
1091 static void rna_def_operator_utils(BlenderRNA *brna)
1092 {
1093         StructRNA *srna;
1094         PropertyRNA *prop;
1095
1096         srna= RNA_def_struct(brna, "OperatorMousePath", "IDPropertyGroup");
1097         RNA_def_struct_ui_text(srna, "Operator Mouse Path", "Mouse path values for operators that record such paths");
1098
1099         prop= RNA_def_property(srna, "loc", PROP_FLOAT, PROP_XYZ);
1100         RNA_def_property_flag(prop, PROP_IDPROPERTY);
1101         RNA_def_property_array(prop, 2);
1102         RNA_def_property_ui_text(prop, "Location", "Mouse location");
1103
1104         prop= RNA_def_property(srna, "time", PROP_FLOAT, PROP_NONE);
1105         RNA_def_property_flag(prop, PROP_IDPROPERTY);
1106         RNA_def_property_ui_text(prop, "Time", "Time of mouse location");
1107 }
1108
1109 static void rna_def_operator_filelist_element(BlenderRNA *brna)
1110 {
1111         StructRNA *srna;
1112         PropertyRNA *prop;
1113
1114         srna= RNA_def_struct(brna, "OperatorFileListElement", "IDPropertyGroup");
1115         RNA_def_struct_ui_text(srna, "Operator File List Element", "");
1116         
1117         
1118         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1119         RNA_def_property_flag(prop, PROP_IDPROPERTY);
1120         RNA_def_property_ui_text(prop, "Name", "the name of a file or directory within a file list");
1121 }
1122         
1123 static void rna_def_event(BlenderRNA *brna)
1124 {
1125         StructRNA *srna;
1126         PropertyRNA *prop;
1127         
1128         srna= RNA_def_struct(brna, "Event", NULL);
1129         RNA_def_struct_ui_text(srna, "Event", "Window Manager Event");
1130         RNA_def_struct_sdna(srna, "wmEvent");
1131
1132         RNA_define_verify_sdna(0); // not in sdna
1133
1134         /* strings */
1135         prop= RNA_def_property(srna, "ascii", PROP_STRING, PROP_NONE);
1136         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1137         RNA_def_property_string_funcs(prop, "rna_Event_ascii_get", "rna_Event_ascii_length", NULL);
1138         RNA_def_property_ui_text(prop, "ASCII", "Single ASCII character for this event");
1139
1140
1141         /* enums */
1142         prop= RNA_def_property(srna, "value", PROP_ENUM, PROP_NONE);
1143         RNA_def_property_enum_sdna(prop, NULL, "val");
1144         RNA_def_property_enum_items(prop, event_value_items);
1145         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1146         RNA_def_property_ui_text(prop, "Value",  "The type of event, only applies to some");
1147         
1148         prop= RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
1149         RNA_def_property_enum_sdna(prop, NULL, "type");
1150         RNA_def_property_enum_items(prop, event_type_items);
1151         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1152         RNA_def_property_ui_text(prop, "Type",  "");
1153
1154
1155         /* mouse */
1156         prop= RNA_def_property(srna, "mouse_x", PROP_INT, PROP_NONE);
1157         RNA_def_property_int_sdna(prop, NULL, "x");
1158         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1159         RNA_def_property_ui_text(prop, "Mouse X Position", "The window relative vertical location of the mouse");
1160         
1161         prop= RNA_def_property(srna, "mouse_y", PROP_INT, PROP_NONE);
1162         RNA_def_property_int_sdna(prop, NULL, "y");
1163         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1164         RNA_def_property_ui_text(prop, "Mouse Y Position", "The window relative horizontal location of the mouse");
1165
1166         prop= RNA_def_property(srna, "mouse_region_x", PROP_INT, PROP_NONE);
1167         RNA_def_property_int_sdna(prop, NULL, "mval[0]");
1168         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1169         RNA_def_property_ui_text(prop, "Mouse X Position", "The region relative vertical location of the mouse");
1170
1171         prop= RNA_def_property(srna, "mouse_region_y", PROP_INT, PROP_NONE);
1172         RNA_def_property_int_sdna(prop, NULL, "mval[1]");
1173         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1174         RNA_def_property_ui_text(prop, "Mouse Y Position", "The region relative horizontal location of the mouse");
1175         
1176         prop= RNA_def_property(srna, "mouse_prev_x", PROP_INT, PROP_NONE);
1177         RNA_def_property_int_sdna(prop, NULL, "prevx");
1178         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1179         RNA_def_property_ui_text(prop, "Mouse Previous X Position", "The window relative vertical location of the mouse");
1180         
1181         prop= RNA_def_property(srna, "mouse_prev_y", PROP_INT, PROP_NONE);
1182         RNA_def_property_int_sdna(prop, NULL, "prevy");
1183         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1184         RNA_def_property_ui_text(prop, "Mouse Previous Y Position", "The window relative horizontal location of the mouse");    
1185
1186
1187         /* modifiers */
1188         prop= RNA_def_property(srna, "shift", PROP_BOOLEAN, PROP_NONE);
1189         RNA_def_property_boolean_sdna(prop, NULL, "shift", 1);
1190         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1191         RNA_def_property_ui_text(prop, "Shift", "True when the Shift key is held");
1192         
1193         prop= RNA_def_property(srna, "ctrl", PROP_BOOLEAN, PROP_NONE);
1194         RNA_def_property_boolean_sdna(prop, NULL, "ctrl", 1);
1195         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1196         RNA_def_property_ui_text(prop, "Ctrl", "True when the Ctrl key is held");
1197         
1198         prop= RNA_def_property(srna, "alt", PROP_BOOLEAN, PROP_NONE);
1199         RNA_def_property_boolean_sdna(prop, NULL, "alt", 1);
1200         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1201         RNA_def_property_ui_text(prop, "Alt", "True when the Alt/Option key is held");
1202         
1203         prop= RNA_def_property(srna, "oskey", PROP_BOOLEAN, PROP_NONE);
1204         RNA_def_property_boolean_sdna(prop, NULL, "oskey", 1);
1205         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1206         RNA_def_property_ui_text(prop, "OS Key", "True when the Cmd key is held");
1207
1208         RNA_define_verify_sdna(1); // not in sdna
1209 }
1210
1211 static void rna_def_window(BlenderRNA *brna)
1212 {
1213         StructRNA *srna;
1214         PropertyRNA *prop;
1215
1216         srna= RNA_def_struct(brna, "Window", NULL);
1217         RNA_def_struct_ui_text(srna, "Window", "Open window");
1218         RNA_def_struct_sdna(srna, "wmWindow");
1219
1220         prop= RNA_def_property(srna, "screen", PROP_POINTER, PROP_NONE);
1221         RNA_def_property_flag(prop, PROP_NEVER_NULL);
1222         RNA_def_property_struct_type(prop, "Screen");
1223         RNA_def_property_ui_text(prop, "Screen", "Active screen showing in the window");
1224         RNA_def_property_flag(prop, PROP_EDITABLE);
1225         RNA_def_property_pointer_funcs(prop, NULL, "rna_Window_screen_set", NULL);
1226         RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
1227         RNA_def_property_update(prop, 0, "rna_Window_screen_update");
1228 }
1229
1230 static void rna_def_windowmanager(BlenderRNA *brna)
1231 {
1232         StructRNA *srna;
1233         PropertyRNA *prop;
1234
1235         srna= RNA_def_struct(brna, "WindowManager", "ID");
1236         RNA_def_struct_ui_text(srna, "Window Manager", "Window manager datablock defining open windows and other user interface data");
1237         RNA_def_struct_clear_flag(srna, STRUCT_ID_REFCOUNT);
1238         RNA_def_struct_sdna(srna, "wmWindowManager");
1239
1240         prop= RNA_def_property(srna, "operators", PROP_COLLECTION, PROP_NONE);
1241         RNA_def_property_struct_type(prop, "Operator");
1242         RNA_def_property_ui_text(prop, "Operators", "Operator registry");
1243
1244         prop= RNA_def_property(srna, "windows", PROP_COLLECTION, PROP_NONE);
1245         RNA_def_property_struct_type(prop, "Window");
1246         RNA_def_property_ui_text(prop, "Windows", "Open windows");
1247
1248         prop= RNA_def_property(srna, "keyconfigs", PROP_COLLECTION, PROP_NONE);
1249         RNA_def_property_struct_type(prop, "KeyConfig");
1250         RNA_def_property_ui_text(prop, "Key Configurations", "Registered key configurations");
1251
1252         prop= RNA_def_property(srna, "active_keyconfig", PROP_POINTER, PROP_NEVER_NULL);
1253         RNA_def_property_struct_type(prop, "KeyConfig");
1254         RNA_def_property_flag(prop, PROP_EDITABLE);
1255         RNA_def_property_pointer_funcs(prop, "rna_WindowManager_active_keyconfig_get", "rna_WindowManager_active_keyconfig_set", 0);
1256         RNA_def_property_ui_text(prop, "Active Key Configuration", "");
1257
1258         prop= RNA_def_property(srna, "default_keyconfig", PROP_POINTER, PROP_NEVER_NULL);
1259         RNA_def_property_pointer_sdna(prop, NULL, "defaultconf");
1260         RNA_def_property_struct_type(prop, "KeyConfig");
1261         RNA_def_property_ui_text(prop, "Default Key Configuration", "");
1262
1263         RNA_api_wm(srna);
1264 }
1265
1266 /* keyconfig.items */
1267 static void rna_def_keymap_items(BlenderRNA *brna, PropertyRNA *cprop)
1268 {
1269         StructRNA *srna;
1270 //      PropertyRNA *prop;
1271
1272         FunctionRNA *func;
1273         PropertyRNA *parm;
1274         
1275         RNA_def_property_srna(cprop, "KeyMapItems");
1276         srna= RNA_def_struct(brna, "KeyMapItems", NULL);
1277         RNA_def_struct_sdna(srna, "wmKeyMap");
1278         RNA_def_struct_ui_text(srna, "KeyMap Items", "Collection of keymap items");
1279
1280         func= RNA_def_function(srna, "add", "rna_KeyMap_add_item");
1281         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1282         parm= RNA_def_string(func, "idname", "", 0, "Operator Identifier", "");
1283         RNA_def_property_flag(parm, PROP_REQUIRED);
1284         parm= RNA_def_enum(func, "type", event_type_items, 0, "Type", "");
1285         RNA_def_property_flag(parm, PROP_REQUIRED);
1286         parm= RNA_def_enum(func, "value", event_value_items, 0, "Value", "");
1287         RNA_def_property_flag(parm, PROP_REQUIRED);
1288         RNA_def_boolean(func, "any", 0, "Any", "");
1289         RNA_def_boolean(func, "shift", 0, "Shift", "");
1290         RNA_def_boolean(func, "ctrl", 0, "Ctrl", "");
1291         RNA_def_boolean(func, "alt", 0, "Alt", "");
1292         RNA_def_boolean(func, "oskey", 0, "OS Key", "");
1293         RNA_def_enum(func, "key_modifier", event_type_items, 0, "Key Modifier", "");
1294         parm= RNA_def_pointer(func, "item", "KeyMapItem", "Item", "Added key map item.");
1295         RNA_def_function_return(func, parm);
1296
1297         func= RNA_def_function(srna, "add_modal", "rna_KeyMap_add_modal_item");
1298         RNA_def_function_flag(func, FUNC_USE_CONTEXT|FUNC_USE_REPORTS);
1299         parm= RNA_def_string(func, "propvalue", "", 0, "Property Value", "");
1300         RNA_def_property_flag(parm, PROP_REQUIRED);
1301         parm= RNA_def_enum(func, "type", event_type_items, 0, "Type", "");
1302         RNA_def_property_flag(parm, PROP_REQUIRED);
1303         parm= RNA_def_enum(func, "value", event_value_items, 0, "Value", "");
1304         RNA_def_property_flag(parm, PROP_REQUIRED);
1305         RNA_def_boolean(func, "any", 0, "Any", "");
1306         RNA_def_boolean(func, "shift", 0, "Shift", "");
1307         RNA_def_boolean(func, "ctrl", 0, "Ctrl", "");
1308         RNA_def_boolean(func, "alt", 0, "Alt", "");
1309         RNA_def_boolean(func, "oskey", 0, "OS Key", "");
1310         RNA_def_enum(func, "key_modifier", event_type_items, 0, "Key Modifier", "");
1311         parm= RNA_def_pointer(func, "item", "KeyMapItem", "Item", "Added key map item.");
1312         RNA_def_function_return(func, parm);
1313         
1314 }
1315
1316 static void rna_def_keyconfig(BlenderRNA *brna)
1317 {
1318         StructRNA *srna;
1319         // FunctionRNA *func;
1320         // PropertyRNA *parm;
1321         PropertyRNA *prop;
1322
1323         static EnumPropertyItem map_type_items[] = {
1324                 {KMI_TYPE_KEYBOARD, "KEYBOARD", 0, "Keyboard", ""},
1325                 {KMI_TYPE_TWEAK, "TWEAK", 0, "Tweak", ""},
1326                 {KMI_TYPE_MOUSE, "MOUSE", 0, "Mouse", ""},
1327                 {KMI_TYPE_TEXTINPUT, "TEXTINPUT", 0, "Text Input", ""},
1328                 {KMI_TYPE_TIMER, "TIMER", 0, "Timer", ""},
1329                 {0, NULL, 0, NULL, NULL}};
1330
1331         /* KeyConfig */
1332         srna= RNA_def_struct(brna, "KeyConfig", NULL);
1333         RNA_def_struct_sdna(srna, "wmKeyConfig");
1334         RNA_def_struct_ui_text(srna, "Key Configuration", "Input configuration, including keymaps");
1335
1336         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1337         RNA_def_property_string_sdna(prop, NULL, "idname");
1338         RNA_def_property_ui_text(prop, "Name", "Name of the key configuration");
1339         RNA_def_struct_name_property(srna, prop);
1340         
1341         prop= RNA_def_property(srna, "filter", PROP_STRING, PROP_NONE);
1342         RNA_def_property_string_sdna(prop, NULL, "filter");
1343         RNA_def_property_ui_text(prop, "Filter", "Search term for filtering in the UI");
1344
1345         prop= RNA_def_property(srna, "keymaps", PROP_COLLECTION, PROP_NONE);
1346         RNA_def_property_struct_type(prop, "KeyMap");
1347         RNA_def_property_ui_text(prop, "Key Maps", "Key maps configured as part of this configuration");
1348
1349         prop= RNA_def_property(srna, "user_defined", PROP_BOOLEAN, PROP_NONE);
1350         RNA_def_property_boolean_sdna(prop, NULL, "flag", KEYCONF_USER);
1351         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1352         RNA_def_property_ui_text(prop, "User Defined", "Indicates that a keyconfig was defined by the user");
1353
1354         RNA_api_keyconfig(srna);
1355
1356         /* KeyMap */
1357         srna= RNA_def_struct(brna, "KeyMap", NULL);
1358         RNA_def_struct_sdna(srna, "wmKeyMap");
1359         RNA_def_struct_ui_text(srna, "Key Map", "Input configuration, including keymaps");
1360
1361         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1362         RNA_def_property_string_sdna(prop, NULL, "idname");
1363         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1364         RNA_def_property_ui_text(prop, "Name", "Name of the key map");
1365         RNA_def_struct_name_property(srna, prop);
1366
1367         prop= RNA_def_property(srna, "space_type", PROP_ENUM, PROP_NONE);
1368         RNA_def_property_enum_sdna(prop, NULL, "spaceid");
1369         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1370         RNA_def_property_enum_items(prop, space_type_items);
1371         RNA_def_property_ui_text(prop, "Space Type", "Optional space type keymap is associated with");
1372
1373         prop= RNA_def_property(srna, "region_type", PROP_ENUM, PROP_NONE);
1374         RNA_def_property_enum_sdna(prop, NULL, "regionid");
1375         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1376         RNA_def_property_enum_items(prop, region_type_items);
1377         RNA_def_property_ui_text(prop, "Region Type", "Optional region type keymap is associated with");
1378
1379         prop= RNA_def_property(srna, "items", PROP_COLLECTION, PROP_NONE);
1380         RNA_def_property_struct_type(prop, "KeyMapItem");
1381         RNA_def_property_ui_text(prop, "Items", "Items in the keymap, linking an operator to an input event");
1382         rna_def_keymap_items(brna, prop);
1383
1384         prop= RNA_def_property(srna, "user_defined", PROP_BOOLEAN, PROP_NEVER_NULL);
1385         RNA_def_property_boolean_sdna(prop, NULL, "flag", KEYMAP_USER);
1386         RNA_def_property_ui_text(prop, "User Defined", "Keymap is defined by the user");
1387
1388         prop= RNA_def_property(srna, "modal", PROP_BOOLEAN, PROP_NONE);
1389         RNA_def_property_boolean_sdna(prop, NULL, "flag", KEYMAP_MODAL);
1390         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1391         RNA_def_property_ui_text(prop, "Modal Keymap", "Indicates that a keymap is used for translate modal events for an operator");
1392
1393         prop= RNA_def_property(srna, "items_expanded", PROP_BOOLEAN, PROP_NONE);
1394         RNA_def_property_boolean_sdna(prop, NULL, "flag", KEYMAP_EXPANDED);
1395         RNA_def_property_ui_text(prop, "Items Expanded", "Expanded in the user interface");
1396         RNA_def_property_ui_icon(prop, ICON_TRIA_RIGHT, 1);
1397         
1398         prop= RNA_def_property(srna, "children_expanded", PROP_BOOLEAN, PROP_NONE);
1399         RNA_def_property_boolean_sdna(prop, NULL, "flag", KEYMAP_CHILDREN_EXPANDED);
1400         RNA_def_property_ui_text(prop, "Children Expanded", "Children expanded in the user interface");
1401         RNA_def_property_ui_icon(prop, ICON_TRIA_RIGHT, 1);
1402
1403
1404         RNA_api_keymap(srna);
1405
1406         /* KeyMapItem */
1407         srna= RNA_def_struct(brna, "KeyMapItem", NULL);
1408         RNA_def_struct_sdna(srna, "wmKeyMapItem");
1409         RNA_def_struct_ui_text(srna, "Key Map Item", "Item in a Key Map");
1410
1411         prop= RNA_def_property(srna, "idname", PROP_STRING, PROP_NONE);
1412         RNA_def_property_string_sdna(prop, NULL, "idname");
1413         RNA_def_property_ui_text(prop, "Identifier", "Identifier of operator to call on input event");
1414         RNA_def_property_string_funcs(prop, "rna_wmKeyMapItem_idname_get", "rna_wmKeyMapItem_idname_length", "rna_wmKeyMapItem_idname_set");
1415         RNA_def_struct_name_property(srna, prop);
1416         
1417         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1418         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1419         RNA_def_property_ui_text(prop, "Name", "Name of operator to call on input event");
1420         RNA_def_property_string_funcs(prop, "rna_wmKeyMapItem_name_get", "rna_wmKeyMapItem_name_length", NULL);
1421         
1422         prop= RNA_def_property(srna, "properties", PROP_POINTER, PROP_NONE);
1423         RNA_def_property_struct_type(prop, "OperatorProperties");
1424         RNA_def_property_pointer_funcs(prop, "rna_KeyMapItem_properties_get", NULL, NULL);
1425         RNA_def_property_ui_text(prop, "Properties", "Properties to set when the operator is called");
1426
1427         prop= RNA_def_property(srna, "map_type", PROP_ENUM, PROP_NONE);
1428         RNA_def_property_enum_sdna(prop, NULL, "maptype");
1429         RNA_def_property_enum_items(prop, map_type_items);
1430         RNA_def_property_enum_funcs(prop, "rna_wmKeyMapItem_map_type_get", "rna_wmKeyMapItem_map_type_set", NULL);
1431         RNA_def_property_ui_text(prop, "Map Type", "Type of event mapping");
1432
1433         prop= RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
1434         RNA_def_property_enum_sdna(prop, NULL, "type");
1435         RNA_def_property_enum_items(prop, event_type_items);
1436         RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_KeyMapItem_type_itemf");
1437         RNA_def_property_ui_text(prop, "Type", "Type of event");
1438
1439         prop= RNA_def_property(srna, "value", PROP_ENUM, PROP_NONE);
1440         RNA_def_property_enum_sdna(prop, NULL, "val");
1441         RNA_def_property_enum_items(prop, event_value_items);
1442         RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_KeyMapItem_value_itemf");
1443         RNA_def_property_ui_text(prop, "Value", "");
1444
1445         prop= RNA_def_property(srna, "id", PROP_INT, PROP_NONE);
1446         RNA_def_property_int_sdna(prop, NULL, "id");
1447         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1448         RNA_def_property_ui_text(prop, "id", "ID of the item");
1449
1450         prop= RNA_def_property(srna, "any", PROP_BOOLEAN, PROP_NONE);
1451         RNA_def_property_boolean_funcs(prop, "rna_KeyMapItem_any_getf", "rna_KeyMapItem_any_setf");
1452         RNA_def_property_ui_text(prop, "Any", "Any modifier keys pressed");
1453
1454         prop= RNA_def_property(srna, "shift", PROP_BOOLEAN, PROP_NONE);
1455         RNA_def_property_boolean_sdna(prop, NULL, "shift", 0);
1456 //      RNA_def_property_enum_sdna(prop, NULL, "shift");
1457 //      RNA_def_property_enum_items(prop, keymap_modifiers_items);
1458         RNA_def_property_ui_text(prop, "Shift", "Shift key pressed");
1459
1460         prop= RNA_def_property(srna, "ctrl", PROP_BOOLEAN, PROP_NONE);
1461         RNA_def_property_boolean_sdna(prop, NULL, "ctrl", 0);
1462 //      RNA_def_property_enum_sdna(prop, NULL, "ctrl");
1463 //      RNA_def_property_enum_items(prop, keymap_modifiers_items);
1464         RNA_def_property_ui_text(prop, "Ctrl", "Control key pressed");
1465
1466         prop= RNA_def_property(srna, "alt", PROP_BOOLEAN, PROP_NONE);
1467         RNA_def_property_boolean_sdna(prop, NULL, "alt", 0);
1468 //      RNA_def_property_enum_sdna(prop, NULL, "alt");
1469 //      RNA_def_property_enum_items(prop, keymap_modifiers_items);
1470         RNA_def_property_ui_text(prop, "Alt", "Alt key pressed");
1471
1472         prop= RNA_def_property(srna, "oskey", PROP_BOOLEAN, PROP_NONE);
1473         RNA_def_property_boolean_sdna(prop, NULL, "oskey", 0);
1474 //      RNA_def_property_enum_sdna(prop, NULL, "oskey");
1475 //      RNA_def_property_enum_items(prop, keymap_modifiers_items);
1476         RNA_def_property_ui_text(prop, "OS Key", "Operating system key pressed");
1477
1478         prop= RNA_def_property(srna, "key_modifier", PROP_ENUM, PROP_NONE);
1479         RNA_def_property_enum_sdna(prop, NULL, "keymodifier");
1480         RNA_def_property_enum_items(prop, event_type_items);
1481         RNA_def_property_ui_text(prop, "Key Modifier", "Regular key pressed as a modifier");
1482
1483         prop= RNA_def_property(srna, "expanded", PROP_BOOLEAN, PROP_NONE);
1484         RNA_def_property_boolean_sdna(prop, NULL, "flag", KMI_EXPANDED);
1485         RNA_def_property_ui_text(prop, "Expanded", "Show key map event and property details in the user interface");
1486         RNA_def_property_ui_icon(prop, ICON_TRIA_RIGHT, 1);
1487
1488         prop= RNA_def_property(srna, "propvalue", PROP_ENUM, PROP_NONE);
1489         RNA_def_property_enum_sdna(prop, NULL, "propvalue");
1490         RNA_def_property_enum_items(prop, keymap_propvalue_items);
1491         RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_KeyMapItem_propvalue_itemf");
1492         RNA_def_property_ui_text(prop, "Property Value", "The value this event translates to in a modal keymap");
1493
1494         prop= RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
1495         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", KMI_INACTIVE);
1496         RNA_def_property_ui_text(prop, "Active", "Activate or deactivate item");
1497         RNA_def_property_ui_icon(prop, ICON_CHECKBOX_DEHLT, 1);
1498
1499         RNA_api_keymapitem(srna);
1500 }
1501
1502 void RNA_def_wm(BlenderRNA *brna)
1503 {
1504         rna_def_operator(brna);
1505         rna_def_operator_utils(brna);
1506         rna_def_operator_filelist_element(brna);
1507         rna_def_macro_operator(brna);
1508         rna_def_operator_type_macro(brna);
1509         rna_def_event(brna);
1510         rna_def_window(brna);
1511         rna_def_windowmanager(brna);
1512         rna_def_keyconfig(brna);
1513 }
1514
1515 #endif
1516