Adding support for the "media" play/pause/stop/next/prev buttons
[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 */
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         {INBETWEEN_MOUSEMOVE, "INBETWEEN_MOUSEMOVE", 0, "Inbetween Move", ""},
118         {MOUSEPAN, "TRACKPADPAN", 0, "Mouse/Trackpad Pan", ""},
119         {MOUSEZOOM, "TRACKPADZOOM", 0, "Mouse/Trackpad Zoom", ""},
120         {MOUSEROTATE, "MOUSEROTATE", 0, "Mouse/Trackpad Rotate", ""},
121         {0, "", 0, NULL, NULL},
122         {WHEELUPMOUSE, "WHEELUPMOUSE", 0, "Wheel Up", ""},
123         {WHEELDOWNMOUSE, "WHEELDOWNMOUSE", 0, "Wheel Down", ""},
124         {WHEELINMOUSE, "WHEELINMOUSE", 0, "Wheel In", ""},
125         {WHEELOUTMOUSE, "WHEELOUTMOUSE", 0, "Wheel Out", ""},
126         {0, "", 0, NULL, NULL},
127         {EVT_TWEAK_L, "EVT_TWEAK_L", 0, "Tweak Left", ""},
128         {EVT_TWEAK_M, "EVT_TWEAK_M", 0, "Tweak Middle", ""},
129         {EVT_TWEAK_R, "EVT_TWEAK_R", 0, "Tweak Right", ""},
130         {EVT_TWEAK_A, "EVT_TWEAK_A", 0, "Tweak Action", ""},
131         {EVT_TWEAK_S, "EVT_TWEAK_S", 0, "Tweak Select", ""},
132         {0, "", 0, NULL, NULL},
133         {AKEY, "A", 0, "A", ""},
134         {BKEY, "B", 0, "B", ""},
135         {CKEY, "C", 0, "C", ""},
136         {DKEY, "D", 0, "D", ""},
137         {EKEY, "E", 0, "E", ""},
138         {FKEY, "F", 0, "F", ""},
139         {GKEY, "G", 0, "G", ""},
140         {HKEY, "H", 0, "H", ""},
141         {IKEY, "I", 0, "I", ""},
142         {JKEY, "J", 0, "J", ""},
143         {KKEY, "K", 0, "K", ""},
144         {LKEY, "L", 0, "L", ""},
145         {MKEY, "M", 0, "M", ""},
146         {NKEY, "N", 0, "N", ""},
147         {OKEY, "O", 0, "O", ""},
148         {PKEY, "P", 0, "P", ""},
149         {QKEY, "Q", 0, "Q", ""},
150         {RKEY, "R", 0, "R", ""},
151         {SKEY, "S", 0, "S", ""},
152         {TKEY, "T", 0, "T", ""},
153         {UKEY, "U", 0, "U", ""},
154         {VKEY, "V", 0, "V", ""},
155         {WKEY, "W", 0, "W", ""},
156         {XKEY, "X", 0, "X", ""},
157         {YKEY, "Y", 0, "Y", ""},
158         {ZKEY, "Z", 0, "Z", ""},
159         {0, "", 0, NULL, NULL},
160         {ZEROKEY, "ZERO",       0, "0", ""},
161         {ONEKEY, "ONE",         0, "1", ""},
162         {TWOKEY, "TWO",         0, "2", ""},
163         {THREEKEY, "THREE",     0, "3", ""},
164         {FOURKEY, "FOUR",       0, "4", ""},
165         {FIVEKEY, "FIVE",       0, "5", ""},
166         {SIXKEY, "SIX",         0, "6", ""},
167         {SEVENKEY, "SEVEN",     0, "7", ""},
168         {EIGHTKEY, "EIGHT",     0, "8", ""},
169         {NINEKEY, "NINE",       0, "9", ""},
170         {0, "", 0, NULL, NULL},
171         {LEFTCTRLKEY,   "LEFT_CTRL",    0, "Left Ctrl", ""},
172         {LEFTALTKEY,    "LEFT_ALT",             0, "Left Alt", ""},
173         {LEFTSHIFTKEY,  "LEFT_SHIFT",   0, "Left Shift", ""},
174         {RIGHTALTKEY,   "RIGHT_ALT",    0, "Right Alt", ""},
175         {RIGHTCTRLKEY,  "RIGHT_CTRL",   0, "Right Ctrl", ""},
176         {RIGHTSHIFTKEY, "RIGHT_SHIFT",  0, "Right Shift", ""},
177         {0, "", 0, NULL, NULL},
178         {OSKEY, "OSKEY",        0, "OS Key", ""},
179         {GRLESSKEY,     "GRLESS",       0, "Grless", ""},
180         {ESCKEY, "ESC", 0, "Esc", ""},
181         {TABKEY, "TAB", 0, "Tab", ""},
182         {RETKEY, "RET", 0, "Return", ""},
183         {SPACEKEY, "SPACE", 0, "Spacebar", ""},
184         {LINEFEEDKEY, "LINE_FEED", 0, "Line Feed", ""},
185         {BACKSPACEKEY, "BACK_SPACE", 0, "Back Space", ""},
186         {DELKEY, "DEL", 0, "Delete", ""},
187         {SEMICOLONKEY, "SEMI_COLON", 0, ";", ""},
188         {PERIODKEY, "PERIOD", 0, ".", ""},
189         {COMMAKEY, "COMMA", 0, ",", ""},
190         {QUOTEKEY, "QUOTE", 0, "\"", ""},
191         {ACCENTGRAVEKEY, "ACCENT_GRAVE", 0, "`", ""},
192         {MINUSKEY, "MINUS", 0, "-", ""},
193         {SLASHKEY, "SLASH", 0, "/", ""},
194         {BACKSLASHKEY, "BACK_SLASH", 0, "\\", ""},
195         {EQUALKEY, "EQUAL", 0, "=", ""},
196         {LEFTBRACKETKEY, "LEFT_BRACKET", 0, "[", ""},
197         {RIGHTBRACKETKEY, "RIGHT_BRACKET", 0, "]", ""},
198         {LEFTARROWKEY, "LEFT_ARROW", 0, "Left Arrow", ""},
199         {DOWNARROWKEY, "DOWN_ARROW", 0, "Down Arrow", ""},
200         {RIGHTARROWKEY, "RIGHT_ARROW", 0, "Right Arrow", ""},
201         {UPARROWKEY, "UP_ARROW", 0, "Up Arrow", ""},
202         {PAD2, "NUMPAD_2", 0, "Numpad 2", ""},
203         {PAD4, "NUMPAD_4", 0, "Numpad 4", ""},
204         {PAD6, "NUMPAD_6", 0, "Numpad 6", ""},
205         {PAD8, "NUMPAD_8", 0, "Numpad 8", ""},
206         {PAD1, "NUMPAD_1", 0, "Numpad 1", ""},
207         {PAD3, "NUMPAD_3", 0, "Numpad 3", ""},
208         {PAD5, "NUMPAD_5", 0, "Numpad 5", ""},
209         {PAD7, "NUMPAD_7", 0, "Numpad 7", ""},
210         {PAD9, "NUMPAD_9", 0, "Numpad 9", ""},
211         {PADPERIOD, "NUMPAD_PERIOD", 0, "Numpad .", ""},
212         {PADSLASHKEY, "NUMPAD_SLASH", 0, "Numpad /", ""},
213         {PADASTERKEY, "NUMPAD_ASTERIX", 0, "Numpad *", ""},
214         {PAD0, "NUMPAD_0", 0, "Numpad 0", ""},
215         {PADMINUS, "NUMPAD_MINUS", 0, "Numpad -", ""},
216         {PADENTER, "NUMPAD_ENTER", 0, "Numpad Enter", ""},
217         {PADPLUSKEY, "NUMPAD_PLUS", 0, "Numpad +", ""},
218         {F1KEY, "F1", 0, "F1", ""},
219         {F2KEY, "F2", 0, "F2", ""},
220         {F3KEY, "F3", 0, "F3", ""},
221         {F4KEY, "F4", 0, "F4", ""},
222         {F5KEY, "F5", 0, "F5", ""},
223         {F6KEY, "F6", 0, "F6", ""},
224         {F7KEY, "F7", 0, "F7", ""},
225         {F8KEY, "F8", 0, "F8", ""},
226         {F9KEY, "F9", 0, "F9", ""},
227         {F10KEY, "F10", 0, "F10", ""},
228         {F11KEY, "F11", 0, "F11", ""},
229         {F12KEY, "F12", 0, "F12", ""},
230         {F13KEY, "F13", 0, "F13", ""},
231         {F14KEY, "F14", 0, "F14", ""},
232         {F15KEY, "F15", 0, "F15", ""},
233         {F16KEY, "F16", 0, "F16", ""},
234         {F17KEY, "F17", 0, "F17", ""},
235         {F18KEY, "F18", 0, "F18", ""},
236         {F19KEY, "F19", 0, "F19", ""},
237         {PAUSEKEY, "PAUSE", 0, "Pause", ""},
238         {INSERTKEY, "INSERT", 0, "Insert", ""},
239         {HOMEKEY, "HOME", 0, "Home", ""},
240         {PAGEUPKEY, "PAGE_UP", 0, "Page Up", ""},
241         {PAGEDOWNKEY, "PAGE_DOWN", 0, "Page Down", ""},
242         {ENDKEY, "END", 0, "End", ""},
243         {0, "", 0, NULL, NULL},
244         {MEDIAPLAY, "MEDIA_PLAY", 0, "Media Play/Pause", ""},
245         {MEDIASTOP, "MEDIA_STOP", 0, "Media Stop", ""},
246         {MEDIAFIRST, "MEDIA_FIRST", 0, "Media First", ""},
247         {MEDIALAST, "MEDIA_LAST", 0, "Media Last", ""},
248         {0, "", 0, NULL, NULL},
249         {WINDEACTIVATE, "WINDOW_DEACTIVATE", 0, "Window Deactivate", ""},
250         {TIMER, "TIMER", 0, "Timer", ""},
251         {TIMER0, "TIMER0", 0, "Timer 0", ""},
252         {TIMER1, "TIMER1", 0, "Timer 1", ""},
253         {TIMER2, "TIMER2", 0, "Timer 2", ""},
254         {0, NULL, 0, NULL, NULL}};      
255
256 EnumPropertyItem keymap_propvalue_items[] = {
257                 {0, "NONE", 0, "", ""},
258                 {0, NULL, 0, NULL, NULL}};
259
260 EnumPropertyItem keymap_modifiers_items[] = {
261                 {KM_ANY, "ANY", 0, "Any", ""},
262                 {0, "NONE", 0, "None", ""},
263                 {1, "FIRST", 0, "First", ""},
264                 {2, "SECOND", 0, "Second", ""},
265                 {0, NULL, 0, NULL, NULL}};
266
267 EnumPropertyItem operator_flag_items[] = {
268                 {OPTYPE_REGISTER, "REGISTER", 0, "Register", ""},
269                 {OPTYPE_UNDO, "UNDO", 0, "Undo", ""},
270                 {OPTYPE_BLOCKING, "BLOCKING", 0, "Finished", ""},
271                 {OPTYPE_MACRO, "MACRO", 0, "Macro", ""},
272                 {OPTYPE_GRAB_POINTER, "GRAB_POINTER", 0, "Grab Pointer", ""},
273                 {OPTYPE_PRESET, "PRESET", 0, "Preset", ""},
274                 {0, NULL, 0, NULL, NULL}};
275
276 EnumPropertyItem operator_return_items[] = {
277                 {OPERATOR_RUNNING_MODAL, "RUNNING_MODAL", 0, "Running Modal", ""},
278                 {OPERATOR_CANCELLED, "CANCELLED", 0, "Cancelled", ""},
279                 {OPERATOR_FINISHED, "FINISHED", 0, "Finished", ""},
280                 {OPERATOR_PASS_THROUGH, "PASS_THROUGH", 0, "Pass Through", ""}, // used as a flag
281                 {0, NULL, 0, NULL, NULL}};
282
283 /* flag/enum */
284 EnumPropertyItem wm_report_items[] = {
285                 {RPT_DEBUG, "DEBUG", 0, "Debug", ""},
286                 {RPT_INFO, "INFO", 0, "Info", ""},
287                 {RPT_OPERATOR, "OPERATOR", 0, "Operator", ""},
288                 {RPT_WARNING, "WARNING", 0, "Warning", ""},
289                 {RPT_ERROR, "ERROR", 0, "Error", ""},
290                 {RPT_ERROR_INVALID_INPUT, "ERROR_INVALID_INPUT", 0, "Invalid Input", ""},\
291                 {RPT_ERROR_INVALID_CONTEXT, "ERROR_INVALID_CONTEXT", 0, "Invalid Context", ""},
292                 {RPT_ERROR_OUT_OF_MEMORY, "ERROR_OUT_OF_MEMORY", 0, "Out of Memory", ""},
293                 {0, NULL, 0, NULL, NULL}};
294
295 #define KMI_TYPE_KEYBOARD       0
296 #define KMI_TYPE_MOUSE          1
297 #define KMI_TYPE_TWEAK          2
298 #define KMI_TYPE_TEXTINPUT      3
299 #define KMI_TYPE_TIMER          4
300
301 #ifdef RNA_RUNTIME
302
303 #include <assert.h>
304
305 #include "WM_api.h"
306
307 #include "BKE_idprop.h"
308
309 #include "MEM_guardedalloc.h"
310
311 static wmOperator *rna_OperatorProperties_find_operator(PointerRNA *ptr)
312 {
313         wmWindowManager *wm= ptr->id.data;
314         IDProperty *properties= (IDProperty*)ptr->data;
315         wmOperator *op;
316
317         if(wm)
318                 for(op=wm->operators.first; op; op=op->next)
319                         if(op->properties == properties)
320                                 return op;
321         
322         return NULL;
323 }
324
325 static StructRNA *rna_OperatorProperties_refine(PointerRNA *ptr)
326 {
327         wmOperator *op= rna_OperatorProperties_find_operator(ptr);
328
329         if(op)
330                 return op->type->srna;
331         else
332                 return ptr->type;
333 }
334
335 static IDProperty *rna_OperatorProperties_idprops(PointerRNA *ptr, int create)
336 {
337         if(create && !ptr->data) {
338                 IDPropertyTemplate val = {0};
339                 ptr->data= IDP_New(IDP_GROUP, val, "RNA_OperatorProperties group");
340         }
341
342         return ptr->data;
343 }
344
345 static void rna_Operator_name_get(PointerRNA *ptr, char *value)
346 {
347         wmOperator *op= (wmOperator*)ptr->data;
348         strcpy(value, op->type->name);
349 }
350
351 static int rna_Operator_name_length(PointerRNA *ptr)
352 {
353         wmOperator *op= (wmOperator*)ptr->data;
354         return strlen(op->type->name);
355 }
356
357 static int rna_Operator_has_reports_get(PointerRNA *ptr)
358 {
359         wmOperator *op= (wmOperator*)ptr->data;
360         return (op->reports && op->reports->list.first);
361 }
362
363 static PointerRNA rna_Operator_properties_get(PointerRNA *ptr)
364 {
365         wmOperator *op= (wmOperator*)ptr->data;
366         return rna_pointer_inherit_refine(ptr, op->type->srna, op->properties);
367 }
368
369 static PointerRNA rna_OperatorTypeMacro_properties_get(PointerRNA *ptr)
370 {
371         wmOperatorTypeMacro *otmacro= (wmOperatorTypeMacro*)ptr->data;
372         wmOperatorType *ot = WM_operatortype_find(otmacro->idname, TRUE);
373         return rna_pointer_inherit_refine(ptr, ot->srna, otmacro->properties);
374 }
375
376 static void rna_Event_ascii_get(PointerRNA *ptr, char *value)
377 {
378         wmEvent *event= (wmEvent*)ptr->id.data;
379         value[0]= event->ascii;
380         value[1]= '\0';
381 }
382
383 static int rna_Event_ascii_length(PointerRNA *ptr)
384 {
385         wmEvent *event= (wmEvent*)ptr->id.data;
386         return (event->ascii)? 1 : 0;
387 }
388
389 static void rna_Window_screen_set(PointerRNA *ptr, PointerRNA value)
390 {
391         wmWindow *win= (wmWindow*)ptr->data;
392
393         if(value.data == NULL)
394                 return;
395
396         /* exception: can't set screens inside of area/region handers */
397         win->newscreen= value.data;
398 }
399
400 static void rna_Window_screen_update(bContext *C, PointerRNA *ptr)
401 {
402         wmWindow *win= (wmWindow*)ptr->data;
403
404         /* exception: can't set screens inside of area/region handers */
405         if(win->newscreen) {
406                 WM_event_add_notifier(C, NC_SCREEN|ND_SCREENBROWSE, win->newscreen);
407                 win->newscreen= NULL;
408         }
409 }
410
411 static PointerRNA rna_KeyMapItem_properties_get(PointerRNA *ptr)
412 {
413         wmKeyMapItem *kmi= ptr->data;
414
415         if(kmi->ptr)
416                 return *(kmi->ptr);
417         
418         //return rna_pointer_inherit_refine(ptr, &RNA_OperatorProperties, op->properties);
419         return PointerRNA_NULL;
420 }
421
422 static int rna_wmKeyMapItem_map_type_get(PointerRNA *ptr)
423 {
424         wmKeyMapItem *kmi= ptr->data;
425
426         if(ISTIMER(kmi->type)) return KMI_TYPE_TIMER;
427         if(ISKEYBOARD(kmi->type)) return KMI_TYPE_KEYBOARD;
428         if(ISTWEAK(kmi->type)) return KMI_TYPE_TWEAK;
429         if(ISMOUSE(kmi->type)) return KMI_TYPE_MOUSE;
430         if(kmi->type == KM_TEXTINPUT) return KMI_TYPE_TEXTINPUT;
431         return KMI_TYPE_KEYBOARD;
432 }
433
434 static void rna_wmKeyMapItem_map_type_set(PointerRNA *ptr, int value)
435 {
436         wmKeyMapItem *kmi= ptr->data;
437         int map_type= rna_wmKeyMapItem_map_type_get(ptr);
438
439         if(value != map_type) {
440                 switch(value) {
441                 case KMI_TYPE_KEYBOARD:
442                         kmi->type= AKEY;
443                         kmi->val= KM_PRESS;
444                         break;
445                 case KMI_TYPE_TWEAK:
446                         kmi->type= EVT_TWEAK_L;
447                         kmi->val= KM_ANY;
448                         break;
449                 case KMI_TYPE_MOUSE:
450                         kmi->type= LEFTMOUSE;
451                         kmi->val= KM_PRESS;
452                         break;
453                 case KMI_TYPE_TEXTINPUT:
454                         kmi->type= KM_TEXTINPUT;
455                         kmi->val= KM_NOTHING;
456                         break;
457                 case KMI_TYPE_TIMER:
458                         kmi->type= TIMER;
459                         kmi->val= KM_NOTHING;
460                         break;
461                 }
462         }
463 }
464
465 static EnumPropertyItem *rna_KeyMapItem_type_itemf(bContext *C, PointerRNA *ptr, int *free)
466 {
467         int map_type= rna_wmKeyMapItem_map_type_get(ptr);
468
469         if(map_type == KMI_TYPE_MOUSE) return event_mouse_type_items;
470         if(map_type == KMI_TYPE_TWEAK) return event_tweak_type_items;
471         if(map_type == KMI_TYPE_TIMER) return event_timer_type_items;
472         else return event_type_items;
473 }
474
475 static EnumPropertyItem *rna_KeyMapItem_value_itemf(bContext *C, PointerRNA *ptr, int *free)
476 {
477         int map_type= rna_wmKeyMapItem_map_type_get(ptr);
478
479         if(map_type == KMI_TYPE_MOUSE || map_type == KMI_TYPE_KEYBOARD) return event_keymouse_value_items;
480         if(map_type == KMI_TYPE_TWEAK) return event_tweak_value_items;
481         else return event_value_items;
482 }
483
484 static EnumPropertyItem *rna_KeyMapItem_propvalue_itemf(bContext *C, PointerRNA *ptr, int *free)
485 {
486         wmWindowManager *wm = CTX_wm_manager(C);
487         wmKeyConfig *kc;
488         wmKeyMap *km;
489
490         /* check user keymaps */
491         for(km=U.keymaps.first; km; km=km->next) {
492                 wmKeyMapItem *kmi;
493                 for (kmi=km->items.first; kmi; kmi=kmi->next) {
494                         if (kmi == ptr->data) {
495                                 if (!km->modal_items) {
496                                         if (!WM_keymap_user_init(wm, km)) {
497                                                 return keymap_propvalue_items; /* ERROR */
498                                         }
499                                 }
500
501                                 return km->modal_items;
502                         }
503                 }
504         }
505
506         for(kc=wm->keyconfigs.first; kc; kc=kc->next) {
507                 for(km=kc->keymaps.first; km; km=km->next) {
508                         /* only check if it's a modal keymap */
509                         if (km->modal_items) {
510                                 wmKeyMapItem *kmi;
511                                 for (kmi=km->items.first; kmi; kmi=kmi->next) {
512                                         if (kmi == ptr->data) {
513                                                 return km->modal_items;
514                                         }
515                                 }
516                         }
517                 }
518         }
519
520
521         return keymap_propvalue_items; /* ERROR */
522 }
523
524 static int rna_KeyMapItem_any_getf(PointerRNA *ptr)
525 {
526         wmKeyMapItem *kmi = (wmKeyMapItem*)ptr->data;
527
528         if (kmi->shift == KM_ANY &&
529                 kmi->ctrl == KM_ANY &&
530                 kmi->alt == KM_ANY &&
531                 kmi->oskey == KM_ANY)
532
533                 return 1;
534         else
535                 return 0;
536 }
537
538 static void rna_KeyMapItem_any_setf(PointerRNA *ptr, int value)
539 {
540         wmKeyMapItem *kmi = (wmKeyMapItem*)ptr->data;
541
542         if(value) {
543                 kmi->shift= kmi->ctrl= kmi->alt= kmi->oskey= KM_ANY;
544         }
545         else {
546                 kmi->shift= kmi->ctrl= kmi->alt= kmi->oskey= 0;
547         }
548 }
549
550
551 static PointerRNA rna_WindowManager_active_keyconfig_get(PointerRNA *ptr)
552 {
553         wmWindowManager *wm= ptr->data;
554         wmKeyConfig *kc;
555
556         for(kc=wm->keyconfigs.first; kc; kc=kc->next)
557                 if(strcmp(kc->idname, U.keyconfigstr) == 0)
558                         break;
559         
560         if(!kc)
561                 kc= wm->defaultconf;
562         
563         return rna_pointer_inherit_refine(ptr, &RNA_KeyConfig, kc);
564 }
565
566 static void rna_WindowManager_active_keyconfig_set(PointerRNA *ptr, PointerRNA value)
567 {
568         wmKeyConfig *kc= value.data;
569
570         if(kc)
571                 BLI_strncpy(U.keyconfigstr, kc->idname, sizeof(U.keyconfigstr));
572 }
573
574 static void rna_wmKeyMapItem_idname_get(PointerRNA *ptr, char *value)
575 {
576         wmKeyMapItem *kmi= ptr->data;
577         WM_operator_py_idname(value, kmi->idname);
578 }
579
580 static int rna_wmKeyMapItem_idname_length(PointerRNA *ptr)
581 {
582         wmKeyMapItem *kmi= ptr->data;
583         char pyname[OP_MAX_TYPENAME];
584
585         WM_operator_py_idname(pyname, kmi->idname);
586         return strlen(pyname);
587 }
588
589 static void rna_wmKeyMapItem_idname_set(PointerRNA *ptr, const char *value)
590 {
591         wmKeyMapItem *kmi= ptr->data;
592         char idname[OP_MAX_TYPENAME];
593
594         WM_operator_bl_idname(idname, value);
595
596         if(strcmp(idname, kmi->idname) != 0) {
597                 BLI_strncpy(kmi->idname, idname, sizeof(kmi->idname));
598
599                 WM_keymap_properties_reset(kmi, NULL);
600         }
601 }
602
603 static void rna_wmKeyMapItem_name_get(PointerRNA *ptr, char *value)
604 {
605         wmKeyMapItem *kmi= ptr->data;
606         wmOperatorType *ot= WM_operatortype_find(kmi->idname, 1);
607         
608         if (ot)
609                 strcpy(value, ot->name);
610 }
611
612 static int rna_wmKeyMapItem_name_length(PointerRNA *ptr)
613 {
614         wmKeyMapItem *kmi= ptr->data;
615         wmOperatorType *ot= WM_operatortype_find(kmi->idname, 1);
616         
617         if (ot)
618                 return strlen(ot->name);
619         else
620                 return 0;
621 }
622
623 static int rna_KeyMapItem_userdefined_get(PointerRNA *ptr)
624 {
625         wmKeyMapItem *kmi= ptr->data;
626         return kmi->id < 0;
627 }
628
629 static void rna_wmClipboard_get(PointerRNA *ptr, char *value)
630 {
631         char *pbuf;
632
633         pbuf= WM_clipboard_text_get(FALSE);
634         if(pbuf) {
635                 strcpy(value, pbuf);
636                 MEM_freeN(pbuf);
637         }
638         else {
639                 value[0]= '\0';
640         }
641 }
642
643 static int rna_wmClipboard_length(PointerRNA *ptr)
644 {
645         char *pbuf;
646         int length;
647
648         pbuf = WM_clipboard_text_get(FALSE);
649         if(pbuf) {
650                 length = strlen(pbuf);
651                 MEM_freeN(pbuf);
652         }
653         else {
654                 length= 0;
655         }
656         
657
658         return length;
659 }
660
661 static void rna_wmClipboard_set(PointerRNA *ptr, const char *value)
662 {
663         WM_clipboard_text_set((void *) value, FALSE);
664 }
665
666 #ifdef WITH_PYTHON
667 static void rna_Operator_unregister(const bContext *C, StructRNA *type)
668 {
669         const char *idname;
670         wmOperatorType *ot= RNA_struct_blender_type_get(type);
671
672         if(!ot)
673                 return;
674
675         /* update while blender is running */
676         if(C) {
677                 WM_operator_stack_clear((bContext*)C);
678                 WM_main_add_notifier(NC_SCREEN|NA_EDITED, NULL);
679         }
680
681         RNA_struct_free_extension(type, &ot->ext);
682
683         idname= ot->idname;
684         WM_operatortype_remove(ot->idname);
685         MEM_freeN((void *)idname);
686
687         /* not to be confused with the RNA_struct_free that WM_operatortype_remove calls, they are 2 different srna's */
688         RNA_struct_free(&BLENDER_RNA, type);
689 }
690
691 static int operator_poll(bContext *C, wmOperatorType *ot)
692 {
693         PointerRNA ptr;
694         ParameterList list;
695         FunctionRNA *func;
696         void *ret;
697         int visible;
698
699         RNA_pointer_create(NULL, ot->ext.srna, NULL, &ptr); /* dummy */
700         func= RNA_struct_find_function(&ptr, "poll");
701
702         RNA_parameter_list_create(&list, &ptr, func);
703         RNA_parameter_set_lookup(&list, "context", &C);
704         ot->ext.call(C, &ptr, func, &list);
705
706         RNA_parameter_get_lookup(&list, "visible", &ret);
707         visible= *(int*)ret;
708
709         RNA_parameter_list_free(&list);
710
711         return visible;
712 }
713
714 static int operator_execute(bContext *C, wmOperator *op)
715 {
716         PointerRNA opr;
717         ParameterList list;
718         FunctionRNA *func;
719         void *ret;
720         int result;
721
722         RNA_pointer_create(&CTX_wm_screen(C)->id, op->type->ext.srna, op, &opr);
723         func= RNA_struct_find_function(&opr, "execute");
724
725         RNA_parameter_list_create(&list, &opr, func);
726         RNA_parameter_set_lookup(&list, "context", &C);
727         op->type->ext.call(C, &opr, func, &list);
728
729         RNA_parameter_get_lookup(&list, "result", &ret);
730         result= *(int*)ret;
731
732         RNA_parameter_list_free(&list);
733
734         return result;
735 }
736
737 /* same as execute() but no return value */
738 static int operator_check(bContext *C, wmOperator *op)
739 {
740         PointerRNA opr;
741         ParameterList list;
742         FunctionRNA *func;
743         void *ret;
744         int result;
745
746         RNA_pointer_create(&CTX_wm_screen(C)->id, op->type->ext.srna, op, &opr);
747         func= RNA_struct_find_function(&opr, "check");
748
749         RNA_parameter_list_create(&list, &opr, func);
750         RNA_parameter_set_lookup(&list, "context", &C);
751         op->type->ext.call(C, &opr, func, &list);
752
753         RNA_parameter_get_lookup(&list, "result", &ret);
754         result= *(int*)ret;
755
756         RNA_parameter_list_free(&list);
757
758         return result;
759 }
760
761 static int operator_invoke(bContext *C, wmOperator *op, wmEvent *event)
762 {
763         PointerRNA opr;
764         ParameterList list;
765         FunctionRNA *func;
766         void *ret;
767         int result;
768
769         RNA_pointer_create(&CTX_wm_screen(C)->id, op->type->ext.srna, op, &opr);
770         func= RNA_struct_find_function(&opr, "invoke");
771
772         RNA_parameter_list_create(&list, &opr, func);
773         RNA_parameter_set_lookup(&list, "context", &C);
774         RNA_parameter_set_lookup(&list, "event", &event);
775         op->type->ext.call(C, &opr, func, &list);
776
777         RNA_parameter_get_lookup(&list, "result", &ret);
778         result= *(int*)ret;
779
780         RNA_parameter_list_free(&list);
781
782         return result;
783 }
784
785 /* same as invoke */
786 static int operator_modal(bContext *C, wmOperator *op, wmEvent *event)
787 {
788         PointerRNA opr;
789         ParameterList list;
790         FunctionRNA *func;
791         void *ret;
792         int result;
793
794         RNA_pointer_create(&CTX_wm_screen(C)->id, op->type->ext.srna, op, &opr);
795         func= RNA_struct_find_function(&opr, "modal");
796
797         RNA_parameter_list_create(&list, &opr, func);
798         RNA_parameter_set_lookup(&list, "context", &C);
799         RNA_parameter_set_lookup(&list, "event", &event);
800         op->type->ext.call(C, &opr, func, &list);
801
802         RNA_parameter_get_lookup(&list, "result", &ret);
803         result= *(int*)ret;
804
805         RNA_parameter_list_free(&list);
806
807         return result;
808 }
809
810 static void operator_draw(bContext *C, wmOperator *op)
811 {
812         PointerRNA opr;
813         ParameterList list;
814         FunctionRNA *func;
815
816         RNA_pointer_create(&CTX_wm_screen(C)->id, op->type->ext.srna, op, &opr);
817         func= RNA_struct_find_function(&opr, "draw");
818
819         RNA_parameter_list_create(&list, &opr, func);
820         RNA_parameter_set_lookup(&list, "context", &C);
821         op->type->ext.call(C, &opr, func, &list);
822
823         RNA_parameter_list_free(&list);
824 }
825
826 void operator_wrapper(wmOperatorType *ot, void *userdata);
827 void macro_wrapper(wmOperatorType *ot, void *userdata);
828
829 static char _operator_idname[OP_MAX_TYPENAME];
830 static char _operator_name[OP_MAX_TYPENAME];
831 static char _operator_descr[1024];
832 static StructRNA *rna_Operator_register(bContext *C, ReportList *reports, void *data, const char *identifier, StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
833 {
834         wmOperatorType dummyot = {0};
835         wmOperator dummyop= {0};
836         PointerRNA dummyotr;
837         int have_function[6];
838
839         /* setup dummy operator & operator type to store static properties in */
840         dummyop.type= &dummyot;
841         dummyot.idname= _operator_idname; /* only assigne the pointer, string is NULL'd */
842         dummyot.name= _operator_name; /* only assigne the pointer, string is NULL'd */
843         dummyot.description= _operator_descr; /* only assigne the pointer, string is NULL'd */
844         RNA_pointer_create(NULL, &RNA_Operator, &dummyop, &dummyotr);
845
846         /* clear incase they are left unset */
847         _operator_idname[0]= _operator_name[0]= _operator_descr[0]= '\0';
848
849         /* validate the python class */
850         if(validate(&dummyotr, data, have_function) != 0)
851                 return NULL;
852
853         {       /* convert foo.bar to FOO_OT_bar
854                  * allocate the description and the idname in 1 go */
855
856                 /* inconveniently long name sanity check */
857                 {
858                         char *ch= _operator_idname;
859                         int i;
860                         int dot= 0;
861                         for(i=0; *ch; i++) {
862                                 if((*ch >= 'a' && *ch <= 'z') || (*ch >= '0' && *ch <= '9') || *ch == '_') {
863                                         /* pass */
864                                 }
865                                 else if(*ch == '.') {
866                                         dot++;
867                                 }
868                                 else {
869                                         BKE_reportf(reports, RPT_ERROR, "registering operator class: '%s', invalid bl_idname '%s', at position %d", identifier, _operator_idname, i);
870                                         return NULL;
871                                 }
872
873                                 ch++;
874                         }
875
876                         if(i > ((int)sizeof(dummyop.idname)) - 3) {
877                                 BKE_reportf(reports, RPT_ERROR, "registering operator class: '%s', invalid bl_idname '%s', is too long, maximum length is %d.", identifier, _operator_idname, (int)sizeof(dummyop.idname) - 3);
878                                 return NULL;
879                         }
880
881                         if(dot != 1) {
882                                 BKE_reportf(reports, RPT_ERROR, "registering operator class: '%s', invalid bl_idname '%s', must contain 1 '.' character", identifier, _operator_idname);
883                                 return NULL;
884                         }
885                 }
886                 /* end sanity check */
887
888                 {
889                         int idlen = strlen(_operator_idname) + 4;
890                         int namelen = strlen(_operator_name) + 1;
891                         int desclen = strlen(_operator_descr) + 1;
892                         char *ch, *ch_arr;
893                         ch_arr= ch= MEM_callocN(sizeof(char) * (idlen + namelen + desclen), "_operator_idname"); /* 2 terminators and 3 to convert a.b -> A_OT_b */
894                         WM_operator_bl_idname(ch, _operator_idname); /* convert the idname from python */
895                         dummyot.idname= ch;
896                         ch += idlen;
897                         strcpy(ch, _operator_name);
898                         dummyot.name = ch;
899                         ch += namelen;
900                         strcpy(ch, _operator_descr);
901                         dummyot.description = ch;
902                 }
903         }
904
905         /* check if we have registered this operator type before, and remove it */
906         {
907                 wmOperatorType *ot= WM_operatortype_find(dummyot.idname, TRUE);
908                 if(ot && ot->ext.srna)
909                         rna_Operator_unregister(C, ot->ext.srna);
910         }
911
912         /* create a new menu type */
913         dummyot.ext.srna= RNA_def_struct(&BLENDER_RNA, dummyot.idname, "Operator");
914         RNA_def_struct_flag(dummyot.ext.srna, STRUCT_NO_IDPROPERTIES); /* operator properties are registered separately */
915         dummyot.ext.data= data;
916         dummyot.ext.call= call;
917         dummyot.ext.free= free;
918
919         dummyot.pyop_poll=      (have_function[0])? operator_poll: NULL;
920         dummyot.exec=           (have_function[1])? operator_execute: NULL;
921         dummyot.check=          (have_function[2])? operator_check: NULL;
922         dummyot.invoke=         (have_function[3])? operator_invoke: NULL;
923         dummyot.modal=          (have_function[4])? operator_modal: NULL;
924         dummyot.ui=                     (have_function[5])? operator_draw: NULL;
925         WM_operatortype_append_ptr(operator_wrapper, (void *)&dummyot);
926
927         /* update while blender is running */
928         if(C)
929                 WM_main_add_notifier(NC_SCREEN|NA_EDITED, NULL);
930
931         return dummyot.ext.srna;
932 }
933
934
935 static StructRNA *rna_MacroOperator_register(bContext *C, ReportList *reports, void *data, const char *identifier, StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
936 {
937         wmOperatorType dummyot = {0};
938         wmOperator dummyop= {0};
939         PointerRNA dummyotr;
940         int have_function[4];
941
942         /* setup dummy operator & operator type to store static properties in */
943         dummyop.type= &dummyot;
944         dummyot.idname= _operator_idname; /* only assigne the pointer, string is NULL'd */
945         dummyot.name= _operator_name; /* only assigne the pointer, string is NULL'd */
946         dummyot.description= _operator_descr; /* only assigne the pointer, string is NULL'd */
947         RNA_pointer_create(NULL, &RNA_Macro, &dummyop, &dummyotr);
948
949         /* validate the python class */
950         if(validate(&dummyotr, data, have_function) != 0)
951                 return NULL;
952
953         {       /* convert foo.bar to FOO_OT_bar
954                  * allocate the description and the idname in 1 go */
955                 int idlen = strlen(_operator_idname) + 4;
956                 int namelen = strlen(_operator_name) + 1;
957                 int desclen = strlen(_operator_descr) + 1;
958                 char *ch, *ch_arr;
959                 ch_arr= ch= MEM_callocN(sizeof(char) * (idlen + namelen + desclen), "_operator_idname"); /* 2 terminators and 3 to convert a.b -> A_OT_b */
960                 WM_operator_bl_idname(ch, _operator_idname); /* convert the idname from python */
961                 dummyot.idname= ch;
962                 ch += idlen;
963                 strcpy(ch, _operator_name);
964                 dummyot.name = ch;
965                 ch += namelen;
966                 strcpy(ch, _operator_descr);
967                 dummyot.description = ch;
968         }
969
970         if(strlen(identifier) >= sizeof(dummyop.idname)) {
971                 BKE_reportf(reports, RPT_ERROR, "registering operator class: '%s' is too long, maximum length is %d.", identifier, (int)sizeof(dummyop.idname));
972                 return NULL;
973         }
974
975         /* check if we have registered this operator type before, and remove it */
976         {
977                 wmOperatorType *ot= WM_operatortype_find(dummyot.idname, TRUE);
978                 if(ot && ot->ext.srna)
979                         rna_Operator_unregister(C, ot->ext.srna);
980         }
981
982         /* create a new menu type */
983         dummyot.ext.srna= RNA_def_struct(&BLENDER_RNA, dummyot.idname, "Operator");
984         dummyot.ext.data= data;
985         dummyot.ext.call= call;
986         dummyot.ext.free= free;
987
988         dummyot.pyop_poll=      (have_function[0])? operator_poll: NULL;
989         dummyot.ui=                     (have_function[3])? operator_draw: NULL;
990
991         WM_operatortype_append_macro_ptr(macro_wrapper, (void *)&dummyot);
992
993         /* update while blender is running */
994         if(C)
995                 WM_main_add_notifier(NC_SCREEN|NA_EDITED, NULL);
996
997         return dummyot.ext.srna;
998 }
999 #endif /* WITH_PYTHON */
1000
1001 static StructRNA* rna_Operator_refine(PointerRNA *opr)
1002 {
1003         wmOperator *op= (wmOperator*)opr->data;
1004         return (op->type && op->type->ext.srna)? op->type->ext.srna: &RNA_Operator;
1005 }
1006
1007 static StructRNA* rna_MacroOperator_refine(PointerRNA *opr)
1008 {
1009         wmOperator *op= (wmOperator*)opr->data;
1010         return (op->type && op->type->ext.srna)? op->type->ext.srna: &RNA_Macro;
1011 }
1012
1013 static wmKeyMapItem *rna_KeyMap_item_new(wmKeyMap *km, ReportList *reports, const char *idname, int type, int value, int any, int shift, int ctrl, int alt, int oskey, int keymodifier)
1014 {
1015 //      wmWindowManager *wm = CTX_wm_manager(C);
1016         int modifier= 0;
1017
1018         /* only on non-modal maps */
1019         if (km->flag & KEYMAP_MODAL) {
1020                 BKE_report(reports, RPT_ERROR, "Not a non-modal keymap.");
1021                 return NULL;
1022         }
1023
1024         if(shift) modifier |= KM_SHIFT;
1025         if(ctrl) modifier |= KM_CTRL;
1026         if(alt) modifier |= KM_ALT;
1027         if(oskey) modifier |= KM_OSKEY;
1028
1029         if(any) modifier = KM_ANY;
1030
1031         return WM_keymap_add_item(km, idname, type, value, modifier, keymodifier);
1032 }
1033
1034 static wmKeyMapItem *rna_KeyMap_item_new_modal(wmKeyMap *km, bContext *C, ReportList *reports, const char *propvalue_str, int type, int value, int any, int shift, int ctrl, int alt, int oskey, int keymodifier)
1035 {
1036         wmWindowManager *wm = CTX_wm_manager(C);
1037         int modifier= 0;
1038         int propvalue = 0;
1039
1040         /* only modal maps */
1041         if ((km->flag & KEYMAP_MODAL) == 0) {
1042                 BKE_report(reports, RPT_ERROR, "Not a modal keymap.");
1043                 return NULL;
1044         }
1045
1046         if (!km->modal_items) {
1047                 if(!WM_keymap_user_init(wm, km)) {
1048                         BKE_report(reports, RPT_ERROR, "User defined keymap doesn't correspond to a system keymap.");
1049                         return NULL;
1050                 }
1051         }
1052
1053         if (!km->modal_items) {
1054                 BKE_report(reports, RPT_ERROR, "No property values defined.");
1055                 return NULL;
1056         }
1057
1058
1059         if(RNA_enum_value_from_id(km->modal_items, propvalue_str, &propvalue)==0) {
1060                 BKE_report(reports, RPT_WARNING, "Property value not in enumeration.");
1061         }
1062
1063         if(shift) modifier |= KM_SHIFT;
1064         if(ctrl) modifier |= KM_CTRL;
1065         if(alt) modifier |= KM_ALT;
1066         if(oskey) modifier |= KM_OSKEY;
1067
1068         if(any) modifier = KM_ANY;
1069
1070         return WM_modalkeymap_add_item(km, type, value, modifier, keymodifier, propvalue);
1071 }
1072
1073 static wmKeyMap *rna_keymap_new(wmKeyConfig *keyconf, const char *idname, int spaceid, int regionid, int modal)
1074 {
1075         if (modal == 0) {
1076                 return WM_keymap_find(keyconf, idname, spaceid, regionid);
1077         } else {
1078                 return WM_modalkeymap_add(keyconf, idname, NULL); /* items will be lazy init */
1079         }
1080 }
1081
1082 static wmKeyMap *rna_keymap_find(wmKeyConfig *keyconf, const char *idname, int spaceid, int regionid)
1083 {
1084         return WM_keymap_list_find(&keyconf->keymaps, idname, spaceid, regionid);
1085 }
1086
1087 static wmKeyMap *rna_keymap_find_modal(wmKeyConfig *keyconf, const char *idname)
1088 {
1089         wmOperatorType *ot = WM_operatortype_find(idname, 0);
1090
1091         if (!ot)
1092                 return NULL;
1093         else
1094                 return ot->modalkeymap;
1095 }
1096
1097 /* just to work around 'const char *' warning and to ensure this is a python op */
1098 static void rna_Operator_bl_idname_set(PointerRNA *ptr, const char *value)
1099 {
1100         wmOperator *data= (wmOperator*)(ptr->data);
1101         char *str= (char *)data->type->idname;
1102         if(!str[0])     strcpy(str, value);
1103         else            assert(!"setting the bl_idname on a non-builtin operator");
1104 }
1105
1106 static void rna_Operator_bl_label_set(PointerRNA *ptr, const char *value)
1107 {
1108         wmOperator *data= (wmOperator*)(ptr->data);
1109         char *str= (char *)data->type->name;
1110         if(!str[0])     strcpy(str, value);
1111         else            assert(!"setting the bl_label on a non-builtin operator");
1112 }
1113
1114 static void rna_Operator_bl_description_set(PointerRNA *ptr, const char *value)
1115 {
1116         wmOperator *data= (wmOperator*)(ptr->data);
1117         char *str= (char *)data->type->description;
1118         if(!str[0])     strcpy(str, value);
1119         else            assert(!"setting the bl_description on a non-builtin operator");
1120 }
1121
1122 #else /* RNA_RUNTIME */
1123
1124 static void rna_def_operator(BlenderRNA *brna)
1125 {
1126         StructRNA *srna;
1127         PropertyRNA *prop;
1128
1129         srna= RNA_def_struct(brna, "Operator", NULL);
1130         RNA_def_struct_ui_text(srna, "Operator", "Storage of an operator being executed, or registered after execution");
1131         RNA_def_struct_sdna(srna, "wmOperator");
1132         RNA_def_struct_refine_func(srna, "rna_Operator_refine");
1133 #ifdef WITH_PYTHON
1134         RNA_def_struct_register_funcs(srna, "rna_Operator_register", "rna_Operator_unregister");
1135 #endif
1136
1137         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1138         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1139         RNA_def_property_string_funcs(prop, "rna_Operator_name_get", "rna_Operator_name_length", NULL);
1140         RNA_def_property_ui_text(prop, "Name", "");
1141
1142         prop= RNA_def_property(srna, "properties", PROP_POINTER, PROP_NONE);
1143         RNA_def_property_flag(prop, PROP_NEVER_NULL);
1144         RNA_def_property_struct_type(prop, "OperatorProperties");
1145         RNA_def_property_ui_text(prop, "Properties", "");
1146         RNA_def_property_pointer_funcs(prop, "rna_Operator_properties_get", NULL, NULL, NULL);
1147         
1148         prop= RNA_def_property(srna, "has_reports", PROP_BOOLEAN, PROP_NONE);
1149         RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* this is 'virtual' property */
1150         RNA_def_property_boolean_funcs(prop, "rna_Operator_has_reports_get", NULL);
1151         RNA_def_property_ui_text(prop, "Has Reports", "Operator has a set of reports (warnings and errors) from last execution");
1152         
1153         prop= RNA_def_property(srna, "layout", PROP_POINTER, PROP_NONE);
1154         RNA_def_property_struct_type(prop, "UILayout");
1155
1156         /* Registration */
1157         prop= RNA_def_property(srna, "bl_idname", PROP_STRING, PROP_NONE);
1158         RNA_def_property_string_sdna(prop, NULL, "type->idname");
1159         RNA_def_property_string_maxlength(prop, OP_MAX_TYPENAME-3); /* else it uses the pointer size!. -3 because '.' -> '_OT_' */
1160         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_Operator_bl_idname_set");
1161         // RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1162         RNA_def_property_flag(prop, PROP_REGISTER|PROP_NEVER_CLAMP);
1163         RNA_def_struct_name_property(srna, prop);
1164
1165         prop= RNA_def_property(srna, "bl_label", PROP_STRING, PROP_NONE);
1166         RNA_def_property_string_sdna(prop, NULL, "type->name");
1167         RNA_def_property_string_maxlength(prop, 1024); /* else it uses the pointer size! */
1168         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_Operator_bl_label_set");
1169         // RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1170         RNA_def_property_flag(prop, PROP_REGISTER);
1171
1172         prop= RNA_def_property(srna, "bl_description", PROP_STRING, PROP_NONE);
1173         RNA_def_property_string_sdna(prop, NULL, "type->description");
1174         RNA_def_property_string_maxlength(prop, 1024); /* else it uses the pointer size! */
1175         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_Operator_bl_description_set");
1176         // RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1177         RNA_def_property_flag(prop, PROP_REGISTER_OPTIONAL);
1178
1179         prop= RNA_def_property(srna, "bl_options", PROP_ENUM, PROP_NONE);
1180         RNA_def_property_enum_sdna(prop, NULL, "type->flag");
1181         RNA_def_property_enum_items(prop, operator_flag_items);
1182         RNA_def_property_flag(prop, PROP_REGISTER_OPTIONAL|PROP_ENUM_FLAG);
1183         RNA_def_property_ui_text(prop, "Options",  "Options for this operator type");
1184
1185         RNA_api_operator(srna);
1186
1187         srna= RNA_def_struct(brna, "OperatorProperties", NULL);
1188         RNA_def_struct_ui_text(srna, "Operator Properties", "Input properties of an Operator");
1189         RNA_def_struct_refine_func(srna, "rna_OperatorProperties_refine");
1190         RNA_def_struct_idprops_func(srna, "rna_OperatorProperties_idprops");
1191 }
1192
1193 static void rna_def_macro_operator(BlenderRNA *brna)
1194 {
1195         StructRNA *srna;
1196         PropertyRNA *prop;
1197
1198         srna= RNA_def_struct(brna, "Macro", NULL);
1199         RNA_def_struct_ui_text(srna, "Macro Operator", "Storage of a macro operator being executed, or registered after execution");
1200         RNA_def_struct_sdna(srna, "wmOperator");
1201         RNA_def_struct_refine_func(srna, "rna_MacroOperator_refine");
1202 #ifdef WITH_PYTHON
1203         RNA_def_struct_register_funcs(srna, "rna_MacroOperator_register", "rna_Operator_unregister");
1204 #endif
1205     
1206         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1207         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1208         RNA_def_property_string_funcs(prop, "rna_Operator_name_get", "rna_Operator_name_length", NULL);
1209         RNA_def_property_ui_text(prop, "Name", "");
1210
1211         prop= RNA_def_property(srna, "properties", PROP_POINTER, PROP_NONE);
1212         RNA_def_property_flag(prop, PROP_NEVER_NULL);
1213         RNA_def_property_struct_type(prop, "OperatorProperties");
1214         RNA_def_property_ui_text(prop, "Properties", "");
1215         RNA_def_property_pointer_funcs(prop, "rna_Operator_properties_get", NULL, NULL, NULL);
1216
1217         /* Registration */
1218         prop= RNA_def_property(srna, "bl_idname", PROP_STRING, PROP_NONE);
1219         RNA_def_property_string_sdna(prop, NULL, "type->idname");
1220         RNA_def_property_string_maxlength(prop, OP_MAX_TYPENAME); /* else it uses the pointer size! */
1221         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_Operator_bl_idname_set");
1222         // RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1223         RNA_def_property_flag(prop, PROP_REGISTER|PROP_NEVER_CLAMP);
1224         RNA_def_struct_name_property(srna, prop);
1225
1226         prop= RNA_def_property(srna, "bl_label", PROP_STRING, PROP_NONE);
1227         RNA_def_property_string_sdna(prop, NULL, "type->name");
1228         RNA_def_property_string_maxlength(prop, 1024); /* else it uses the pointer size! */
1229         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_Operator_bl_label_set");
1230         // RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1231         RNA_def_property_flag(prop, PROP_REGISTER);
1232
1233         prop= RNA_def_property(srna, "bl_description", PROP_STRING, PROP_NONE);
1234         RNA_def_property_string_sdna(prop, NULL, "type->description");
1235         RNA_def_property_string_maxlength(prop, 1024); /* else it uses the pointer size! */
1236         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_Operator_bl_description_set");
1237         // RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1238         RNA_def_property_flag(prop, PROP_REGISTER_OPTIONAL);
1239
1240         prop= RNA_def_property(srna, "bl_options", PROP_ENUM, PROP_NONE);
1241         RNA_def_property_enum_sdna(prop, NULL, "type->flag");
1242         RNA_def_property_enum_items(prop, operator_flag_items);
1243         RNA_def_property_flag(prop, PROP_REGISTER_OPTIONAL|PROP_ENUM_FLAG);
1244         RNA_def_property_ui_text(prop, "Options",  "Options for this operator type");
1245
1246         RNA_api_macro(srna);
1247 }
1248
1249 static void rna_def_operator_type_macro(BlenderRNA *brna)
1250 {
1251         StructRNA *srna;
1252         PropertyRNA *prop;
1253
1254         srna= RNA_def_struct(brna, "OperatorTypeMacro", NULL);
1255         RNA_def_struct_ui_text(srna, "OperatorTypeMacro", "Storage of a sub operator in a macro after it has been added");
1256         RNA_def_struct_sdna(srna, "wmOperatorTypeMacro");
1257
1258 //      prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1259 //      RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1260 //      RNA_def_property_string_sdna(prop, NULL, "idname");
1261 //      RNA_def_property_ui_text(prop, "Name", "Name of the sub operator");
1262 //      RNA_def_struct_name_property(srna, prop);
1263
1264         prop= RNA_def_property(srna, "properties", PROP_POINTER, PROP_NONE);
1265         RNA_def_property_flag(prop, PROP_NEVER_NULL);
1266         RNA_def_property_struct_type(prop, "OperatorProperties");
1267         RNA_def_property_ui_text(prop, "Properties", "");
1268         RNA_def_property_pointer_funcs(prop, "rna_OperatorTypeMacro_properties_get", NULL, NULL, NULL);
1269 }
1270
1271 static void rna_def_operator_utils(BlenderRNA *brna)
1272 {
1273         StructRNA *srna;
1274         PropertyRNA *prop;
1275
1276         srna= RNA_def_struct(brna, "OperatorMousePath", "PropertyGroup");
1277         RNA_def_struct_ui_text(srna, "Operator Mouse Path", "Mouse path values for operators that record such paths");
1278
1279         prop= RNA_def_property(srna, "loc", PROP_FLOAT, PROP_XYZ);
1280         RNA_def_property_flag(prop, PROP_IDPROPERTY);
1281         RNA_def_property_array(prop, 2);
1282         RNA_def_property_ui_text(prop, "Location", "Mouse location");
1283
1284         prop= RNA_def_property(srna, "time", PROP_FLOAT, PROP_NONE);
1285         RNA_def_property_flag(prop, PROP_IDPROPERTY);
1286         RNA_def_property_ui_text(prop, "Time", "Time of mouse location");
1287 }
1288
1289 static void rna_def_operator_filelist_element(BlenderRNA *brna)
1290 {
1291         StructRNA *srna;
1292         PropertyRNA *prop;
1293
1294         srna= RNA_def_struct(brna, "OperatorFileListElement", "PropertyGroup");
1295         RNA_def_struct_ui_text(srna, "Operator File List Element", "");
1296         
1297         
1298         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1299         RNA_def_property_flag(prop, PROP_IDPROPERTY);
1300         RNA_def_property_ui_text(prop, "Name", "the name of a file or directory within a file list");
1301 }
1302         
1303 static void rna_def_event(BlenderRNA *brna)
1304 {
1305         StructRNA *srna;
1306         PropertyRNA *prop;
1307         
1308         srna= RNA_def_struct(brna, "Event", NULL);
1309         RNA_def_struct_ui_text(srna, "Event", "Window Manager Event");
1310         RNA_def_struct_sdna(srna, "wmEvent");
1311
1312         RNA_define_verify_sdna(0); // not in sdna
1313
1314         /* strings */
1315         prop= RNA_def_property(srna, "ascii", PROP_STRING, PROP_NONE);
1316         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1317         RNA_def_property_string_funcs(prop, "rna_Event_ascii_get", "rna_Event_ascii_length", NULL);
1318         RNA_def_property_ui_text(prop, "ASCII", "Single ASCII character for this event");
1319
1320
1321         /* enums */
1322         prop= RNA_def_property(srna, "value", PROP_ENUM, PROP_NONE);
1323         RNA_def_property_enum_sdna(prop, NULL, "val");
1324         RNA_def_property_enum_items(prop, event_value_items);
1325         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1326         RNA_def_property_ui_text(prop, "Value",  "The type of event, only applies to some");
1327         
1328         prop= RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
1329         RNA_def_property_enum_sdna(prop, NULL, "type");
1330         RNA_def_property_enum_items(prop, event_type_items);
1331         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1332         RNA_def_property_ui_text(prop, "Type",  "");
1333
1334
1335         /* mouse */
1336         prop= RNA_def_property(srna, "mouse_x", PROP_INT, PROP_NONE);
1337         RNA_def_property_int_sdna(prop, NULL, "x");
1338         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1339         RNA_def_property_ui_text(prop, "Mouse X Position", "The window relative vertical location of the mouse");
1340         
1341         prop= RNA_def_property(srna, "mouse_y", PROP_INT, PROP_NONE);
1342         RNA_def_property_int_sdna(prop, NULL, "y");
1343         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1344         RNA_def_property_ui_text(prop, "Mouse Y Position", "The window relative horizontal location of the mouse");
1345
1346         prop= RNA_def_property(srna, "mouse_region_x", PROP_INT, PROP_NONE);
1347         RNA_def_property_int_sdna(prop, NULL, "mval[0]");
1348         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1349         RNA_def_property_ui_text(prop, "Mouse X Position", "The region relative vertical location of the mouse");
1350
1351         prop= RNA_def_property(srna, "mouse_region_y", PROP_INT, PROP_NONE);
1352         RNA_def_property_int_sdna(prop, NULL, "mval[1]");
1353         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1354         RNA_def_property_ui_text(prop, "Mouse Y Position", "The region relative horizontal location of the mouse");
1355         
1356         prop= RNA_def_property(srna, "mouse_prev_x", PROP_INT, PROP_NONE);
1357         RNA_def_property_int_sdna(prop, NULL, "prevx");
1358         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1359         RNA_def_property_ui_text(prop, "Mouse Previous X Position", "The window relative vertical location of the mouse");
1360         
1361         prop= RNA_def_property(srna, "mouse_prev_y", PROP_INT, PROP_NONE);
1362         RNA_def_property_int_sdna(prop, NULL, "prevy");
1363         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1364         RNA_def_property_ui_text(prop, "Mouse Previous Y Position", "The window relative horizontal location of the mouse");    
1365
1366
1367         /* modifiers */
1368         prop= RNA_def_property(srna, "shift", PROP_BOOLEAN, PROP_NONE);
1369         RNA_def_property_boolean_sdna(prop, NULL, "shift", 1);
1370         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1371         RNA_def_property_ui_text(prop, "Shift", "True when the Shift key is held");
1372         
1373         prop= RNA_def_property(srna, "ctrl", PROP_BOOLEAN, PROP_NONE);
1374         RNA_def_property_boolean_sdna(prop, NULL, "ctrl", 1);
1375         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1376         RNA_def_property_ui_text(prop, "Ctrl", "True when the Ctrl key is held");
1377         
1378         prop= RNA_def_property(srna, "alt", PROP_BOOLEAN, PROP_NONE);
1379         RNA_def_property_boolean_sdna(prop, NULL, "alt", 1);
1380         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1381         RNA_def_property_ui_text(prop, "Alt", "True when the Alt/Option key is held");
1382         
1383         prop= RNA_def_property(srna, "oskey", PROP_BOOLEAN, PROP_NONE);
1384         RNA_def_property_boolean_sdna(prop, NULL, "oskey", 1);
1385         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1386         RNA_def_property_ui_text(prop, "OS Key", "True when the Cmd key is held");
1387
1388         RNA_define_verify_sdna(1); // not in sdna
1389 }
1390
1391 static void rna_def_window(BlenderRNA *brna)
1392 {
1393         StructRNA *srna;
1394         PropertyRNA *prop;
1395
1396         srna= RNA_def_struct(brna, "Window", NULL);
1397         RNA_def_struct_ui_text(srna, "Window", "Open window");
1398         RNA_def_struct_sdna(srna, "wmWindow");
1399
1400         prop= RNA_def_property(srna, "screen", PROP_POINTER, PROP_NONE);
1401         RNA_def_property_flag(prop, PROP_NEVER_NULL);
1402         RNA_def_property_struct_type(prop, "Screen");
1403         RNA_def_property_ui_text(prop, "Screen", "Active screen showing in the window");
1404         RNA_def_property_flag(prop, PROP_EDITABLE);
1405         RNA_def_property_pointer_funcs(prop, NULL, "rna_Window_screen_set", NULL, NULL);
1406         RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
1407         RNA_def_property_update(prop, 0, "rna_Window_screen_update");
1408 }
1409
1410 /* curve.splines */
1411 static void rna_def_wm_keyconfigs(BlenderRNA *brna, PropertyRNA *cprop)
1412 {
1413         StructRNA *srna;
1414         PropertyRNA *prop;
1415
1416         FunctionRNA *func;
1417         PropertyRNA *parm;
1418
1419         RNA_def_property_srna(cprop, "KeyConfigurations");
1420         srna= RNA_def_struct(brna, "KeyConfigurations", NULL);
1421         RNA_def_struct_sdna(srna, "wmWindowManager");
1422         RNA_def_struct_ui_text(srna, "KeyConfigs", "Collection of KeyConfigs");
1423
1424         prop= RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
1425         RNA_def_property_struct_type(prop, "KeyConfig");
1426         RNA_def_property_pointer_funcs(prop, "rna_WindowManager_active_keyconfig_get", "rna_WindowManager_active_keyconfig_set", NULL, NULL);
1427         RNA_def_property_flag(prop, PROP_EDITABLE);
1428         RNA_def_property_ui_text(prop, "Active KeyConfig", "Active wm KeyConfig");
1429         
1430         prop= RNA_def_property(srna, "default", PROP_POINTER, PROP_NEVER_NULL);
1431         RNA_def_property_pointer_sdna(prop, NULL, "defaultconf");
1432         RNA_def_property_struct_type(prop, "KeyConfig");
1433         RNA_def_property_ui_text(prop, "Default Key Configuration", "");
1434         
1435         /* funcs */
1436         func= RNA_def_function(srna, "new", "WM_keyconfig_new_user"); // add_keyconfig
1437         parm= RNA_def_string(func, "name", "", 0, "Name", "");
1438         RNA_def_property_flag(parm, PROP_REQUIRED);
1439         parm= RNA_def_pointer(func, "keyconfig", "KeyConfig", "Key Configuration", "Added key configuration.");
1440         RNA_def_function_return(func, parm);
1441
1442         func= RNA_def_function(srna, "remove", "WM_keyconfig_remove"); // remove_keyconfig
1443         parm= RNA_def_pointer(func, "keyconfig", "KeyConfig", "Key Configuration", "Removed key configuration.");
1444         RNA_def_property_flag(parm, PROP_REQUIRED);
1445 }
1446
1447 static void rna_def_windowmanager(BlenderRNA *brna)
1448 {
1449         StructRNA *srna;
1450         PropertyRNA *prop;
1451
1452         srna= RNA_def_struct(brna, "WindowManager", "ID");
1453         RNA_def_struct_ui_text(srna, "Window Manager", "Window manager datablock defining open windows and other user interface data");
1454         RNA_def_struct_clear_flag(srna, STRUCT_ID_REFCOUNT);
1455         RNA_def_struct_sdna(srna, "wmWindowManager");
1456
1457         prop= RNA_def_property(srna, "operators", PROP_COLLECTION, PROP_NONE);
1458         RNA_def_property_struct_type(prop, "Operator");
1459         RNA_def_property_ui_text(prop, "Operators", "Operator registry");
1460
1461         prop= RNA_def_property(srna, "windows", PROP_COLLECTION, PROP_NONE);
1462         RNA_def_property_struct_type(prop, "Window");
1463         RNA_def_property_ui_text(prop, "Windows", "Open windows");
1464
1465         prop= RNA_def_property(srna, "keyconfigs", PROP_COLLECTION, PROP_NONE);
1466         RNA_def_property_struct_type(prop, "KeyConfig");
1467         RNA_def_property_ui_text(prop, "Key Configurations", "Registered key configurations");
1468         rna_def_wm_keyconfigs(brna, prop);
1469
1470         prop= RNA_def_property(srna, "clipboard", PROP_STRING, PROP_NONE);
1471         RNA_def_property_string_funcs(prop, "rna_wmClipboard_get", "rna_wmClipboard_length", "rna_wmClipboard_set");
1472         RNA_def_property_ui_text(prop, "Text Clipboard", "");
1473
1474         RNA_api_wm(srna);
1475 }
1476
1477 /* keyconfig.items */
1478 static void rna_def_keymap_items(BlenderRNA *brna, PropertyRNA *cprop)
1479 {
1480         StructRNA *srna;
1481 //      PropertyRNA *prop;
1482
1483         FunctionRNA *func;
1484         PropertyRNA *parm;
1485         
1486         RNA_def_property_srna(cprop, "KeyMapItems");
1487         srna= RNA_def_struct(brna, "KeyMapItems", NULL);
1488         RNA_def_struct_sdna(srna, "wmKeyMap");
1489         RNA_def_struct_ui_text(srna, "KeyMap Items", "Collection of keymap items");
1490
1491         func= RNA_def_function(srna, "new", "rna_KeyMap_item_new");
1492         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1493         parm= RNA_def_string(func, "idname", "", 0, "Operator Identifier", "");
1494         RNA_def_property_flag(parm, PROP_REQUIRED);
1495         parm= RNA_def_enum(func, "type", event_type_items, 0, "Type", "");
1496         RNA_def_property_flag(parm, PROP_REQUIRED);
1497         parm= RNA_def_enum(func, "value", event_value_items, 0, "Value", "");
1498         RNA_def_property_flag(parm, PROP_REQUIRED);
1499         RNA_def_boolean(func, "any", 0, "Any", "");
1500         RNA_def_boolean(func, "shift", 0, "Shift", "");
1501         RNA_def_boolean(func, "ctrl", 0, "Ctrl", "");
1502         RNA_def_boolean(func, "alt", 0, "Alt", "");
1503         RNA_def_boolean(func, "oskey", 0, "OS Key", "");
1504         RNA_def_enum(func, "key_modifier", event_type_items, 0, "Key Modifier", "");
1505         parm= RNA_def_pointer(func, "item", "KeyMapItem", "Item", "Added key map item.");
1506         RNA_def_function_return(func, parm);
1507
1508         func= RNA_def_function(srna, "new_modal", "rna_KeyMap_item_new_modal");
1509         RNA_def_function_flag(func, FUNC_USE_CONTEXT|FUNC_USE_REPORTS);
1510         parm= RNA_def_string(func, "propvalue", "", 0, "Property Value", "");
1511         RNA_def_property_flag(parm, PROP_REQUIRED);
1512         parm= RNA_def_enum(func, "type", event_type_items, 0, "Type", "");
1513         RNA_def_property_flag(parm, PROP_REQUIRED);
1514         parm= RNA_def_enum(func, "value", event_value_items, 0, "Value", "");
1515         RNA_def_property_flag(parm, PROP_REQUIRED);
1516         RNA_def_boolean(func, "any", 0, "Any", "");
1517         RNA_def_boolean(func, "shift", 0, "Shift", "");
1518         RNA_def_boolean(func, "ctrl", 0, "Ctrl", "");
1519         RNA_def_boolean(func, "alt", 0, "Alt", "");
1520         RNA_def_boolean(func, "oskey", 0, "OS Key", "");
1521         RNA_def_enum(func, "key_modifier", event_type_items, 0, "Key Modifier", "");
1522         parm= RNA_def_pointer(func, "item", "KeyMapItem", "Item", "Added key map item.");
1523         RNA_def_function_return(func, parm);
1524         
1525         func= RNA_def_function(srna, "remove", "WM_keymap_remove_item");
1526         parm= RNA_def_pointer(func, "item", "KeyMapItem", "Item", "");
1527         RNA_def_property_flag(parm, PROP_REQUIRED);
1528
1529         func= RNA_def_function(srna, "from_id", "WM_keymap_item_find_id");
1530         parm= RNA_def_property(func, "id", PROP_INT, PROP_NONE);
1531         RNA_def_property_flag(parm, PROP_REQUIRED);
1532         RNA_def_property_ui_text(parm, "id", "ID of the item");
1533         parm= RNA_def_pointer(func, "item", "KeyMapItem", "Item", "");
1534         RNA_def_function_return(func, parm);
1535         
1536 }
1537
1538 static void rna_def_wm_keymaps(BlenderRNA *brna, PropertyRNA *cprop)
1539 {
1540         StructRNA *srna;
1541         //PropertyRNA *prop;
1542
1543         FunctionRNA *func;
1544         PropertyRNA *parm;
1545
1546
1547         RNA_def_property_srna(cprop, "KeyMaps");
1548         srna= RNA_def_struct(brna, "KeyMaps", NULL);
1549         RNA_def_struct_sdna(srna, "wmKeyConfig");
1550         RNA_def_struct_ui_text(srna, "Key Maps", "Collection of keymaps");
1551
1552         func= RNA_def_function(srna, "new", "rna_keymap_new"); // add_keymap
1553         parm= RNA_def_string(func, "name", "", 0, "Name", "");
1554         RNA_def_property_flag(parm, PROP_REQUIRED);
1555         RNA_def_enum(func, "space_type", space_type_items, SPACE_EMPTY, "Space Type", "");
1556         RNA_def_enum(func, "region_type", region_type_items, RGN_TYPE_WINDOW, "Region Type", "");
1557         RNA_def_boolean(func, "modal", 0, "Modal", "");
1558         parm= RNA_def_pointer(func, "keymap", "KeyMap", "Key Map", "Added key map.");
1559         RNA_def_function_return(func, parm);
1560
1561         func= RNA_def_function(srna, "find", "rna_keymap_find"); // find_keymap
1562         parm= RNA_def_string(func, "name", "", 0, "Name", "");
1563         RNA_def_property_flag(parm, PROP_REQUIRED);
1564         RNA_def_enum(func, "space_type", space_type_items, SPACE_EMPTY, "Space Type", "");
1565         RNA_def_enum(func, "region_type", region_type_items, RGN_TYPE_WINDOW, "Region Type", "");
1566         parm= RNA_def_pointer(func, "keymap", "KeyMap", "Key Map", "Corresponding key map.");
1567         RNA_def_function_return(func, parm);
1568
1569         func= RNA_def_function(srna, "find_modal", "rna_keymap_find_modal"); // find_keymap_modal
1570         parm= RNA_def_string(func, "name", "", 0, "Operator Name", "");
1571         RNA_def_property_flag(parm, PROP_REQUIRED);
1572         parm= RNA_def_pointer(func, "keymap", "KeyMap", "Key Map", "Corresponding key map.");
1573         RNA_def_function_return(func, parm);
1574         
1575 }
1576
1577 static void rna_def_keyconfig(BlenderRNA *brna)
1578 {
1579         StructRNA *srna;
1580         // FunctionRNA *func;
1581         // PropertyRNA *parm;
1582         PropertyRNA *prop;
1583
1584         static EnumPropertyItem map_type_items[] = {
1585                 {KMI_TYPE_KEYBOARD, "KEYBOARD", 0, "Keyboard", ""},
1586                 {KMI_TYPE_TWEAK, "TWEAK", 0, "Tweak", ""},
1587                 {KMI_TYPE_MOUSE, "MOUSE", 0, "Mouse", ""},
1588                 {KMI_TYPE_TEXTINPUT, "TEXTINPUT", 0, "Text Input", ""},
1589                 {KMI_TYPE_TIMER, "TIMER", 0, "Timer", ""},
1590                 {0, NULL, 0, NULL, NULL}};
1591
1592         /* KeyConfig */
1593         srna= RNA_def_struct(brna, "KeyConfig", NULL);
1594         RNA_def_struct_sdna(srna, "wmKeyConfig");
1595         RNA_def_struct_ui_text(srna, "Key Configuration", "Input configuration, including keymaps");
1596
1597         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1598         RNA_def_property_string_sdna(prop, NULL, "idname");
1599         RNA_def_property_ui_text(prop, "Name", "Name of the key configuration");
1600         RNA_def_struct_name_property(srna, prop);
1601
1602         prop= RNA_def_property(srna, "keymaps", PROP_COLLECTION, PROP_NONE);
1603         RNA_def_property_struct_type(prop, "KeyMap");
1604         RNA_def_property_ui_text(prop, "Key Maps", "Key maps configured as part of this configuration");
1605         rna_def_wm_keymaps(brna, prop);
1606
1607         prop= RNA_def_property(srna, "is_user_defined", PROP_BOOLEAN, PROP_NONE);
1608         RNA_def_property_boolean_sdna(prop, NULL, "flag", KEYCONF_USER);
1609         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1610         RNA_def_property_ui_text(prop, "User Defined", "Indicates that a keyconfig was defined by the user");
1611
1612         RNA_api_keyconfig(srna);
1613
1614         /* KeyMap */
1615         srna= RNA_def_struct(brna, "KeyMap", NULL);
1616         RNA_def_struct_sdna(srna, "wmKeyMap");
1617         RNA_def_struct_ui_text(srna, "Key Map", "Input configuration, including keymaps");
1618
1619         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1620         RNA_def_property_string_sdna(prop, NULL, "idname");
1621         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1622         RNA_def_property_ui_text(prop, "Name", "Name of the key map");
1623         RNA_def_struct_name_property(srna, prop);
1624
1625         prop= RNA_def_property(srna, "space_type", PROP_ENUM, PROP_NONE);
1626         RNA_def_property_enum_sdna(prop, NULL, "spaceid");
1627         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1628         RNA_def_property_enum_items(prop, space_type_items);
1629         RNA_def_property_ui_text(prop, "Space Type", "Optional space type keymap is associated with");
1630
1631         prop= RNA_def_property(srna, "region_type", PROP_ENUM, PROP_NONE);
1632         RNA_def_property_enum_sdna(prop, NULL, "regionid");
1633         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1634         RNA_def_property_enum_items(prop, region_type_items);
1635         RNA_def_property_ui_text(prop, "Region Type", "Optional region type keymap is associated with");
1636
1637         prop= RNA_def_property(srna, "items", PROP_COLLECTION, PROP_NONE);
1638         RNA_def_property_struct_type(prop, "KeyMapItem");
1639         RNA_def_property_ui_text(prop, "Items", "Items in the keymap, linking an operator to an input event");
1640         rna_def_keymap_items(brna, prop);
1641
1642         prop= RNA_def_property(srna, "is_user_defined", PROP_BOOLEAN, PROP_NEVER_NULL);
1643         RNA_def_property_boolean_sdna(prop, NULL, "flag", KEYMAP_USER);
1644         RNA_def_property_ui_text(prop, "User Defined", "Keymap is defined by the user");
1645
1646         prop= RNA_def_property(srna, "is_modal", PROP_BOOLEAN, PROP_NONE);
1647         RNA_def_property_boolean_sdna(prop, NULL, "flag", KEYMAP_MODAL);
1648         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1649         RNA_def_property_ui_text(prop, "Modal Keymap", "Indicates that a keymap is used for translate modal events for an operator");
1650
1651         prop= RNA_def_property(srna, "show_expanded_items", PROP_BOOLEAN, PROP_NONE);
1652         RNA_def_property_boolean_sdna(prop, NULL, "flag", KEYMAP_EXPANDED);
1653         RNA_def_property_ui_text(prop, "Items Expanded", "Expanded in the user interface");
1654         RNA_def_property_ui_icon(prop, ICON_TRIA_RIGHT, 1);
1655         
1656         prop= RNA_def_property(srna, "show_expanded_children", PROP_BOOLEAN, PROP_NONE);
1657         RNA_def_property_boolean_sdna(prop, NULL, "flag", KEYMAP_CHILDREN_EXPANDED);
1658         RNA_def_property_ui_text(prop, "Children Expanded", "Children expanded in the user interface");
1659         RNA_def_property_ui_icon(prop, ICON_TRIA_RIGHT, 1);
1660
1661
1662         RNA_api_keymap(srna);
1663
1664         /* KeyMapItem */
1665         srna= RNA_def_struct(brna, "KeyMapItem", NULL);
1666         RNA_def_struct_sdna(srna, "wmKeyMapItem");
1667         RNA_def_struct_ui_text(srna, "Key Map Item", "Item in a Key Map");
1668
1669         prop= RNA_def_property(srna, "idname", PROP_STRING, PROP_NONE);
1670         RNA_def_property_string_sdna(prop, NULL, "idname");
1671         RNA_def_property_ui_text(prop, "Identifier", "Identifier of operator to call on input event");
1672         RNA_def_property_string_funcs(prop, "rna_wmKeyMapItem_idname_get", "rna_wmKeyMapItem_idname_length", "rna_wmKeyMapItem_idname_set");
1673         RNA_def_struct_name_property(srna, prop);
1674         
1675         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1676         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1677         RNA_def_property_ui_text(prop, "Name", "Name of operator to call on input event");
1678         RNA_def_property_string_funcs(prop, "rna_wmKeyMapItem_name_get", "rna_wmKeyMapItem_name_length", NULL);
1679         
1680         prop= RNA_def_property(srna, "properties", PROP_POINTER, PROP_NONE);
1681         RNA_def_property_struct_type(prop, "OperatorProperties");
1682         RNA_def_property_pointer_funcs(prop, "rna_KeyMapItem_properties_get", NULL, NULL, NULL);
1683         RNA_def_property_ui_text(prop, "Properties", "Properties to set when the operator is called");
1684
1685         prop= RNA_def_property(srna, "map_type", PROP_ENUM, PROP_NONE);
1686         RNA_def_property_enum_sdna(prop, NULL, "maptype");
1687         RNA_def_property_enum_items(prop, map_type_items);
1688         RNA_def_property_enum_funcs(prop, "rna_wmKeyMapItem_map_type_get", "rna_wmKeyMapItem_map_type_set", NULL);
1689         RNA_def_property_ui_text(prop, "Map Type", "Type of event mapping");
1690
1691         prop= RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
1692         RNA_def_property_enum_sdna(prop, NULL, "type");
1693         RNA_def_property_enum_items(prop, event_type_items);
1694         RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_KeyMapItem_type_itemf");
1695         RNA_def_property_ui_text(prop, "Type", "Type of event");
1696
1697         prop= RNA_def_property(srna, "value", PROP_ENUM, PROP_NONE);
1698         RNA_def_property_enum_sdna(prop, NULL, "val");
1699         RNA_def_property_enum_items(prop, event_value_items);
1700         RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_KeyMapItem_value_itemf");
1701         RNA_def_property_ui_text(prop, "Value", "");
1702
1703         prop= RNA_def_property(srna, "id", PROP_INT, PROP_NONE);
1704         RNA_def_property_int_sdna(prop, NULL, "id");
1705         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1706         RNA_def_property_ui_text(prop, "id", "ID of the item");
1707
1708         prop= RNA_def_property(srna, "any", PROP_BOOLEAN, PROP_NONE);
1709         RNA_def_property_boolean_funcs(prop, "rna_KeyMapItem_any_getf", "rna_KeyMapItem_any_setf");
1710         RNA_def_property_ui_text(prop, "Any", "Any modifier keys pressed");
1711
1712         prop= RNA_def_property(srna, "shift", PROP_BOOLEAN, PROP_NONE);
1713         RNA_def_property_boolean_sdna(prop, NULL, "shift", 0);
1714 //      RNA_def_property_enum_sdna(prop, NULL, "shift");
1715 //      RNA_def_property_enum_items(prop, keymap_modifiers_items);
1716         RNA_def_property_ui_text(prop, "Shift", "Shift key pressed");
1717
1718         prop= RNA_def_property(srna, "ctrl", PROP_BOOLEAN, PROP_NONE);
1719         RNA_def_property_boolean_sdna(prop, NULL, "ctrl", 0);
1720 //      RNA_def_property_enum_sdna(prop, NULL, "ctrl");
1721 //      RNA_def_property_enum_items(prop, keymap_modifiers_items);
1722         RNA_def_property_ui_text(prop, "Ctrl", "Control key pressed");
1723
1724         prop= RNA_def_property(srna, "alt", PROP_BOOLEAN, PROP_NONE);
1725         RNA_def_property_boolean_sdna(prop, NULL, "alt", 0);
1726 //      RNA_def_property_enum_sdna(prop, NULL, "alt");
1727 //      RNA_def_property_enum_items(prop, keymap_modifiers_items);
1728         RNA_def_property_ui_text(prop, "Alt", "Alt key pressed");
1729
1730         prop= RNA_def_property(srna, "oskey", PROP_BOOLEAN, PROP_NONE);
1731         RNA_def_property_boolean_sdna(prop, NULL, "oskey", 0);
1732 //      RNA_def_property_enum_sdna(prop, NULL, "oskey");
1733 //      RNA_def_property_enum_items(prop, keymap_modifiers_items);
1734         RNA_def_property_ui_text(prop, "OS Key", "Operating system key pressed");
1735
1736         prop= RNA_def_property(srna, "key_modifier", PROP_ENUM, PROP_NONE);
1737         RNA_def_property_enum_sdna(prop, NULL, "keymodifier");
1738         RNA_def_property_enum_items(prop, event_type_items);
1739         RNA_def_property_ui_text(prop, "Key Modifier", "Regular key pressed as a modifier");
1740
1741         prop= RNA_def_property(srna, "show_expanded", PROP_BOOLEAN, PROP_NONE);
1742         RNA_def_property_boolean_sdna(prop, NULL, "flag", KMI_EXPANDED);
1743         RNA_def_property_ui_text(prop, "Expanded", "Show key map event and property details in the user interface");
1744         RNA_def_property_ui_icon(prop, ICON_TRIA_RIGHT, 1);
1745
1746         prop= RNA_def_property(srna, "propvalue", PROP_ENUM, PROP_NONE);
1747         RNA_def_property_enum_sdna(prop, NULL, "propvalue");
1748         RNA_def_property_enum_items(prop, keymap_propvalue_items);
1749         RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_KeyMapItem_propvalue_itemf");
1750         RNA_def_property_ui_text(prop, "Property Value", "The value this event translates to in a modal keymap");
1751
1752         prop= RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
1753         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", KMI_INACTIVE);
1754         RNA_def_property_ui_text(prop, "Active", "Activate or deactivate item");
1755         RNA_def_property_ui_icon(prop, ICON_CHECKBOX_DEHLT, 1);
1756
1757         prop= RNA_def_property(srna, "is_user_defined", PROP_BOOLEAN, PROP_NONE);
1758         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1759         RNA_def_property_ui_text(prop, "User Defined", "Is this keymap item user defined (doesn't just override a builtin item)");
1760         RNA_def_property_boolean_funcs(prop, "rna_KeyMapItem_userdefined_get", NULL);
1761
1762         RNA_api_keymapitem(srna);
1763 }
1764
1765 void RNA_def_wm(BlenderRNA *brna)
1766 {
1767         rna_def_operator(brna);
1768         rna_def_operator_utils(brna);
1769         rna_def_operator_filelist_element(brna);
1770         rna_def_macro_operator(brna);
1771         rna_def_operator_type_macro(brna);
1772         rna_def_event(brna);
1773         rna_def_window(brna);
1774         rna_def_windowmanager(brna);
1775         rna_def_keyconfig(brna);
1776 }
1777
1778 #endif /* RNA_RUNTIME */
1779