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