Fix #21641: crash when disabling active addon, removing operator
[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         /* update while blender is running */
616         if(C) {
617                 WM_operator_stack_clear((bContext*)C);
618                 WM_main_add_notifier(NC_SCREEN|NA_EDITED, NULL);
619         }
620
621         RNA_struct_free_extension(type, &ot->ext);
622
623         idname= ot->idname;
624         WM_operatortype_remove(ot->idname);
625         MEM_freeN(idname);
626
627         /* not to be confused with the RNA_struct_free that WM_operatortype_remove calls, they are 2 different srna's */
628         RNA_struct_free(&BLENDER_RNA, type);
629 }
630
631 static int operator_poll(bContext *C, wmOperatorType *ot)
632 {
633         PointerRNA ptr;
634         ParameterList list;
635         FunctionRNA *func;
636         void *ret;
637         int visible;
638
639         RNA_pointer_create(NULL, ot->ext.srna, NULL, &ptr); /* dummy */
640         func= RNA_struct_find_function(&ptr, "poll");
641
642         RNA_parameter_list_create(&list, &ptr, func);
643         RNA_parameter_set_lookup(&list, "context", &C);
644         ot->ext.call(&ptr, func, &list);
645
646         RNA_parameter_get_lookup(&list, "visible", &ret);
647         visible= *(int*)ret;
648
649         RNA_parameter_list_free(&list);
650
651         return visible;
652 }
653
654 static int operator_exec(bContext *C, wmOperator *op)
655 {
656         PointerRNA opr;
657         ParameterList list;
658         FunctionRNA *func;
659         void *ret;
660         int result;
661
662         RNA_pointer_create(&CTX_wm_screen(C)->id, op->type->ext.srna, op, &opr);
663         func= RNA_struct_find_function(&opr, "execute");
664
665         RNA_parameter_list_create(&list, &opr, func);
666         RNA_parameter_set_lookup(&list, "context", &C);
667         op->type->ext.call(&opr, func, &list);
668
669         RNA_parameter_get_lookup(&list, "result", &ret);
670         result= *(int*)ret;
671
672         RNA_parameter_list_free(&list);
673
674         return result;
675 }
676
677 static int operator_invoke(bContext *C, wmOperator *op, wmEvent *event)
678 {
679         PointerRNA opr;
680         ParameterList list;
681         FunctionRNA *func;
682         void *ret;
683         int result;
684
685         RNA_pointer_create(&CTX_wm_screen(C)->id, op->type->ext.srna, op, &opr);
686         func= RNA_struct_find_function(&opr, "invoke");
687
688         RNA_parameter_list_create(&list, &opr, func);
689         RNA_parameter_set_lookup(&list, "context", &C);
690         RNA_parameter_set_lookup(&list, "event", &event);
691         op->type->ext.call(&opr, func, &list);
692
693         RNA_parameter_get_lookup(&list, "result", &ret);
694         result= *(int*)ret;
695
696         RNA_parameter_list_free(&list);
697
698         return result;
699 }
700
701 /* same as invoke */
702 static int operator_modal(bContext *C, wmOperator *op, wmEvent *event)
703 {
704         PointerRNA opr;
705         ParameterList list;
706         FunctionRNA *func;
707         void *ret;
708         int result;
709
710         RNA_pointer_create(&CTX_wm_screen(C)->id, op->type->ext.srna, op, &opr);
711         func= RNA_struct_find_function(&opr, "modal");
712
713         RNA_parameter_list_create(&list, &opr, func);
714         RNA_parameter_set_lookup(&list, "context", &C);
715         RNA_parameter_set_lookup(&list, "event", &event);
716         op->type->ext.call(&opr, func, &list);
717
718         RNA_parameter_get_lookup(&list, "result", &ret);
719         result= *(int*)ret;
720
721         RNA_parameter_list_free(&list);
722
723         return result;
724 }
725
726 static void operator_draw(bContext *C, wmOperator *op)
727 {
728         PointerRNA opr;
729         ParameterList list;
730         FunctionRNA *func;
731
732         RNA_pointer_create(&CTX_wm_screen(C)->id, op->type->ext.srna, op, &opr);
733         func= RNA_struct_find_function(&opr, "draw");
734
735         RNA_parameter_list_create(&list, &opr, func);
736         RNA_parameter_set_lookup(&list, "context", &C);
737         op->type->ext.call(&opr, func, &list);
738
739         RNA_parameter_list_free(&list);
740 }
741
742 #ifndef DISABLE_PYTHON
743 void operator_wrapper(wmOperatorType *ot, void *userdata);
744 void macro_wrapper(wmOperatorType *ot, void *userdata);
745
746 static char _operator_idname[OP_MAX_TYPENAME];
747 static char _operator_name[OP_MAX_TYPENAME];
748 static char _operator_descr[1024];
749 static StructRNA *rna_Operator_register(const bContext *C, ReportList *reports, void *data, const char *identifier, StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
750 {
751         wmOperatorType dummyot = {0};
752         wmOperator dummyop= {0};
753         PointerRNA dummyotr;
754         int have_function[5];
755
756         /* setup dummy operator & operator type to store static properties in */
757         dummyop.type= &dummyot;
758         dummyot.idname= _operator_idname; /* only assigne the pointer, string is NULL'd */
759         dummyot.name= _operator_name; /* only assigne the pointer, string is NULL'd */
760         dummyot.description= _operator_descr; /* only assigne the pointer, string is NULL'd */
761         RNA_pointer_create(NULL, &RNA_Operator, &dummyop, &dummyotr);
762
763         /* validate the python class */
764         if(validate(&dummyotr, data, have_function) != 0)
765                 return NULL;
766
767         {       /* convert foo.bar to FOO_OT_bar
768                  * allocate the description and the idname in 1 go */
769                 int idlen = strlen(_operator_idname) + 4;
770                 int namelen = strlen(_operator_name) + 1;
771                 int desclen = strlen(_operator_descr) + 1;
772                 char *ch, *ch_arr;
773                 ch_arr= ch= MEM_callocN(sizeof(char) * (idlen + namelen + desclen), "_operator_idname"); /* 2 terminators and 3 to convert a.b -> A_OT_b */
774                 WM_operator_bl_idname(ch, _operator_idname); /* convert the idname from python */
775                 dummyot.idname= ch;
776                 ch += idlen;
777                 strcpy(ch, _operator_name);
778                 dummyot.name = ch;
779                 ch += namelen;
780                 strcpy(ch, _operator_descr);
781                 dummyot.description = ch;
782         }
783
784         if(strlen(identifier) >= sizeof(dummyop.idname)) {
785                 BKE_reportf(reports, RPT_ERROR, "registering operator class: '%s' is too long, maximum length is %d.", identifier, sizeof(dummyop.idname));
786                 return NULL;
787         }
788
789         /* check if we have registered this operator type before, and remove it */
790         {
791                 wmOperatorType *ot= WM_operatortype_exists(dummyot.idname);
792                 if(ot && ot->ext.srna)
793                         rna_Operator_unregister(C, ot->ext.srna);
794         }
795
796         /* create a new menu type */
797         dummyot.ext.srna= RNA_def_struct(&BLENDER_RNA, dummyot.idname, "Operator");
798         dummyot.ext.data= data;
799         dummyot.ext.call= call;
800         dummyot.ext.free= free;
801
802         dummyot.pyop_poll=      (have_function[0])? operator_poll: NULL;
803         dummyot.exec=           (have_function[1])? operator_exec: NULL;
804         dummyot.invoke=         (have_function[2])? operator_invoke: NULL;
805         dummyot.modal=          (have_function[3])? operator_modal: NULL;
806         dummyot.ui=                     (have_function[4])? operator_draw: NULL;
807
808         WM_operatortype_append_ptr(operator_wrapper, (void *)&dummyot);
809
810         /* update while blender is running */
811         if(C)
812                 WM_main_add_notifier(NC_SCREEN|NA_EDITED, NULL);
813
814         return dummyot.ext.srna;
815 }
816
817
818 static StructRNA *rna_MacroOperator_register(const bContext *C, ReportList *reports, void *data, const char *identifier, StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
819 {
820         wmOperatorType dummyot = {0};
821         wmOperator dummyop= {0};
822         PointerRNA dummyotr;
823         int have_function[4];
824
825         /* setup dummy operator & operator type to store static properties in */
826         dummyop.type= &dummyot;
827         dummyot.idname= _operator_idname; /* only assigne the pointer, string is NULL'd */
828         dummyot.name= _operator_name; /* only assigne the pointer, string is NULL'd */
829         dummyot.description= _operator_descr; /* only assigne the pointer, string is NULL'd */
830         RNA_pointer_create(NULL, &RNA_Macro, &dummyop, &dummyotr);
831
832         /* validate the python class */
833         if(validate(&dummyotr, data, have_function) != 0)
834                 return NULL;
835
836         {       /* convert foo.bar to FOO_OT_bar
837                  * allocate the description and the idname in 1 go */
838                 int idlen = strlen(_operator_idname) + 4;
839                 int namelen = strlen(_operator_name) + 1;
840                 int desclen = strlen(_operator_descr) + 1;
841                 char *ch, *ch_arr;
842                 ch_arr= ch= MEM_callocN(sizeof(char) * (idlen + namelen + desclen), "_operator_idname"); /* 2 terminators and 3 to convert a.b -> A_OT_b */
843                 WM_operator_bl_idname(ch, _operator_idname); /* convert the idname from python */
844                 dummyot.idname= ch;
845                 ch += idlen;
846                 strcpy(ch, _operator_name);
847                 dummyot.name = ch;
848                 ch += namelen;
849                 strcpy(ch, _operator_descr);
850                 dummyot.description = ch;
851         }
852
853         if(strlen(identifier) >= sizeof(dummyop.idname)) {
854                 BKE_reportf(reports, RPT_ERROR, "registering operator class: '%s' is too long, maximum length is %d.", identifier, sizeof(dummyop.idname));
855                 return NULL;
856         }
857
858         /* check if we have registered this operator type before, and remove it */
859         {
860                 wmOperatorType *ot= WM_operatortype_exists(dummyot.idname);
861                 if(ot && ot->ext.srna)
862                         rna_Operator_unregister(C, ot->ext.srna);
863         }
864
865         /* create a new menu type */
866         dummyot.ext.srna= RNA_def_struct(&BLENDER_RNA, dummyot.idname, "Operator");
867         dummyot.ext.data= data;
868         dummyot.ext.call= call;
869         dummyot.ext.free= free;
870
871         dummyot.pyop_poll=      (have_function[0])? operator_poll: NULL;
872         dummyot.ui=                     (have_function[3])? operator_draw: NULL;
873
874         WM_operatortype_append_macro_ptr(macro_wrapper, (void *)&dummyot);
875
876         /* update while blender is running */
877         if(C)
878                 WM_main_add_notifier(NC_SCREEN|NA_EDITED, NULL);
879
880         return dummyot.ext.srna;
881 }
882 #endif
883
884 static StructRNA* rna_Operator_refine(PointerRNA *opr)
885 {
886         wmOperator *op= (wmOperator*)opr->data;
887         return (op->type && op->type->ext.srna)? op->type->ext.srna: &RNA_Operator;
888 }
889
890 static StructRNA* rna_MacroOperator_refine(PointerRNA *opr)
891 {
892         wmOperator *op= (wmOperator*)opr->data;
893         return (op->type && op->type->ext.srna)? op->type->ext.srna: &RNA_Macro;
894 }
895
896 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)
897 {
898 //      wmWindowManager *wm = CTX_wm_manager(C);
899         int modifier= 0;
900
901         /* only on non-modal maps */
902         if (km->flag & KEYMAP_MODAL) {
903                 BKE_report(reports, RPT_ERROR, "Not a non-modal keymap.");
904                 return NULL;
905         }
906
907         if(shift) modifier |= KM_SHIFT;
908         if(ctrl) modifier |= KM_CTRL;
909         if(alt) modifier |= KM_ALT;
910         if(oskey) modifier |= KM_OSKEY;
911
912         if(any) modifier = KM_ANY;
913
914         return WM_keymap_add_item(km, idname, type, value, modifier, keymodifier);
915 }
916
917 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)
918 {
919         wmWindowManager *wm = CTX_wm_manager(C);
920         int modifier= 0;
921         int propvalue = 0;
922
923         /* only modal maps */
924         if ((km->flag & KEYMAP_MODAL) == 0) {
925                 BKE_report(reports, RPT_ERROR, "Not a modal keymap.");
926                 return NULL;
927         }
928
929         if (!km->modal_items) {
930                 if(!WM_keymap_user_init(wm, km)) {
931                         BKE_report(reports, RPT_ERROR, "User defined keymap doesn't correspond to a system keymap.");
932                         return NULL;
933                 }
934         }
935
936         if (!km->modal_items) {
937                 BKE_report(reports, RPT_ERROR, "No property values defined.");
938                 return NULL;
939         }
940
941
942         if(RNA_enum_value_from_id(km->modal_items, propvalue_str, &propvalue)==0) {
943                 BKE_report(reports, RPT_WARNING, "Property value not in enumeration.");
944         }
945
946         if(shift) modifier |= KM_SHIFT;
947         if(ctrl) modifier |= KM_CTRL;
948         if(alt) modifier |= KM_ALT;
949         if(oskey) modifier |= KM_OSKEY;
950
951         if(any) modifier = KM_ANY;
952
953         return WM_modalkeymap_add_item(km, type, value, modifier, keymodifier, propvalue);
954 }
955
956 #else
957
958 static void rna_def_operator(BlenderRNA *brna)
959 {
960         StructRNA *srna;
961         PropertyRNA *prop;
962
963         srna= RNA_def_struct(brna, "Operator", NULL);
964         RNA_def_struct_ui_text(srna, "Operator", "Storage of an operator being executed, or registered after execution");
965         RNA_def_struct_sdna(srna, "wmOperator");
966         RNA_def_struct_refine_func(srna, "rna_Operator_refine");
967 #ifndef DISABLE_PYTHON
968         RNA_def_struct_register_funcs(srna, "rna_Operator_register", "rna_Operator_unregister");
969 #endif
970
971         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
972         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
973         RNA_def_property_string_funcs(prop, "rna_Operator_name_get", "rna_Operator_name_length", NULL);
974         RNA_def_property_ui_text(prop, "Name", "");
975         RNA_def_struct_name_property(srna, prop);
976
977         prop= RNA_def_property(srna, "properties", PROP_POINTER, PROP_NONE);
978         RNA_def_property_flag(prop, PROP_NEVER_NULL);
979         RNA_def_property_struct_type(prop, "OperatorProperties");
980         RNA_def_property_ui_text(prop, "Properties", "");
981         RNA_def_property_pointer_funcs(prop, "rna_Operator_properties_get", NULL, NULL);
982         
983         prop= RNA_def_property(srna, "has_reports", PROP_BOOLEAN, PROP_NONE);
984         RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* this is 'virtual' property */
985         RNA_def_property_boolean_funcs(prop, "rna_Operator_has_reports_get", NULL);
986         RNA_def_property_ui_text(prop, "Has Reports", "Operator has a set of reports (warnings and errors) from last execution");
987         
988         prop= RNA_def_property(srna, "layout", PROP_POINTER, PROP_NONE);
989         RNA_def_property_struct_type(prop, "UILayout");
990
991         /* Registration */
992         prop= RNA_def_property(srna, "bl_idname", PROP_STRING, PROP_NONE);
993         RNA_def_property_string_sdna(prop, NULL, "type->idname");
994         RNA_def_property_string_maxlength(prop, OP_MAX_TYPENAME); /* else it uses the pointer size! */
995         RNA_def_property_flag(prop, PROP_REGISTER);
996
997         prop= RNA_def_property(srna, "bl_label", PROP_STRING, PROP_NONE);
998         RNA_def_property_string_sdna(prop, NULL, "type->name");
999         RNA_def_property_string_maxlength(prop, 1024); /* else it uses the pointer size! */
1000         RNA_def_property_flag(prop, PROP_REGISTER);
1001
1002         prop= RNA_def_property(srna, "bl_description", PROP_STRING, PROP_NONE);
1003         RNA_def_property_string_sdna(prop, NULL, "type->description");
1004         RNA_def_property_string_maxlength(prop, 1024); /* else it uses the pointer size! */
1005         RNA_def_property_flag(prop, PROP_REGISTER);
1006
1007         prop= RNA_def_property(srna, "bl_options", PROP_ENUM, PROP_NONE);
1008         RNA_def_property_enum_sdna(prop, NULL, "type->flag");
1009         RNA_def_property_enum_items(prop, operator_flag_items);
1010         RNA_def_property_flag(prop, PROP_REGISTER_OPTIONAL|PROP_ENUM_FLAG);
1011         RNA_def_property_ui_text(prop, "Options",  "Options for this operator type");
1012
1013         RNA_api_operator(srna);
1014
1015         srna= RNA_def_struct(brna, "OperatorProperties", NULL);
1016         RNA_def_struct_ui_text(srna, "Operator Properties", "Input properties of an Operator");
1017         RNA_def_struct_refine_func(srna, "rna_OperatorProperties_refine");
1018         RNA_def_struct_idproperties_func(srna, "rna_OperatorProperties_idproperties");
1019 }
1020
1021 static void rna_def_macro_operator(BlenderRNA *brna)
1022 {
1023         StructRNA *srna;
1024         PropertyRNA *prop;
1025
1026         srna= RNA_def_struct(brna, "Macro", NULL);
1027         RNA_def_struct_ui_text(srna, "Macro Operator", "Storage of a macro operator being executed, or registered after execution");
1028         RNA_def_struct_sdna(srna, "wmOperator");
1029         RNA_def_struct_refine_func(srna, "rna_MacroOperator_refine");
1030 #ifndef DISABLE_PYTHON
1031         RNA_def_struct_register_funcs(srna, "rna_MacroOperator_register", "rna_Operator_unregister");
1032 #endif
1033     
1034         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1035         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1036         RNA_def_property_string_funcs(prop, "rna_Operator_name_get", "rna_Operator_name_length", NULL);
1037         RNA_def_property_ui_text(prop, "Name", "");
1038         RNA_def_struct_name_property(srna, prop);
1039
1040         prop= RNA_def_property(srna, "properties", PROP_POINTER, PROP_NONE);
1041         RNA_def_property_flag(prop, PROP_NEVER_NULL);
1042         RNA_def_property_struct_type(prop, "OperatorProperties");
1043         RNA_def_property_ui_text(prop, "Properties", "");
1044         RNA_def_property_pointer_funcs(prop, "rna_Operator_properties_get", NULL, NULL);
1045
1046         /* Registration */
1047         prop= RNA_def_property(srna, "bl_idname", PROP_STRING, PROP_NONE);
1048         RNA_def_property_string_sdna(prop, NULL, "type->idname");
1049         RNA_def_property_string_maxlength(prop, OP_MAX_TYPENAME); /* else it uses the pointer size! */
1050         RNA_def_property_flag(prop, PROP_REGISTER);
1051
1052         prop= RNA_def_property(srna, "bl_label", PROP_STRING, PROP_NONE);
1053         RNA_def_property_string_sdna(prop, NULL, "type->name");
1054         RNA_def_property_string_maxlength(prop, 1024); /* else it uses the pointer size! */
1055         RNA_def_property_flag(prop, PROP_REGISTER);
1056
1057         prop= RNA_def_property(srna, "bl_description", PROP_STRING, PROP_NONE);
1058         RNA_def_property_string_sdna(prop, NULL, "type->description");
1059         RNA_def_property_string_maxlength(prop, 1024); /* else it uses the pointer size! */
1060         RNA_def_property_flag(prop, PROP_REGISTER);
1061
1062         prop= RNA_def_property(srna, "bl_options", PROP_ENUM, PROP_NONE);
1063         RNA_def_property_enum_sdna(prop, NULL, "type->flag");
1064         RNA_def_property_enum_items(prop, operator_flag_items);
1065         RNA_def_property_flag(prop, PROP_REGISTER_OPTIONAL|PROP_ENUM_FLAG);
1066         RNA_def_property_ui_text(prop, "Options",  "Options for this operator type");
1067
1068         RNA_api_macro(srna);
1069 }
1070
1071 static void rna_def_operator_type_macro(BlenderRNA *brna)
1072 {
1073         StructRNA *srna;
1074         PropertyRNA *prop;
1075
1076         srna= RNA_def_struct(brna, "OperatorTypeMacro", NULL);
1077         RNA_def_struct_ui_text(srna, "OperatorTypeMacro", "Storage of a sub operator in a macro after it has been added");
1078         RNA_def_struct_sdna(srna, "wmOperatorTypeMacro");
1079
1080 //      prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1081 //      RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1082 //      RNA_def_property_string_sdna(prop, NULL, "idname");
1083 //      RNA_def_property_ui_text(prop, "Name", "Name of the sub operator");
1084 //      RNA_def_struct_name_property(srna, prop);
1085
1086         prop= RNA_def_property(srna, "properties", PROP_POINTER, PROP_NONE);
1087         RNA_def_property_flag(prop, PROP_NEVER_NULL);
1088         RNA_def_property_struct_type(prop, "OperatorProperties");
1089         RNA_def_property_ui_text(prop, "Properties", "");
1090         RNA_def_property_pointer_funcs(prop, "rna_OperatorTypeMacro_properties_get", NULL, NULL);
1091 }
1092
1093 static void rna_def_operator_utils(BlenderRNA *brna)
1094 {
1095         StructRNA *srna;
1096         PropertyRNA *prop;
1097
1098         srna= RNA_def_struct(brna, "OperatorMousePath", "IDPropertyGroup");
1099         RNA_def_struct_ui_text(srna, "Operator Mouse Path", "Mouse path values for operators that record such paths");
1100
1101         prop= RNA_def_property(srna, "loc", PROP_FLOAT, PROP_XYZ);
1102         RNA_def_property_flag(prop, PROP_IDPROPERTY);
1103         RNA_def_property_array(prop, 2);
1104         RNA_def_property_ui_text(prop, "Location", "Mouse location");
1105
1106         prop= RNA_def_property(srna, "time", PROP_FLOAT, PROP_NONE);
1107         RNA_def_property_flag(prop, PROP_IDPROPERTY);
1108         RNA_def_property_ui_text(prop, "Time", "Time of mouse location");
1109 }
1110
1111 static void rna_def_operator_filelist_element(BlenderRNA *brna)
1112 {
1113         StructRNA *srna;
1114         PropertyRNA *prop;
1115
1116         srna= RNA_def_struct(brna, "OperatorFileListElement", "IDPropertyGroup");
1117         RNA_def_struct_ui_text(srna, "Operator File List Element", "");
1118         
1119         
1120         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1121         RNA_def_property_flag(prop, PROP_IDPROPERTY);
1122         RNA_def_property_ui_text(prop, "Name", "the name of a file or directory within a file list");
1123 }
1124         
1125 static void rna_def_event(BlenderRNA *brna)
1126 {
1127         StructRNA *srna;
1128         PropertyRNA *prop;
1129         
1130         srna= RNA_def_struct(brna, "Event", NULL);
1131         RNA_def_struct_ui_text(srna, "Event", "Window Manager Event");
1132         RNA_def_struct_sdna(srna, "wmEvent");
1133
1134         RNA_define_verify_sdna(0); // not in sdna
1135
1136         /* strings */
1137         prop= RNA_def_property(srna, "ascii", PROP_STRING, PROP_NONE);
1138         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1139         RNA_def_property_string_funcs(prop, "rna_Event_ascii_get", "rna_Event_ascii_length", NULL);
1140         RNA_def_property_ui_text(prop, "ASCII", "Single ASCII character for this event");
1141
1142
1143         /* enums */
1144         prop= RNA_def_property(srna, "value", PROP_ENUM, PROP_NONE);
1145         RNA_def_property_enum_sdna(prop, NULL, "val");
1146         RNA_def_property_enum_items(prop, event_value_items);
1147         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1148         RNA_def_property_ui_text(prop, "Value",  "The type of event, only applies to some");
1149         
1150         prop= RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
1151         RNA_def_property_enum_sdna(prop, NULL, "type");
1152         RNA_def_property_enum_items(prop, event_type_items);
1153         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1154         RNA_def_property_ui_text(prop, "Type",  "");
1155
1156
1157         /* mouse */
1158         prop= RNA_def_property(srna, "mouse_x", PROP_INT, PROP_NONE);
1159         RNA_def_property_int_sdna(prop, NULL, "x");
1160         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1161         RNA_def_property_ui_text(prop, "Mouse X Position", "The window relative vertical location of the mouse");
1162         
1163         prop= RNA_def_property(srna, "mouse_y", PROP_INT, PROP_NONE);
1164         RNA_def_property_int_sdna(prop, NULL, "y");
1165         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1166         RNA_def_property_ui_text(prop, "Mouse Y Position", "The window relative horizontal location of the mouse");
1167
1168         prop= RNA_def_property(srna, "mouse_region_x", PROP_INT, PROP_NONE);
1169         RNA_def_property_int_sdna(prop, NULL, "mval[0]");
1170         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1171         RNA_def_property_ui_text(prop, "Mouse X Position", "The region relative vertical location of the mouse");
1172
1173         prop= RNA_def_property(srna, "mouse_region_y", PROP_INT, PROP_NONE);
1174         RNA_def_property_int_sdna(prop, NULL, "mval[1]");
1175         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1176         RNA_def_property_ui_text(prop, "Mouse Y Position", "The region relative horizontal location of the mouse");
1177         
1178         prop= RNA_def_property(srna, "mouse_prev_x", PROP_INT, PROP_NONE);
1179         RNA_def_property_int_sdna(prop, NULL, "prevx");
1180         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1181         RNA_def_property_ui_text(prop, "Mouse Previous X Position", "The window relative vertical location of the mouse");
1182         
1183         prop= RNA_def_property(srna, "mouse_prev_y", PROP_INT, PROP_NONE);
1184         RNA_def_property_int_sdna(prop, NULL, "prevy");
1185         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1186         RNA_def_property_ui_text(prop, "Mouse Previous Y Position", "The window relative horizontal location of the mouse");    
1187
1188
1189         /* modifiers */
1190         prop= RNA_def_property(srna, "shift", PROP_BOOLEAN, PROP_NONE);
1191         RNA_def_property_boolean_sdna(prop, NULL, "shift", 1);
1192         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1193         RNA_def_property_ui_text(prop, "Shift", "True when the Shift key is held");
1194         
1195         prop= RNA_def_property(srna, "ctrl", PROP_BOOLEAN, PROP_NONE);
1196         RNA_def_property_boolean_sdna(prop, NULL, "ctrl", 1);
1197         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1198         RNA_def_property_ui_text(prop, "Ctrl", "True when the Ctrl key is held");
1199         
1200         prop= RNA_def_property(srna, "alt", PROP_BOOLEAN, PROP_NONE);
1201         RNA_def_property_boolean_sdna(prop, NULL, "alt", 1);
1202         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1203         RNA_def_property_ui_text(prop, "Alt", "True when the Alt/Option key is held");
1204         
1205         prop= RNA_def_property(srna, "oskey", PROP_BOOLEAN, PROP_NONE);
1206         RNA_def_property_boolean_sdna(prop, NULL, "oskey", 1);
1207         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1208         RNA_def_property_ui_text(prop, "OS Key", "True when the Cmd key is held");
1209
1210         RNA_define_verify_sdna(1); // not in sdna
1211 }
1212
1213 static void rna_def_window(BlenderRNA *brna)
1214 {
1215         StructRNA *srna;
1216         PropertyRNA *prop;
1217
1218         srna= RNA_def_struct(brna, "Window", NULL);
1219         RNA_def_struct_ui_text(srna, "Window", "Open window");
1220         RNA_def_struct_sdna(srna, "wmWindow");
1221
1222         prop= RNA_def_property(srna, "screen", PROP_POINTER, PROP_NONE);
1223         RNA_def_property_flag(prop, PROP_NEVER_NULL);
1224         RNA_def_property_struct_type(prop, "Screen");
1225         RNA_def_property_ui_text(prop, "Screen", "Active screen showing in the window");
1226         RNA_def_property_flag(prop, PROP_EDITABLE);
1227         RNA_def_property_pointer_funcs(prop, NULL, "rna_Window_screen_set", NULL);
1228         RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
1229         RNA_def_property_update(prop, 0, "rna_Window_screen_update");
1230 }
1231
1232 static void rna_def_windowmanager(BlenderRNA *brna)
1233 {
1234         StructRNA *srna;
1235         PropertyRNA *prop;
1236
1237         srna= RNA_def_struct(brna, "WindowManager", "ID");
1238         RNA_def_struct_ui_text(srna, "Window Manager", "Window manager datablock defining open windows and other user interface data");
1239         RNA_def_struct_clear_flag(srna, STRUCT_ID_REFCOUNT);
1240         RNA_def_struct_sdna(srna, "wmWindowManager");
1241
1242         prop= RNA_def_property(srna, "operators", PROP_COLLECTION, PROP_NONE);
1243         RNA_def_property_struct_type(prop, "Operator");
1244         RNA_def_property_ui_text(prop, "Operators", "Operator registry");
1245
1246         prop= RNA_def_property(srna, "windows", PROP_COLLECTION, PROP_NONE);
1247         RNA_def_property_struct_type(prop, "Window");
1248         RNA_def_property_ui_text(prop, "Windows", "Open windows");
1249
1250         prop= RNA_def_property(srna, "keyconfigs", PROP_COLLECTION, PROP_NONE);
1251         RNA_def_property_struct_type(prop, "KeyConfig");
1252         RNA_def_property_ui_text(prop, "Key Configurations", "Registered key configurations");
1253
1254         prop= RNA_def_property(srna, "active_keyconfig", PROP_POINTER, PROP_NEVER_NULL);
1255         RNA_def_property_struct_type(prop, "KeyConfig");
1256         RNA_def_property_flag(prop, PROP_EDITABLE);
1257         RNA_def_property_pointer_funcs(prop, "rna_WindowManager_active_keyconfig_get", "rna_WindowManager_active_keyconfig_set", 0);
1258         RNA_def_property_ui_text(prop, "Active Key Configuration", "");
1259
1260         prop= RNA_def_property(srna, "default_keyconfig", PROP_POINTER, PROP_NEVER_NULL);
1261         RNA_def_property_pointer_sdna(prop, NULL, "defaultconf");
1262         RNA_def_property_struct_type(prop, "KeyConfig");
1263         RNA_def_property_ui_text(prop, "Default Key Configuration", "");
1264
1265         RNA_api_wm(srna);
1266 }
1267
1268 /* keyconfig.items */
1269 static void rna_def_keymap_items(BlenderRNA *brna, PropertyRNA *cprop)
1270 {
1271         StructRNA *srna;
1272 //      PropertyRNA *prop;
1273
1274         FunctionRNA *func;
1275         PropertyRNA *parm;
1276         
1277         RNA_def_property_srna(cprop, "KeyMapItems");
1278         srna= RNA_def_struct(brna, "KeyMapItems", NULL);
1279         RNA_def_struct_sdna(srna, "wmKeyMap");
1280         RNA_def_struct_ui_text(srna, "KeyMap Items", "Collection of keymap items");
1281
1282         func= RNA_def_function(srna, "add", "rna_KeyMap_add_item");
1283         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1284         parm= RNA_def_string(func, "idname", "", 0, "Operator Identifier", "");
1285         RNA_def_property_flag(parm, PROP_REQUIRED);
1286         parm= RNA_def_enum(func, "type", event_type_items, 0, "Type", "");
1287         RNA_def_property_flag(parm, PROP_REQUIRED);
1288         parm= RNA_def_enum(func, "value", event_value_items, 0, "Value", "");
1289         RNA_def_property_flag(parm, PROP_REQUIRED);
1290         RNA_def_boolean(func, "any", 0, "Any", "");
1291         RNA_def_boolean(func, "shift", 0, "Shift", "");
1292         RNA_def_boolean(func, "ctrl", 0, "Ctrl", "");
1293         RNA_def_boolean(func, "alt", 0, "Alt", "");
1294         RNA_def_boolean(func, "oskey", 0, "OS Key", "");
1295         RNA_def_enum(func, "key_modifier", event_type_items, 0, "Key Modifier", "");
1296         parm= RNA_def_pointer(func, "item", "KeyMapItem", "Item", "Added key map item.");
1297         RNA_def_function_return(func, parm);
1298
1299         func= RNA_def_function(srna, "add_modal", "rna_KeyMap_add_modal_item");
1300         RNA_def_function_flag(func, FUNC_USE_CONTEXT|FUNC_USE_REPORTS);
1301         parm= RNA_def_string(func, "propvalue", "", 0, "Property Value", "");
1302         RNA_def_property_flag(parm, PROP_REQUIRED);
1303         parm= RNA_def_enum(func, "type", event_type_items, 0, "Type", "");
1304         RNA_def_property_flag(parm, PROP_REQUIRED);
1305         parm= RNA_def_enum(func, "value", event_value_items, 0, "Value", "");
1306         RNA_def_property_flag(parm, PROP_REQUIRED);
1307         RNA_def_boolean(func, "any", 0, "Any", "");
1308         RNA_def_boolean(func, "shift", 0, "Shift", "");
1309         RNA_def_boolean(func, "ctrl", 0, "Ctrl", "");
1310         RNA_def_boolean(func, "alt", 0, "Alt", "");
1311         RNA_def_boolean(func, "oskey", 0, "OS Key", "");
1312         RNA_def_enum(func, "key_modifier", event_type_items, 0, "Key Modifier", "");
1313         parm= RNA_def_pointer(func, "item", "KeyMapItem", "Item", "Added key map item.");
1314         RNA_def_function_return(func, parm);
1315         
1316 }
1317
1318 static void rna_def_keyconfig(BlenderRNA *brna)
1319 {
1320         StructRNA *srna;
1321         // FunctionRNA *func;
1322         // PropertyRNA *parm;
1323         PropertyRNA *prop;
1324
1325         static EnumPropertyItem map_type_items[] = {
1326                 {KMI_TYPE_KEYBOARD, "KEYBOARD", 0, "Keyboard", ""},
1327                 {KMI_TYPE_TWEAK, "TWEAK", 0, "Tweak", ""},
1328                 {KMI_TYPE_MOUSE, "MOUSE", 0, "Mouse", ""},
1329                 {KMI_TYPE_TEXTINPUT, "TEXTINPUT", 0, "Text Input", ""},
1330                 {KMI_TYPE_TIMER, "TIMER", 0, "Timer", ""},
1331                 {0, NULL, 0, NULL, NULL}};
1332
1333         /* KeyConfig */
1334         srna= RNA_def_struct(brna, "KeyConfig", NULL);
1335         RNA_def_struct_sdna(srna, "wmKeyConfig");
1336         RNA_def_struct_ui_text(srna, "Key Configuration", "Input configuration, including keymaps");
1337
1338         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1339         RNA_def_property_string_sdna(prop, NULL, "idname");
1340         RNA_def_property_ui_text(prop, "Name", "Name of the key configuration");
1341         RNA_def_struct_name_property(srna, prop);
1342         
1343         prop= RNA_def_property(srna, "filter", PROP_STRING, PROP_NONE);
1344         RNA_def_property_string_sdna(prop, NULL, "filter");
1345         RNA_def_property_ui_text(prop, "Filter", "Search term for filtering in the UI");
1346
1347         prop= RNA_def_property(srna, "keymaps", PROP_COLLECTION, PROP_NONE);
1348         RNA_def_property_struct_type(prop, "KeyMap");
1349         RNA_def_property_ui_text(prop, "Key Maps", "Key maps configured as part of this configuration");
1350
1351         prop= RNA_def_property(srna, "user_defined", PROP_BOOLEAN, PROP_NONE);
1352         RNA_def_property_boolean_sdna(prop, NULL, "flag", KEYCONF_USER);
1353         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1354         RNA_def_property_ui_text(prop, "User Defined", "Indicates that a keyconfig was defined by the user");
1355
1356         RNA_api_keyconfig(srna);
1357
1358         /* KeyMap */
1359         srna= RNA_def_struct(brna, "KeyMap", NULL);
1360         RNA_def_struct_sdna(srna, "wmKeyMap");
1361         RNA_def_struct_ui_text(srna, "Key Map", "Input configuration, including keymaps");
1362
1363         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1364         RNA_def_property_string_sdna(prop, NULL, "idname");
1365         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1366         RNA_def_property_ui_text(prop, "Name", "Name of the key map");
1367         RNA_def_struct_name_property(srna, prop);
1368
1369         prop= RNA_def_property(srna, "space_type", PROP_ENUM, PROP_NONE);
1370         RNA_def_property_enum_sdna(prop, NULL, "spaceid");
1371         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1372         RNA_def_property_enum_items(prop, space_type_items);
1373         RNA_def_property_ui_text(prop, "Space Type", "Optional space type keymap is associated with");
1374
1375         prop= RNA_def_property(srna, "region_type", PROP_ENUM, PROP_NONE);
1376         RNA_def_property_enum_sdna(prop, NULL, "regionid");
1377         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1378         RNA_def_property_enum_items(prop, region_type_items);
1379         RNA_def_property_ui_text(prop, "Region Type", "Optional region type keymap is associated with");
1380
1381         prop= RNA_def_property(srna, "items", PROP_COLLECTION, PROP_NONE);
1382         RNA_def_property_struct_type(prop, "KeyMapItem");
1383         RNA_def_property_ui_text(prop, "Items", "Items in the keymap, linking an operator to an input event");
1384         rna_def_keymap_items(brna, prop);
1385
1386         prop= RNA_def_property(srna, "user_defined", PROP_BOOLEAN, PROP_NEVER_NULL);
1387         RNA_def_property_boolean_sdna(prop, NULL, "flag", KEYMAP_USER);
1388         RNA_def_property_ui_text(prop, "User Defined", "Keymap is defined by the user");
1389
1390         prop= RNA_def_property(srna, "modal", PROP_BOOLEAN, PROP_NONE);
1391         RNA_def_property_boolean_sdna(prop, NULL, "flag", KEYMAP_MODAL);
1392         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1393         RNA_def_property_ui_text(prop, "Modal Keymap", "Indicates that a keymap is used for translate modal events for an operator");
1394
1395         prop= RNA_def_property(srna, "items_expanded", PROP_BOOLEAN, PROP_NONE);
1396         RNA_def_property_boolean_sdna(prop, NULL, "flag", KEYMAP_EXPANDED);
1397         RNA_def_property_ui_text(prop, "Items Expanded", "Expanded in the user interface");
1398         RNA_def_property_ui_icon(prop, ICON_TRIA_RIGHT, 1);
1399         
1400         prop= RNA_def_property(srna, "children_expanded", PROP_BOOLEAN, PROP_NONE);
1401         RNA_def_property_boolean_sdna(prop, NULL, "flag", KEYMAP_CHILDREN_EXPANDED);
1402         RNA_def_property_ui_text(prop, "Children Expanded", "Children expanded in the user interface");
1403         RNA_def_property_ui_icon(prop, ICON_TRIA_RIGHT, 1);
1404
1405
1406         RNA_api_keymap(srna);
1407
1408         /* KeyMapItem */
1409         srna= RNA_def_struct(brna, "KeyMapItem", NULL);
1410         RNA_def_struct_sdna(srna, "wmKeyMapItem");
1411         RNA_def_struct_ui_text(srna, "Key Map Item", "Item in a Key Map");
1412
1413         prop= RNA_def_property(srna, "idname", PROP_STRING, PROP_NONE);
1414         RNA_def_property_string_sdna(prop, NULL, "idname");
1415         RNA_def_property_ui_text(prop, "Identifier", "Identifier of operator to call on input event");
1416         RNA_def_property_string_funcs(prop, "rna_wmKeyMapItem_idname_get", "rna_wmKeyMapItem_idname_length", "rna_wmKeyMapItem_idname_set");
1417         RNA_def_struct_name_property(srna, prop);
1418         
1419         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1420         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1421         RNA_def_property_ui_text(prop, "Name", "Name of operator to call on input event");
1422         RNA_def_property_string_funcs(prop, "rna_wmKeyMapItem_name_get", "rna_wmKeyMapItem_name_length", NULL);
1423         
1424         prop= RNA_def_property(srna, "properties", PROP_POINTER, PROP_NONE);
1425         RNA_def_property_struct_type(prop, "OperatorProperties");
1426         RNA_def_property_pointer_funcs(prop, "rna_KeyMapItem_properties_get", NULL, NULL);
1427         RNA_def_property_ui_text(prop, "Properties", "Properties to set when the operator is called");
1428
1429         prop= RNA_def_property(srna, "map_type", PROP_ENUM, PROP_NONE);
1430         RNA_def_property_enum_sdna(prop, NULL, "maptype");
1431         RNA_def_property_enum_items(prop, map_type_items);
1432         RNA_def_property_enum_funcs(prop, "rna_wmKeyMapItem_map_type_get", "rna_wmKeyMapItem_map_type_set", NULL);
1433         RNA_def_property_ui_text(prop, "Map Type", "Type of event mapping");
1434
1435         prop= RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
1436         RNA_def_property_enum_sdna(prop, NULL, "type");
1437         RNA_def_property_enum_items(prop, event_type_items);
1438         RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_KeyMapItem_type_itemf");
1439         RNA_def_property_ui_text(prop, "Type", "Type of event");
1440
1441         prop= RNA_def_property(srna, "value", PROP_ENUM, PROP_NONE);
1442         RNA_def_property_enum_sdna(prop, NULL, "val");
1443         RNA_def_property_enum_items(prop, event_value_items);
1444         RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_KeyMapItem_value_itemf");
1445         RNA_def_property_ui_text(prop, "Value", "");
1446
1447         prop= RNA_def_property(srna, "id", PROP_INT, PROP_NONE);
1448         RNA_def_property_int_sdna(prop, NULL, "id");
1449         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1450         RNA_def_property_ui_text(prop, "id", "ID of the item");
1451
1452         prop= RNA_def_property(srna, "any", PROP_BOOLEAN, PROP_NONE);
1453         RNA_def_property_boolean_funcs(prop, "rna_KeyMapItem_any_getf", "rna_KeyMapItem_any_setf");
1454         RNA_def_property_ui_text(prop, "Any", "Any modifier keys pressed");
1455
1456         prop= RNA_def_property(srna, "shift", PROP_BOOLEAN, PROP_NONE);
1457         RNA_def_property_boolean_sdna(prop, NULL, "shift", 0);
1458 //      RNA_def_property_enum_sdna(prop, NULL, "shift");
1459 //      RNA_def_property_enum_items(prop, keymap_modifiers_items);
1460         RNA_def_property_ui_text(prop, "Shift", "Shift key pressed");
1461
1462         prop= RNA_def_property(srna, "ctrl", PROP_BOOLEAN, PROP_NONE);
1463         RNA_def_property_boolean_sdna(prop, NULL, "ctrl", 0);
1464 //      RNA_def_property_enum_sdna(prop, NULL, "ctrl");
1465 //      RNA_def_property_enum_items(prop, keymap_modifiers_items);
1466         RNA_def_property_ui_text(prop, "Ctrl", "Control key pressed");
1467
1468         prop= RNA_def_property(srna, "alt", PROP_BOOLEAN, PROP_NONE);
1469         RNA_def_property_boolean_sdna(prop, NULL, "alt", 0);
1470 //      RNA_def_property_enum_sdna(prop, NULL, "alt");
1471 //      RNA_def_property_enum_items(prop, keymap_modifiers_items);
1472         RNA_def_property_ui_text(prop, "Alt", "Alt key pressed");
1473
1474         prop= RNA_def_property(srna, "oskey", PROP_BOOLEAN, PROP_NONE);
1475         RNA_def_property_boolean_sdna(prop, NULL, "oskey", 0);
1476 //      RNA_def_property_enum_sdna(prop, NULL, "oskey");
1477 //      RNA_def_property_enum_items(prop, keymap_modifiers_items);
1478         RNA_def_property_ui_text(prop, "OS Key", "Operating system key pressed");
1479
1480         prop= RNA_def_property(srna, "key_modifier", PROP_ENUM, PROP_NONE);
1481         RNA_def_property_enum_sdna(prop, NULL, "keymodifier");
1482         RNA_def_property_enum_items(prop, event_type_items);
1483         RNA_def_property_ui_text(prop, "Key Modifier", "Regular key pressed as a modifier");
1484
1485         prop= RNA_def_property(srna, "expanded", PROP_BOOLEAN, PROP_NONE);
1486         RNA_def_property_boolean_sdna(prop, NULL, "flag", KMI_EXPANDED);
1487         RNA_def_property_ui_text(prop, "Expanded", "Show key map event and property details in the user interface");
1488         RNA_def_property_ui_icon(prop, ICON_TRIA_RIGHT, 1);
1489
1490         prop= RNA_def_property(srna, "propvalue", PROP_ENUM, PROP_NONE);
1491         RNA_def_property_enum_sdna(prop, NULL, "propvalue");
1492         RNA_def_property_enum_items(prop, keymap_propvalue_items);
1493         RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_KeyMapItem_propvalue_itemf");
1494         RNA_def_property_ui_text(prop, "Property Value", "The value this event translates to in a modal keymap");
1495
1496         prop= RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
1497         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", KMI_INACTIVE);
1498         RNA_def_property_ui_text(prop, "Active", "Activate or deactivate item");
1499         RNA_def_property_ui_icon(prop, ICON_CHECKBOX_DEHLT, 1);
1500
1501         RNA_api_keymapitem(srna);
1502 }
1503
1504 void RNA_def_wm(BlenderRNA *brna)
1505 {
1506         rna_def_operator(brna);
1507         rna_def_operator_utils(brna);
1508         rna_def_operator_filelist_element(brna);
1509         rna_def_macro_operator(brna);
1510         rna_def_operator_type_macro(brna);
1511         rna_def_event(brna);
1512         rna_def_window(brna);
1513         rna_def_windowmanager(brna);
1514         rna_def_keyconfig(brna);
1515 }
1516
1517 #endif
1518