Cleanup: indentation, naming
[blender.git] / source / blender / makesrna / intern / rna_wm.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * Contributor(s): Blender Foundation (2008).
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22
23 /** \file blender/makesrna/intern/rna_wm.c
24  *  \ingroup RNA
25  */
26
27 #include <stdlib.h>
28
29 #include "DNA_screen_types.h"
30 #include "DNA_space_types.h"
31 #include "DNA_userdef_types.h"
32 #include "DNA_windowmanager_types.h"
33
34 #include "BLI_utildefines.h"
35 #include "BLI_string_utils.h"
36
37 #include "BLT_translation.h"
38
39 #include "BKE_workspace.h"
40 #include "BKE_keyconfig.h"
41
42 #include "RNA_access.h"
43 #include "RNA_define.h"
44 #include "RNA_enum_types.h"
45
46 #include "rna_internal.h"
47
48 #include "WM_types.h"
49
50 #ifdef RNA_RUNTIME
51 static const EnumPropertyItem event_keymouse_value_items[] = {
52         {KM_ANY, "ANY", 0, "Any", ""},
53         {KM_PRESS, "PRESS", 0, "Press", ""},
54         {KM_RELEASE, "RELEASE", 0, "Release", ""},
55         {KM_CLICK, "CLICK", 0, "Click", ""},
56         {KM_DBL_CLICK, "DOUBLE_CLICK", 0, "Double Click", ""},
57         {KM_CLICK_DRAG, "CLICK_DRAG", 0, "Click Drag", ""},
58         {0, NULL, 0, NULL, NULL}
59 };
60
61 static const EnumPropertyItem event_tweak_value_items[] = {
62         {KM_ANY, "ANY", 0, "Any", ""},
63         {EVT_GESTURE_N, "NORTH", 0, "North", ""},
64         {EVT_GESTURE_NE, "NORTH_EAST", 0, "North-East", ""},
65         {EVT_GESTURE_E, "EAST", 0, "East", ""},
66         {EVT_GESTURE_SE, "SOUTH_EAST", 0, "South-East", ""},
67         {EVT_GESTURE_S, "SOUTH", 0, "South", ""},
68         {EVT_GESTURE_SW, "SOUTH_WEST", 0, "South-West", ""},
69         {EVT_GESTURE_W, "WEST", 0, "West", ""},
70         {EVT_GESTURE_NW, "NORTH_WEST", 0, "North-West", ""},
71         {0, NULL, 0, NULL, NULL}
72 };
73
74 static const EnumPropertyItem event_tweak_type_items[] = {
75         {EVT_TWEAK_L, "EVT_TWEAK_L", 0, "Left", ""},
76         {EVT_TWEAK_M, "EVT_TWEAK_M", 0, "Middle", ""},
77         {EVT_TWEAK_R, "EVT_TWEAK_R", 0, "Right", ""},
78         {0, NULL, 0, NULL, NULL}
79 };
80
81 static const EnumPropertyItem event_mouse_type_items[] = {
82         {LEFTMOUSE, "LEFTMOUSE", 0, "Left", ""},
83         {MIDDLEMOUSE, "MIDDLEMOUSE", 0, "Middle", ""},
84         {RIGHTMOUSE, "RIGHTMOUSE", 0, "Right", ""},
85         {BUTTON4MOUSE, "BUTTON4MOUSE", 0, "Button4", ""},
86         {BUTTON5MOUSE, "BUTTON5MOUSE", 0, "Button5", ""},
87         {BUTTON6MOUSE, "BUTTON6MOUSE", 0, "Button6", ""},
88         {BUTTON7MOUSE, "BUTTON7MOUSE", 0, "Button7", ""},
89         {0, "", 0, NULL, NULL},
90         {TABLET_STYLUS, "PEN", 0, "Pen", ""},
91         {TABLET_ERASER, "ERASER", 0, "Eraser", ""},
92         {0, "", 0, NULL, NULL},
93         {MOUSEMOVE, "MOUSEMOVE", 0, "Move", ""},
94         {MOUSEPAN, "TRACKPADPAN", 0, "Mouse/Trackpad Pan", ""},
95         {MOUSEZOOM, "TRACKPADZOOM", 0, "Mouse/Trackpad Zoom", ""},
96         {MOUSEROTATE, "MOUSEROTATE", 0, "Mouse/Trackpad Rotate", ""},
97         {0, "", 0, NULL, NULL},
98         {WHEELUPMOUSE, "WHEELUPMOUSE", 0, "Wheel Up", ""},
99         {WHEELDOWNMOUSE, "WHEELDOWNMOUSE", 0, "Wheel Down", ""},
100         {WHEELINMOUSE, "WHEELINMOUSE", 0, "Wheel In", ""},
101         {WHEELOUTMOUSE, "WHEELOUTMOUSE", 0, "Wheel Out", ""},
102         {0, NULL, 0, NULL, NULL}
103 };
104
105 static const EnumPropertyItem event_timer_type_items[] = {
106         {TIMER, "TIMER", 0, "Timer", ""},
107         {TIMER0, "TIMER0", 0, "Timer 0", ""},
108         {TIMER1, "TIMER1", 0, "Timer 1", ""},
109         {TIMER2, "TIMER2", 0, "Timer 2", ""},
110         {TIMERJOBS, "TIMER_JOBS", 0, "Timer Jobs", ""},
111         {TIMERAUTOSAVE, "TIMER_AUTOSAVE", 0, "Timer Autosave", ""},
112         {TIMERREPORT, "TIMER_REPORT", 0, "Timer Report", ""},
113         {TIMERREGION, "TIMERREGION", 0, "Timer Region", ""},
114         {0, NULL, 0, NULL, NULL}
115 };
116
117 static const EnumPropertyItem event_textinput_type_items[] = {
118         {KM_TEXTINPUT, "TEXTINPUT", 0, "Text Input", ""},
119         {0, NULL, 0, NULL, NULL}
120 };
121
122 static const EnumPropertyItem event_ndof_type_items[] = {
123         {NDOF_MOTION, "NDOF_MOTION", 0, "Motion", ""},
124         /* buttons on all 3dconnexion devices */
125         {NDOF_BUTTON_MENU, "NDOF_BUTTON_MENU", 0, "Menu", ""},
126         {NDOF_BUTTON_FIT, "NDOF_BUTTON_FIT", 0, "Fit", ""},
127         /* view buttons */
128         {NDOF_BUTTON_TOP, "NDOF_BUTTON_TOP", 0, "Top", ""},
129         {NDOF_BUTTON_BOTTOM, "NDOF_BUTTON_BOTTOM", 0, "Bottom", ""},
130         {NDOF_BUTTON_LEFT, "NDOF_BUTTON_LEFT", 0, "Left", ""},
131         {NDOF_BUTTON_RIGHT, "NDOF_BUTTON_RIGHT", 0, "Right", ""},
132         {NDOF_BUTTON_FRONT, "NDOF_BUTTON_FRONT", 0, "Front", ""},
133         {NDOF_BUTTON_BACK, "NDOF_BUTTON_BACK", 0, "Back", ""},
134         /* more views */
135         {NDOF_BUTTON_ISO1, "NDOF_BUTTON_ISO1", 0, "Isometric 1", ""},
136         {NDOF_BUTTON_ISO2, "NDOF_BUTTON_ISO2", 0, "Isometric 2", ""},
137         /* 90 degree rotations */
138         {NDOF_BUTTON_ROLL_CW, "NDOF_BUTTON_ROLL_CW", 0, "Roll CW", ""},
139         {NDOF_BUTTON_ROLL_CCW, "NDOF_BUTTON_ROLL_CCW", 0, "Roll CCW", ""},
140         {NDOF_BUTTON_SPIN_CW, "NDOF_BUTTON_SPIN_CW", 0, "Spin CW", ""},
141         {NDOF_BUTTON_SPIN_CCW, "NDOF_BUTTON_SPIN_CCW", 0, "Spin CCW", ""},
142         {NDOF_BUTTON_TILT_CW, "NDOF_BUTTON_TILT_CW", 0, "Tilt CW", ""},
143         {NDOF_BUTTON_TILT_CCW, "NDOF_BUTTON_TILT_CCW", 0, "Tilt CCW", ""},
144         /* device control */
145         {NDOF_BUTTON_ROTATE, "NDOF_BUTTON_ROTATE", 0, "Rotate", ""},
146         {NDOF_BUTTON_PANZOOM, "NDOF_BUTTON_PANZOOM", 0, "Pan/Zoom", ""},
147         {NDOF_BUTTON_DOMINANT, "NDOF_BUTTON_DOMINANT", 0, "Dominant", ""},
148         {NDOF_BUTTON_PLUS, "NDOF_BUTTON_PLUS", 0, "Plus", ""},
149         {NDOF_BUTTON_MINUS, "NDOF_BUTTON_MINUS", 0, "Minus", ""},
150         /* keyboard emulation */
151         {NDOF_BUTTON_ESC, "NDOF_BUTTON_ESC", 0, "Esc"},
152         {NDOF_BUTTON_ALT, "NDOF_BUTTON_ALT", 0, "Alt"},
153         {NDOF_BUTTON_SHIFT, "NDOF_BUTTON_SHIFT", 0, "Shift"},
154         {NDOF_BUTTON_CTRL, "NDOF_BUTTON_CTRL", 0, "Ctrl"},
155         /* general-purpose buttons */
156         {NDOF_BUTTON_1, "NDOF_BUTTON_1", 0, "Button 1", ""},
157         {NDOF_BUTTON_2, "NDOF_BUTTON_2", 0, "Button 2", ""},
158         {NDOF_BUTTON_3, "NDOF_BUTTON_3", 0, "Button 3", ""},
159         {NDOF_BUTTON_4, "NDOF_BUTTON_4", 0, "Button 4", ""},
160         {NDOF_BUTTON_5, "NDOF_BUTTON_5", 0, "Button 5", ""},
161         {NDOF_BUTTON_6, "NDOF_BUTTON_6", 0, "Button 6", ""},
162         {NDOF_BUTTON_7, "NDOF_BUTTON_7", 0, "Button 7", ""},
163         {NDOF_BUTTON_8, "NDOF_BUTTON_8", 0, "Button 8", ""},
164         {NDOF_BUTTON_9, "NDOF_BUTTON_9", 0, "Button 9", ""},
165         {NDOF_BUTTON_10, "NDOF_BUTTON_10", 0, "Button 10", ""},
166         {NDOF_BUTTON_A, "NDOF_BUTTON_A", 0, "Button A", ""},
167         {NDOF_BUTTON_B, "NDOF_BUTTON_B", 0, "Button B", ""},
168         {NDOF_BUTTON_C, "NDOF_BUTTON_C", 0, "Button C", ""},
169         {0, NULL, 0, NULL, NULL}
170 };
171 #endif /* RNA_RUNTIME */
172
173 /* not returned: CAPSLOCKKEY, UNKNOWNKEY */
174 const EnumPropertyItem rna_enum_event_type_items[] = {
175         /* Note we abuse 'tooltip' message here to store a 'compact' form of some (too) long names. */
176         {0, "NONE", 0, "", ""},
177         {LEFTMOUSE, "LEFTMOUSE", 0, "Left Mouse", "LMB"},
178         {MIDDLEMOUSE, "MIDDLEMOUSE", 0, "Middle Mouse", "MMB"},
179         {RIGHTMOUSE, "RIGHTMOUSE", 0, "Right Mouse", "RMB"},
180         {BUTTON4MOUSE, "BUTTON4MOUSE", 0, "Button4 Mouse", "MB4"},
181         {BUTTON5MOUSE, "BUTTON5MOUSE", 0, "Button5 Mouse", "MB5"},
182         {BUTTON6MOUSE, "BUTTON6MOUSE", 0, "Button6 Mouse", "MB6"},
183         {BUTTON7MOUSE, "BUTTON7MOUSE", 0, "Button7 Mouse", "MB7"},
184         {0, "", 0, NULL, NULL},
185         {TABLET_STYLUS, "PEN", 0, "Pen", ""},
186         {TABLET_ERASER, "ERASER", 0, "Eraser", ""},
187         {0, "", 0, NULL, NULL},
188         {MOUSEMOVE, "MOUSEMOVE", 0, "Mouse Move", "MsMov"},
189         {INBETWEEN_MOUSEMOVE, "INBETWEEN_MOUSEMOVE", 0, "In-between Move", "MsSubMov"},
190         {MOUSEPAN, "TRACKPADPAN", 0, "Mouse/Trackpad Pan", "MsPan"},
191         {MOUSEZOOM, "TRACKPADZOOM", 0, "Mouse/Trackpad Zoom", "MsZoom"},
192         {MOUSEROTATE, "MOUSEROTATE", 0, "Mouse/Trackpad Rotate", "MsRot"},
193         {0, "", 0, NULL, NULL},
194         {WHEELUPMOUSE, "WHEELUPMOUSE", 0, "Wheel Up", "WhUp"},
195         {WHEELDOWNMOUSE, "WHEELDOWNMOUSE", 0, "Wheel Down", "WhDown"},
196         {WHEELINMOUSE, "WHEELINMOUSE", 0, "Wheel In", "WhIn"},
197         {WHEELOUTMOUSE, "WHEELOUTMOUSE", 0, "Wheel Out", "WhOut"},
198         {0, "", 0, NULL, NULL},
199         {EVT_TWEAK_L, "EVT_TWEAK_L", 0, "Tweak Left", "TwkL"},
200         {EVT_TWEAK_M, "EVT_TWEAK_M", 0, "Tweak Middle", "TwkM"},
201         {EVT_TWEAK_R, "EVT_TWEAK_R", 0, "Tweak Right", "TwkR"},
202         {0, "", 0, NULL, NULL},
203         {AKEY, "A", 0, "A", ""},
204         {BKEY, "B", 0, "B", ""},
205         {CKEY, "C", 0, "C", ""},
206         {DKEY, "D", 0, "D", ""},
207         {EKEY, "E", 0, "E", ""},
208         {FKEY, "F", 0, "F", ""},
209         {GKEY, "G", 0, "G", ""},
210         {HKEY, "H", 0, "H", ""},
211         {IKEY, "I", 0, "I", ""},
212         {JKEY, "J", 0, "J", ""},
213         {KKEY, "K", 0, "K", ""},
214         {LKEY, "L", 0, "L", ""},
215         {MKEY, "M", 0, "M", ""},
216         {NKEY, "N", 0, "N", ""},
217         {OKEY, "O", 0, "O", ""},
218         {PKEY, "P", 0, "P", ""},
219         {QKEY, "Q", 0, "Q", ""},
220         {RKEY, "R", 0, "R", ""},
221         {SKEY, "S", 0, "S", ""},
222         {TKEY, "T", 0, "T", ""},
223         {UKEY, "U", 0, "U", ""},
224         {VKEY, "V", 0, "V", ""},
225         {WKEY, "W", 0, "W", ""},
226         {XKEY, "X", 0, "X", ""},
227         {YKEY, "Y", 0, "Y", ""},
228         {ZKEY, "Z", 0, "Z", ""},
229         {0, "", 0, NULL, NULL},
230         {ZEROKEY, "ZERO",   0, "0", ""},
231         {ONEKEY, "ONE",     0, "1", ""},
232         {TWOKEY, "TWO",     0, "2", ""},
233         {THREEKEY, "THREE", 0, "3", ""},
234         {FOURKEY, "FOUR",   0, "4", ""},
235         {FIVEKEY, "FIVE",   0, "5", ""},
236         {SIXKEY, "SIX",     0, "6", ""},
237         {SEVENKEY, "SEVEN", 0, "7", ""},
238         {EIGHTKEY, "EIGHT", 0, "8", ""},
239         {NINEKEY, "NINE",   0, "9", ""},
240         {0, "", 0, NULL, NULL},
241         {LEFTCTRLKEY,   "LEFT_CTRL",    0, "Left Ctrl", "CtrlL"},
242         {LEFTALTKEY,    "LEFT_ALT",     0, "Left Alt", "AltL"},
243         {LEFTSHIFTKEY,  "LEFT_SHIFT",   0, "Left Shift", "ShiftL"},
244         {RIGHTALTKEY,   "RIGHT_ALT",    0, "Right Alt", "AltR"},
245         {RIGHTCTRLKEY,  "RIGHT_CTRL",   0, "Right Ctrl", "CtrlR"},
246         {RIGHTSHIFTKEY, "RIGHT_SHIFT",  0, "Right Shift", "ShiftR"},
247         {0, "", 0, NULL, NULL},
248         {OSKEY, "OSKEY",    0, "OS Key", "Cmd"},
249         {GRLESSKEY, "GRLESS",   0, "Grless", ""},
250         {ESCKEY, "ESC", 0, "Esc", ""},
251         {TABKEY, "TAB", 0, "Tab", ""},
252         {RETKEY, "RET", 0, "Return", "Enter"},
253         {SPACEKEY, "SPACE", 0, "Spacebar", "Space"},
254         {LINEFEEDKEY, "LINE_FEED", 0, "Line Feed", ""},
255         {BACKSPACEKEY, "BACK_SPACE", 0, "Back Space", "BkSpace"},
256         {DELKEY, "DEL", 0, "Delete", "Del"},
257         {SEMICOLONKEY, "SEMI_COLON", 0, ";", ""},
258         {PERIODKEY, "PERIOD", 0, ".", ""},
259         {COMMAKEY, "COMMA", 0, ",", ""},
260         {QUOTEKEY, "QUOTE", 0, "\"", ""},
261         {ACCENTGRAVEKEY, "ACCENT_GRAVE", 0, "`", ""},
262         {MINUSKEY, "MINUS", 0, "-", ""},
263         {PLUSKEY, "PLUS", 0, "+", ""},
264         {SLASHKEY, "SLASH", 0, "/", ""},
265         {BACKSLASHKEY, "BACK_SLASH", 0, "\\", ""},
266         {EQUALKEY, "EQUAL", 0, "=", ""},
267         {LEFTBRACKETKEY, "LEFT_BRACKET", 0, "[", ""},
268         {RIGHTBRACKETKEY, "RIGHT_BRACKET", 0, "]", ""},
269         {LEFTARROWKEY, "LEFT_ARROW", 0, "Left Arrow", "←"},
270         {DOWNARROWKEY, "DOWN_ARROW", 0, "Down Arrow", "↓"},
271         {RIGHTARROWKEY, "RIGHT_ARROW", 0, "Right Arrow", "→"},
272         {UPARROWKEY, "UP_ARROW", 0, "Up Arrow", "↑"},
273         {PAD2, "NUMPAD_2", 0, "Numpad 2", "Pad2"},
274         {PAD4, "NUMPAD_4", 0, "Numpad 4", "Pad4"},
275         {PAD6, "NUMPAD_6", 0, "Numpad 6", "Pad6"},
276         {PAD8, "NUMPAD_8", 0, "Numpad 8", "Pad8"},
277         {PAD1, "NUMPAD_1", 0, "Numpad 1", "Pad1"},
278         {PAD3, "NUMPAD_3", 0, "Numpad 3", "Pad3"},
279         {PAD5, "NUMPAD_5", 0, "Numpad 5", "Pad5"},
280         {PAD7, "NUMPAD_7", 0, "Numpad 7", "Pad7"},
281         {PAD9, "NUMPAD_9", 0, "Numpad 9", "Pad9"},
282         {PADPERIOD, "NUMPAD_PERIOD", 0, "Numpad .", "Pad."},
283         {PADSLASHKEY, "NUMPAD_SLASH", 0, "Numpad /", "Pad/"},
284         {PADASTERKEY, "NUMPAD_ASTERIX", 0, "Numpad *", "Pad*"},
285         {PAD0, "NUMPAD_0", 0, "Numpad 0", "Pad0"},
286         {PADMINUS, "NUMPAD_MINUS", 0, "Numpad -", "Pad-"},
287         {PADENTER, "NUMPAD_ENTER", 0, "Numpad Enter", "PadEnter"},
288         {PADPLUSKEY, "NUMPAD_PLUS", 0, "Numpad +", "Pad+"},
289         {F1KEY, "F1", 0, "F1", ""},
290         {F2KEY, "F2", 0, "F2", ""},
291         {F3KEY, "F3", 0, "F3", ""},
292         {F4KEY, "F4", 0, "F4", ""},
293         {F5KEY, "F5", 0, "F5", ""},
294         {F6KEY, "F6", 0, "F6", ""},
295         {F7KEY, "F7", 0, "F7", ""},
296         {F8KEY, "F8", 0, "F8", ""},
297         {F9KEY, "F9", 0, "F9", ""},
298         {F10KEY, "F10", 0, "F10", ""},
299         {F11KEY, "F11", 0, "F11", ""},
300         {F12KEY, "F12", 0, "F12", ""},
301         {F13KEY, "F13", 0, "F13", ""},
302         {F14KEY, "F14", 0, "F14", ""},
303         {F15KEY, "F15", 0, "F15", ""},
304         {F16KEY, "F16", 0, "F16", ""},
305         {F17KEY, "F17", 0, "F17", ""},
306         {F18KEY, "F18", 0, "F18", ""},
307         {F19KEY, "F19", 0, "F19", ""},
308         {PAUSEKEY, "PAUSE", 0, "Pause", ""},
309         {INSERTKEY, "INSERT", 0, "Insert", "Ins"},
310         {HOMEKEY, "HOME", 0, "Home", ""},
311         {PAGEUPKEY, "PAGE_UP", 0, "Page Up", "PgUp"},
312         {PAGEDOWNKEY, "PAGE_DOWN", 0, "Page Down", "PgDown"},
313         {ENDKEY, "END", 0, "End", ""},
314         {0, "", 0, NULL, NULL},
315         {MEDIAPLAY, "MEDIA_PLAY", 0, "Media Play/Pause", ">/||"},
316         {MEDIASTOP, "MEDIA_STOP", 0, "Media Stop", "Stop"},
317         {MEDIAFIRST, "MEDIA_FIRST", 0, "Media First", "|<<"},
318         {MEDIALAST, "MEDIA_LAST", 0, "Media Last", ">>|"},
319         {0, "", 0, NULL, NULL},
320         {KM_TEXTINPUT, "TEXTINPUT", 0, "Text Input", "TxtIn"},
321         {0, "", 0, NULL, NULL},
322         {WINDEACTIVATE, "WINDOW_DEACTIVATE", 0, "Window Deactivate", ""},
323         {TIMER, "TIMER", 0, "Timer", "Tmr"},
324         {TIMER0, "TIMER0", 0, "Timer 0", "Tmr0"},
325         {TIMER1, "TIMER1", 0, "Timer 1", "Tmr1"},
326         {TIMER2, "TIMER2", 0, "Timer 2", "Tmr2"},
327         {TIMERJOBS, "TIMER_JOBS", 0, "Timer Jobs", "TmrJob"},
328         {TIMERAUTOSAVE, "TIMER_AUTOSAVE", 0, "Timer Autosave", "TmrSave"},
329         {TIMERREPORT, "TIMER_REPORT", 0, "Timer Report", "TmrReport"},
330         {TIMERREGION, "TIMERREGION", 0, "Timer Region", "TmrReg"},
331         {0, "", 0, NULL, NULL},
332         {NDOF_MOTION, "NDOF_MOTION", 0, "NDOF Motion", "NdofMov"},
333         /* buttons on all 3dconnexion devices */
334         {NDOF_BUTTON_MENU, "NDOF_BUTTON_MENU", 0, "NDOF Menu", "NdofMenu"},
335         {NDOF_BUTTON_FIT, "NDOF_BUTTON_FIT", 0, "NDOF Fit", "NdofFit"},
336         /* view buttons */
337         {NDOF_BUTTON_TOP, "NDOF_BUTTON_TOP", 0, "NDOF Top", "Ndof↑"},
338         {NDOF_BUTTON_BOTTOM, "NDOF_BUTTON_BOTTOM", 0, "NDOF Bottom", "Ndof↓"},
339         {NDOF_BUTTON_LEFT, "NDOF_BUTTON_LEFT", 0, "NDOF Left", "Ndof←"},
340         {NDOF_BUTTON_RIGHT, "NDOF_BUTTON_RIGHT", 0, "NDOF Right", "Ndof→"},
341         {NDOF_BUTTON_FRONT, "NDOF_BUTTON_FRONT", 0, "NDOF Front", "NdofFront"},
342         {NDOF_BUTTON_BACK, "NDOF_BUTTON_BACK", 0, "NDOF Back", "NdofBack"},
343         /* more views */
344         {NDOF_BUTTON_ISO1, "NDOF_BUTTON_ISO1", 0, "NDOF Isometric 1", "NdofIso1"},
345         {NDOF_BUTTON_ISO2, "NDOF_BUTTON_ISO2", 0, "NDOF Isometric 2", "NdofIso2"},
346         /* 90 degree rotations */
347         {NDOF_BUTTON_ROLL_CW, "NDOF_BUTTON_ROLL_CW", 0, "NDOF Roll CW", "NdofRCW"},
348         {NDOF_BUTTON_ROLL_CCW, "NDOF_BUTTON_ROLL_CCW", 0, "NDOF Roll CCW", "NdofRCCW"},
349         {NDOF_BUTTON_SPIN_CW, "NDOF_BUTTON_SPIN_CW", 0, "NDOF Spin CW", "NdofSCW"},
350         {NDOF_BUTTON_SPIN_CCW, "NDOF_BUTTON_SPIN_CCW", 0, "NDOF Spin CCW", "NdofSCCW"},
351         {NDOF_BUTTON_TILT_CW, "NDOF_BUTTON_TILT_CW", 0, "NDOF Tilt CW", "NdofTCW"},
352         {NDOF_BUTTON_TILT_CCW, "NDOF_BUTTON_TILT_CCW", 0, "NDOF Tilt CCW", "NdofTCCW"},
353         /* device control */
354         {NDOF_BUTTON_ROTATE, "NDOF_BUTTON_ROTATE", 0, "NDOF Rotate", "NdofRot"},
355         {NDOF_BUTTON_PANZOOM, "NDOF_BUTTON_PANZOOM", 0, "NDOF Pan/Zoom", "NdofPanZoom"},
356         {NDOF_BUTTON_DOMINANT, "NDOF_BUTTON_DOMINANT", 0, "NDOF Dominant", "NdofDom"},
357         {NDOF_BUTTON_PLUS, "NDOF_BUTTON_PLUS", 0, "NDOF Plus", "Ndof+"},
358         {NDOF_BUTTON_MINUS, "NDOF_BUTTON_MINUS", 0, "NDOF Minus", "Ndof-"},
359         /* keyboard emulation */
360         {NDOF_BUTTON_ESC, "NDOF_BUTTON_ESC", 0, "NDOF Esc", "NdofEsc"},
361         {NDOF_BUTTON_ALT, "NDOF_BUTTON_ALT", 0, "NDOF Alt", "NdofAlt"},
362         {NDOF_BUTTON_SHIFT, "NDOF_BUTTON_SHIFT", 0, "NDOF Shift", "NdofShift"},
363         {NDOF_BUTTON_CTRL, "NDOF_BUTTON_CTRL", 0, "NDOF Ctrl", "NdofCtrl"},
364         /* general-purpose buttons */
365         {NDOF_BUTTON_1, "NDOF_BUTTON_1", 0, "NDOF Button 1", "NdofB1"},
366         {NDOF_BUTTON_2, "NDOF_BUTTON_2", 0, "NDOF Button 2", "NdofB2"},
367         {NDOF_BUTTON_3, "NDOF_BUTTON_3", 0, "NDOF Button 3", "NdofB3"},
368         {NDOF_BUTTON_4, "NDOF_BUTTON_4", 0, "NDOF Button 4", "NdofB4"},
369         {NDOF_BUTTON_5, "NDOF_BUTTON_5", 0, "NDOF Button 5", "NdofB5"},
370         {NDOF_BUTTON_6, "NDOF_BUTTON_6", 0, "NDOF Button 6", "NdofB6"},
371         {NDOF_BUTTON_7, "NDOF_BUTTON_7", 0, "NDOF Button 7", "NdofB7"},
372         {NDOF_BUTTON_8, "NDOF_BUTTON_8", 0, "NDOF Button 8", "NdofB8"},
373         {NDOF_BUTTON_9, "NDOF_BUTTON_9", 0, "NDOF Button 9", "NdofB9"},
374         {NDOF_BUTTON_10, "NDOF_BUTTON_10", 0, "NDOF Button 10", "NdofB10"},
375         {NDOF_BUTTON_A, "NDOF_BUTTON_A", 0, "NDOF Button A", "NdofBA"},
376         {NDOF_BUTTON_B, "NDOF_BUTTON_B", 0, "NDOF Button B", "NdofBB"},
377         {NDOF_BUTTON_C, "NDOF_BUTTON_C", 0, "NDOF Button C", "NdofBC"},
378         /* Action Zones. */
379         {EVT_ACTIONZONE_AREA, "ACTIONZONE_AREA", 0, "ActionZone Area", "AZone Area"},
380         {EVT_ACTIONZONE_REGION, "ACTIONZONE_REGION", 0, "ActionZone Region", "AZone Region"},
381         {EVT_ACTIONZONE_FULLSCREEN, "ACTIONZONE_FULLSCREEN", 0, "ActionZone Fullscreen", "AZone FullScr"},
382         {0, NULL, 0, NULL, NULL}
383 };
384
385 const EnumPropertyItem rna_enum_event_value_items[] = {
386         {KM_ANY, "ANY", 0, "Any", ""},
387         {KM_NOTHING, "NOTHING", 0, "Nothing", ""},
388         {KM_PRESS, "PRESS", 0, "Press", ""},
389         {KM_RELEASE, "RELEASE", 0, "Release", ""},
390         {KM_CLICK, "CLICK", 0, "Click", ""},
391         {KM_DBL_CLICK, "DOUBLE_CLICK", 0, "Double Click", ""},
392         {KM_CLICK_DRAG, "CLICK_DRAG", 0, "Click Drag", ""},
393         {EVT_GESTURE_N, "NORTH", 0, "North", ""},
394         {EVT_GESTURE_NE, "NORTH_EAST", 0, "North-East", ""},
395         {EVT_GESTURE_E, "EAST", 0, "East", ""},
396         {EVT_GESTURE_SE, "SOUTH_EAST", 0, "South-East", ""},
397         {EVT_GESTURE_S, "SOUTH", 0, "South", ""},
398         {EVT_GESTURE_SW, "SOUTH_WEST", 0, "South-West", ""},
399         {EVT_GESTURE_W, "WEST", 0, "West", ""},
400         {EVT_GESTURE_NW, "NORTH_WEST", 0, "North-West", ""},
401         {0, NULL, 0, NULL, NULL}
402 };
403
404 const EnumPropertyItem rna_enum_keymap_propvalue_items[] = {
405         {0, "NONE", 0, "", ""},
406         {0, NULL, 0, NULL, NULL}
407 };
408
409
410 /* Mask event types used in keymap items. */
411 const EnumPropertyItem rna_enum_event_type_mask_items[] = {
412         {EVT_TYPE_MASK_KEYBOARD_MODIFIER, "KEYBOARD_MODIFIER", 0, "Keyboard Modifier", ""},
413         {EVT_TYPE_MASK_KEYBOARD, "KEYBOARD", 0, "Keyboard", ""},
414         {EVT_TYPE_MASK_MOUSE_WHEEL, "MOUSE_WHEEL", 0, "Mouse Wheel", ""},
415         {EVT_TYPE_MASK_MOUSE_GESTURE, "MOUSE_GESTURE", 0, "Mouse Gesture", ""},
416         {EVT_TYPE_MASK_MOUSE_BUTTON, "MOUSE_BUTTON", 0, "Mouse Button", ""},
417         {EVT_TYPE_MASK_MOUSE, "MOUSE", 0, "Mouse", ""},
418         {EVT_TYPE_MASK_NDOF, "NDOF", 0, "NDOF", ""},
419         {EVT_TYPE_MASK_TWEAK, "TWEAK", 0, "Tweak", ""},
420         {EVT_TYPE_MASK_ACTIONZONE, "ACTIONZONE", 0, "Action Zone", ""},
421         {0, NULL, 0, NULL, NULL}
422 };
423
424 #if 0
425 static const EnumPropertyItem keymap_modifiers_items[] = {
426         {KM_ANY, "ANY", 0, "Any", ""},
427         {0, "NONE", 0, "None", ""},
428         {1, "FIRST", 0, "First", ""},
429         {2, "SECOND", 0, "Second", ""},
430         {0, NULL, 0, NULL, NULL}
431 };
432 #endif
433
434
435 #ifndef RNA_RUNTIME
436 static const EnumPropertyItem operator_flag_items[] = {
437         {OPTYPE_REGISTER, "REGISTER", 0, "Register", "Display in the info window and support the redo toolbar panel"},
438         {OPTYPE_UNDO, "UNDO", 0, "Undo", "Push an undo event (needed for operator redo)"},
439         {OPTYPE_UNDO_GROUPED, "UNDO_GROUPED", 0, "Grouped Undo", "Push a single undo event for repetead instances of this operator"},
440         {OPTYPE_BLOCKING, "BLOCKING", 0, "Blocking", "Block anything else from using the cursor"},
441         {OPTYPE_MACRO, "MACRO", 0, "Macro", "Use to check if an operator is a macro"},
442         {OPTYPE_GRAB_CURSOR, "GRAB_CURSOR", 0, "Grab Pointer",
443                               "Use so the operator grabs the mouse focus, enables wrapping when continuous grab "
444                               "is enabled"},
445         {OPTYPE_PRESET, "PRESET", 0, "Preset", "Display a preset button with the operators settings"},
446         {OPTYPE_INTERNAL, "INTERNAL", 0, "Internal", "Removes the operator from search results"},
447         {OPTYPE_USE_EVAL_DATA, "USE_EVAL_DATA", 0, "Use Evaluated Data",
448                                "Uses evaluated data (i.e. needs a valid depsgraph for current context)"},
449         {0, NULL, 0, NULL, NULL}
450 };
451 #endif
452
453 const EnumPropertyItem rna_enum_operator_return_items[] = {
454         {OPERATOR_RUNNING_MODAL, "RUNNING_MODAL", 0, "Running Modal", "Keep the operator running with blender"},
455         {OPERATOR_CANCELLED, "CANCELLED", 0, "Cancelled", "When no action has been taken, operator exits"},
456         {OPERATOR_FINISHED, "FINISHED", 0, "Finished", "When the operator is complete, operator exits"},
457         /* used as a flag */
458         {OPERATOR_PASS_THROUGH, "PASS_THROUGH", 0, "Pass Through", "Do nothing and pass the event on"},
459         {OPERATOR_INTERFACE, "INTERFACE", 0, "Interface", "Handled but not executed (popup menus)"},
460         {0, NULL, 0, NULL, NULL}
461 };
462
463 const EnumPropertyItem rna_enum_operator_property_tags[] = {
464         {OP_PROP_TAG_ADVANCED, "ADVANCED", 0, "Advanced", "The property is advanced so UI is suggested to hide it"},
465         {0, NULL, 0, NULL, NULL}
466 };
467
468 /* flag/enum */
469 const EnumPropertyItem rna_enum_wm_report_items[] = {
470         {RPT_DEBUG, "DEBUG", 0, "Debug", ""},
471         {RPT_INFO, "INFO", 0, "Info", ""},
472         {RPT_OPERATOR, "OPERATOR", 0, "Operator", ""},
473         {RPT_PROPERTY, "PROPERTY", 0, "Property", ""},
474         {RPT_WARNING, "WARNING", 0, "Warning", ""},
475         {RPT_ERROR, "ERROR", 0, "Error", ""},
476         {RPT_ERROR_INVALID_INPUT, "ERROR_INVALID_INPUT", 0, "Invalid Input", ""},
477         {RPT_ERROR_INVALID_CONTEXT, "ERROR_INVALID_CONTEXT", 0, "Invalid Context", ""},
478         {RPT_ERROR_OUT_OF_MEMORY, "ERROR_OUT_OF_MEMORY", 0, "Out of Memory", ""},
479         {0, NULL, 0, NULL, NULL}
480 };
481
482 #ifdef RNA_RUNTIME
483
484 #include <assert.h>
485
486 #include "WM_api.h"
487
488 #include "DNA_object_types.h"
489 #include "DNA_workspace_types.h"
490
491 #include "ED_screen.h"
492
493 #include "UI_interface.h"
494
495 #include "BKE_global.h"
496 #include "BKE_idprop.h"
497
498 #include "MEM_guardedalloc.h"
499
500 #ifdef WITH_PYTHON
501 #  include "BPY_extern.h"
502 #endif
503
504
505 static wmOperator *rna_OperatorProperties_find_operator(PointerRNA *ptr)
506 {
507         wmWindowManager *wm = ptr->id.data;
508
509         if (wm) {
510                 IDProperty *properties = (IDProperty *)ptr->data;
511                 for (wmOperator *op = wm->operators.last; op; op = op->prev) {
512                         if (op->properties == properties) {
513                                 return op;
514                         }
515                 }
516         }
517
518         return NULL;
519 }
520
521 static StructRNA *rna_OperatorProperties_refine(PointerRNA *ptr)
522 {
523         wmOperator *op = rna_OperatorProperties_find_operator(ptr);
524
525         if (op)
526                 return op->type->srna;
527         else
528                 return ptr->type;
529 }
530
531 static IDProperty *rna_OperatorProperties_idprops(PointerRNA *ptr, bool create)
532 {
533         if (create && !ptr->data) {
534                 IDPropertyTemplate val = {0};
535                 ptr->data = IDP_New(IDP_GROUP, &val, "RNA_OperatorProperties group");
536         }
537
538         return ptr->data;
539 }
540
541 static void rna_Operator_name_get(PointerRNA *ptr, char *value)
542 {
543         wmOperator *op = (wmOperator *)ptr->data;
544         strcpy(value, op->type->name);
545 }
546
547 static int rna_Operator_name_length(PointerRNA *ptr)
548 {
549         wmOperator *op = (wmOperator *)ptr->data;
550         return strlen(op->type->name);
551 }
552
553 static bool rna_Operator_has_reports_get(PointerRNA *ptr)
554 {
555         wmOperator *op = (wmOperator *)ptr->data;
556         return (op->reports && op->reports->list.first);
557 }
558
559 static PointerRNA rna_Operator_options_get(PointerRNA *ptr)
560 {
561         return rna_pointer_inherit_refine(ptr, &RNA_OperatorOptions, ptr->data);
562 }
563
564 static PointerRNA rna_Operator_properties_get(PointerRNA *ptr)
565 {
566         wmOperator *op = (wmOperator *)ptr->data;
567         return rna_pointer_inherit_refine(ptr, op->type->srna, op->properties);
568 }
569
570 static PointerRNA rna_OperatorMacro_properties_get(PointerRNA *ptr)
571 {
572         wmOperatorTypeMacro *otmacro = (wmOperatorTypeMacro *)ptr->data;
573         wmOperatorType *ot = WM_operatortype_find(otmacro->idname, true);
574         return rna_pointer_inherit_refine(ptr, ot->srna, otmacro->properties);
575 }
576
577 static void rna_Event_ascii_get(PointerRNA *ptr, char *value)
578 {
579         const wmEvent *event = ptr->data;
580         value[0] = event->ascii;
581         value[1] = '\0';
582 }
583
584 static int rna_Event_ascii_length(PointerRNA *ptr)
585 {
586         const wmEvent *event = ptr->data;
587         return (event->ascii) ? 1 : 0;
588 }
589
590 static void rna_Event_unicode_get(PointerRNA *ptr, char *value)
591 {
592         /* utf8 buf isn't \0 terminated */
593         const wmEvent *event = ptr->data;
594         size_t len = 0;
595
596         if (event->utf8_buf[0]) {
597                 BLI_str_utf8_as_unicode_and_size(event->utf8_buf, &len);
598                 if (len > 0) {
599                         memcpy(value, event->utf8_buf, len);
600                 }
601         }
602
603         value[len] = '\0';
604 }
605
606 static int rna_Event_unicode_length(PointerRNA *ptr)
607 {
608
609         const wmEvent *event = ptr->data;
610         if (event->utf8_buf[0]) {
611                 /* invalid value is checked on assignment so we don't need to account for this */
612                 return BLI_str_utf8_size(event->utf8_buf);
613         }
614         else {
615                 return 0;
616         }
617 }
618
619 static float rna_Event_pressure_get(PointerRNA *ptr)
620 {
621         const wmEvent *event = ptr->data;
622         return WM_event_tablet_data(event, NULL, NULL);
623 }
624
625 static bool rna_Event_is_tablet_get(PointerRNA *ptr)
626 {
627         const wmEvent *event = ptr->data;
628         return WM_event_is_tablet(event);
629 }
630
631 static void rna_Event_tilt_get(PointerRNA *ptr, float *values)
632 {
633         wmEvent *event = ptr->data;
634         WM_event_tablet_data(event, NULL, values);
635 }
636
637 static PointerRNA rna_PopupMenu_layout_get(PointerRNA *ptr)
638 {
639         struct uiPopupMenu *pup = ptr->data;
640         uiLayout *layout = UI_popup_menu_layout(pup);
641
642         PointerRNA rptr;
643         RNA_pointer_create(ptr->id.data, &RNA_UILayout, layout, &rptr);
644
645         return rptr;
646 }
647
648 static PointerRNA rna_PopoverMenu_layout_get(PointerRNA *ptr)
649 {
650         struct uiPopover *pup = ptr->data;
651         uiLayout *layout = UI_popover_layout(pup);
652
653         PointerRNA rptr;
654         RNA_pointer_create(ptr->id.data, &RNA_UILayout, layout, &rptr);
655
656         return rptr;
657 }
658
659 static PointerRNA rna_PieMenu_layout_get(PointerRNA *ptr)
660 {
661         struct uiPieMenu *pie = ptr->data;
662         uiLayout *layout = UI_pie_menu_layout(pie);
663
664         PointerRNA rptr;
665         RNA_pointer_create(ptr->id.data, &RNA_UILayout, layout, &rptr);
666
667         return rptr;
668 }
669
670 static void rna_Window_scene_set(PointerRNA *ptr, PointerRNA value)
671 {
672         wmWindow *win = ptr->data;
673
674         if (value.data == NULL) {
675                 return;
676         }
677
678         win->new_scene = value.data;
679 }
680
681 static void rna_Window_scene_update(bContext *C, PointerRNA *ptr)
682 {
683         Main *bmain = CTX_data_main(C);
684         wmWindow *win = ptr->data;
685
686         /* exception: must use context so notifier gets to the right window  */
687         if (win->new_scene) {
688 #ifdef WITH_PYTHON
689                 BPy_BEGIN_ALLOW_THREADS;
690 #endif
691
692                 WM_window_set_active_scene(bmain, C, win, win->new_scene);
693
694 #ifdef WITH_PYTHON
695                 BPy_END_ALLOW_THREADS;
696 #endif
697
698                 WM_event_add_notifier(C, NC_SCENE | ND_SCENEBROWSE, win->new_scene);
699
700                 if (G.debug & G_DEBUG)
701                         printf("scene set %p\n", win->new_scene);
702
703                 win->new_scene = NULL;
704         }
705 }
706
707 static PointerRNA rna_Window_workspace_get(PointerRNA *ptr)
708 {
709         wmWindow *win = ptr->data;
710         return rna_pointer_inherit_refine(ptr, &RNA_WorkSpace, BKE_workspace_active_get(win->workspace_hook));
711 }
712
713 static void rna_Window_workspace_set(PointerRNA *ptr, PointerRNA value)
714 {
715         wmWindow *win = (wmWindow *)ptr->data;
716
717         /* disallow ID-browsing away from temp screens */
718         if (WM_window_is_temp_screen(win)) {
719                 return;
720         }
721         if (value.data == NULL) {
722                 return;
723         }
724
725         /* exception: can't set workspaces inside of area/region handlers */
726         win->workspace_hook->temp_workspace_store = value.data;
727 }
728
729 static void rna_Window_workspace_update(bContext *C, PointerRNA *ptr)
730 {
731         wmWindow *win = ptr->data;
732         WorkSpace *new_workspace = win->workspace_hook->temp_workspace_store;
733
734         /* exception: can't set screens inside of area/region handlers,
735          * and must use context so notifier gets to the right window */
736         if (new_workspace) {
737                 WM_event_add_notifier(C, NC_SCREEN | ND_WORKSPACE_SET, new_workspace);
738                 win->workspace_hook->temp_workspace_store = NULL;
739         }
740 }
741
742 PointerRNA rna_Window_screen_get(PointerRNA *ptr)
743 {
744         wmWindow *win = ptr->data;
745         return rna_pointer_inherit_refine(ptr, &RNA_Screen, BKE_workspace_active_screen_get(win->workspace_hook));
746 }
747
748 static void rna_Window_screen_set(PointerRNA *ptr, PointerRNA value)
749 {
750         wmWindow *win = ptr->data;
751         WorkSpace *workspace = BKE_workspace_active_get(win->workspace_hook);
752         WorkSpaceLayout *layout_new;
753         const bScreen *screen = BKE_workspace_active_screen_get(win->workspace_hook);
754
755         /* disallow ID-browsing away from temp screens */
756         if (screen->temp) {
757                 return;
758         }
759         if (value.data == NULL) {
760                 return;
761         }
762
763         /* exception: can't set screens inside of area/region handlers */
764         layout_new = BKE_workspace_layout_find(workspace, value.data);
765         win->workspace_hook->temp_layout_store = layout_new;
766 }
767
768 static bool rna_Window_screen_assign_poll(PointerRNA *UNUSED(ptr), PointerRNA value)
769 {
770         bScreen *screen = value.id.data;
771         return !screen->temp;
772 }
773
774 static void rna_workspace_screen_update(bContext *C, PointerRNA *ptr)
775 {
776         wmWindow *win = ptr->data;
777         WorkSpaceLayout *layout_new = win->workspace_hook->temp_layout_store;
778
779         /* exception: can't set screens inside of area/region handlers,
780          * and must use context so notifier gets to the right window */
781         if (layout_new) {
782                 WM_event_add_notifier(C, NC_SCREEN | ND_LAYOUTBROWSE, layout_new);
783                 win->workspace_hook->temp_layout_store = NULL;
784         }
785 }
786
787 static PointerRNA rna_Window_view_layer_get(PointerRNA *ptr)
788 {
789         wmWindow *win = ptr->data;
790         Scene *scene = WM_window_get_active_scene(win);
791         ViewLayer *view_layer = WM_window_get_active_view_layer(win);
792         PointerRNA scene_ptr;
793
794         RNA_id_pointer_create(&scene->id, &scene_ptr);
795         return rna_pointer_inherit_refine(&scene_ptr, &RNA_ViewLayer, view_layer);
796 }
797
798 static void rna_Window_view_layer_set(PointerRNA *ptr, PointerRNA value)
799 {
800         wmWindow *win = ptr->data;
801         ViewLayer *view_layer = value.data;
802
803         WM_window_set_active_view_layer(win, view_layer);
804 }
805
806 static PointerRNA rna_KeyMapItem_properties_get(PointerRNA *ptr)
807 {
808         wmKeyMapItem *kmi = ptr->data;
809
810         if (kmi->ptr)
811                 return *(kmi->ptr);
812
813         /*return rna_pointer_inherit_refine(ptr, &RNA_OperatorProperties, op->properties); */
814         return PointerRNA_NULL;
815 }
816
817 static int rna_wmKeyMapItem_map_type_get(PointerRNA *ptr)
818 {
819         wmKeyMapItem *kmi = ptr->data;
820
821         return WM_keymap_map_type_get(kmi);
822 }
823
824 static void rna_wmKeyMapItem_map_type_set(PointerRNA *ptr, int value)
825 {
826         wmKeyMapItem *kmi = ptr->data;
827         int map_type = rna_wmKeyMapItem_map_type_get(ptr);
828
829         if (value != map_type) {
830                 switch (value) {
831                         case KMI_TYPE_KEYBOARD:
832                                 kmi->type = AKEY;
833                                 kmi->val = KM_PRESS;
834                                 break;
835                         case KMI_TYPE_TWEAK:
836                                 kmi->type = EVT_TWEAK_L;
837                                 kmi->val = KM_ANY;
838                                 break;
839                         case KMI_TYPE_MOUSE:
840                                 kmi->type = LEFTMOUSE;
841                                 kmi->val = KM_PRESS;
842                                 break;
843                         case KMI_TYPE_TEXTINPUT:
844                                 kmi->type = KM_TEXTINPUT;
845                                 kmi->val = KM_NOTHING;
846                                 break;
847                         case KMI_TYPE_TIMER:
848                                 kmi->type = TIMER;
849                                 kmi->val = KM_NOTHING;
850                                 break;
851                         case KMI_TYPE_NDOF:
852                                 kmi->type = NDOF_MOTION;
853                                 kmi->val = KM_NOTHING;
854                                 break;
855                 }
856         }
857 }
858
859 /* assumes value to be an enum from rna_enum_event_type_items */
860 /* function makes sure keymodifiers are only valid keys, ESC keeps it unaltered */
861 static void rna_wmKeyMapItem_keymodifier_set(PointerRNA *ptr, int value)
862 {
863         wmKeyMapItem *kmi = ptr->data;
864
865         /* XXX, this should really be managed in an _itemf function,
866          * giving a list of valid enums, then silently changing them when they are set is not
867          * a good precedent, don't do this unless you have a good reason! */
868         if (value == ESCKEY) {
869                 /* pass */
870         }
871         else if (value >= AKEY) {
872                 kmi->keymodifier = value;
873         }
874         else {
875                 kmi->keymodifier = 0;
876         }
877 }
878
879
880 static const EnumPropertyItem *rna_KeyMapItem_type_itemf(
881         bContext *UNUSED(C), PointerRNA *ptr, PropertyRNA *UNUSED(prop),
882         bool *UNUSED(r_free))
883 {
884         int map_type = rna_wmKeyMapItem_map_type_get(ptr);
885
886         if (map_type == KMI_TYPE_MOUSE) return event_mouse_type_items;
887         if (map_type == KMI_TYPE_TWEAK) return event_tweak_type_items;
888         if (map_type == KMI_TYPE_TIMER) return event_timer_type_items;
889         if (map_type == KMI_TYPE_NDOF) return event_ndof_type_items;
890         if (map_type == KMI_TYPE_TEXTINPUT) return event_textinput_type_items;
891         else return rna_enum_event_type_items;
892 }
893
894 static const EnumPropertyItem *rna_KeyMapItem_value_itemf(
895         bContext *UNUSED(C), PointerRNA *ptr, PropertyRNA *UNUSED(prop),
896         bool *UNUSED(r_free))
897 {
898         int map_type = rna_wmKeyMapItem_map_type_get(ptr);
899
900         if (map_type == KMI_TYPE_MOUSE || map_type == KMI_TYPE_KEYBOARD || map_type == KMI_TYPE_NDOF)
901                 return event_keymouse_value_items;
902         if (map_type == KMI_TYPE_TWEAK)
903                 return event_tweak_value_items;
904         else
905                 return rna_enum_event_value_items;
906 }
907
908 static const EnumPropertyItem *rna_KeyMapItem_propvalue_itemf(
909         bContext *C, PointerRNA *ptr, PropertyRNA *UNUSED(prop),
910         bool *UNUSED(r_free))
911 {
912         wmWindowManager *wm = CTX_wm_manager(C);
913         wmKeyConfig *kc;
914         wmKeyMap *km;
915
916         for (kc = wm->keyconfigs.first; kc; kc = kc->next) {
917                 for (km = kc->keymaps.first; km; km = km->next) {
918                         /* only check if it's a modal keymap */
919                         if (km->modal_items) {
920                                 wmKeyMapItem *kmi;
921                                 for (kmi = km->items.first; kmi; kmi = kmi->next) {
922                                         if (kmi == ptr->data) {
923                                                 return km->modal_items;
924                                         }
925                                 }
926                         }
927                 }
928         }
929
930
931         return rna_enum_keymap_propvalue_items; /* ERROR */
932 }
933
934 static bool rna_KeyMapItem_any_get(PointerRNA *ptr)
935 {
936         wmKeyMapItem *kmi = (wmKeyMapItem *)ptr->data;
937
938         if (kmi->shift == KM_ANY &&
939             kmi->ctrl == KM_ANY &&
940             kmi->alt == KM_ANY &&
941             kmi->oskey == KM_ANY)
942         {
943                 return 1;
944         }
945         else {
946                 return 0;
947         }
948 }
949
950 static void rna_KeyMapItem_any_set(PointerRNA *ptr, bool value)
951 {
952         wmKeyMapItem *kmi = (wmKeyMapItem *)ptr->data;
953
954         if (value) {
955                 kmi->shift = kmi->ctrl = kmi->alt = kmi->oskey = KM_ANY;
956         }
957         else {
958                 kmi->shift = kmi->ctrl = kmi->alt = kmi->oskey = 0;
959         }
960 }
961
962 static bool rna_KeyMapItem_shift_get(PointerRNA *ptr)
963 {
964         wmKeyMapItem *kmi = (wmKeyMapItem *)ptr->data;
965         return kmi->shift != 0;
966 }
967
968 static bool rna_KeyMapItem_ctrl_get(PointerRNA *ptr)
969 {
970         wmKeyMapItem *kmi = (wmKeyMapItem *)ptr->data;
971         return kmi->ctrl != 0;
972 }
973
974 static bool rna_KeyMapItem_alt_get(PointerRNA *ptr)
975 {
976         wmKeyMapItem *kmi = (wmKeyMapItem *)ptr->data;
977         return kmi->alt != 0;
978 }
979
980 static bool rna_KeyMapItem_oskey_get(PointerRNA *ptr)
981 {
982         wmKeyMapItem *kmi = (wmKeyMapItem *)ptr->data;
983         return kmi->oskey != 0;
984 }
985
986 static PointerRNA rna_WindowManager_active_keyconfig_get(PointerRNA *ptr)
987 {
988         wmWindowManager *wm = ptr->data;
989         wmKeyConfig *kc;
990
991         kc = BLI_findstring(&wm->keyconfigs, U.keyconfigstr, offsetof(wmKeyConfig, idname));
992
993         if (!kc)
994                 kc = wm->defaultconf;
995
996         return rna_pointer_inherit_refine(ptr, &RNA_KeyConfig, kc);
997 }
998
999 static void rna_WindowManager_active_keyconfig_set(PointerRNA *ptr, PointerRNA value)
1000 {
1001         wmWindowManager *wm = ptr->data;
1002         wmKeyConfig *kc = value.data;
1003
1004         if (kc)
1005                 WM_keyconfig_set_active(wm, kc->idname);
1006 }
1007
1008 /* -------------------------------------------------------------------- */
1009 /** \name Key Config Preferences
1010  * \{ */
1011
1012 static PointerRNA rna_wmKeyConfig_preferences_get(PointerRNA *ptr)
1013 {
1014         wmKeyConfig *kc = ptr->data;
1015         wmKeyConfigPrefType_Runtime *kpt_rt = BKE_keyconfig_pref_type_find(kc->idname, true);
1016         if (kpt_rt) {
1017                 wmKeyConfigPref *kpt = BKE_keyconfig_pref_ensure(&U, kc->idname);
1018                 return rna_pointer_inherit_refine(ptr, kpt_rt->ext.srna, kpt->prop);
1019         }
1020         else {
1021                 return PointerRNA_NULL;
1022         }
1023 }
1024
1025 static IDProperty *rna_wmKeyConfigPref_idprops(PointerRNA *ptr, bool create)
1026 {
1027         if (create && !ptr->data) {
1028                 IDPropertyTemplate val = {0};
1029                 ptr->data = IDP_New(IDP_GROUP, &val, "RNA_KeyConfigPreferences group");
1030         }
1031         return ptr->data;
1032 }
1033
1034 static void rna_wmKeyConfigPref_unregister(Main *UNUSED(bmain), StructRNA *type)
1035 {
1036         wmKeyConfigPrefType_Runtime *kpt_rt = RNA_struct_blender_type_get(type);
1037
1038         if (!kpt_rt)
1039                 return;
1040
1041         RNA_struct_free_extension(type, &kpt_rt->ext);
1042         RNA_struct_free(&BLENDER_RNA, type);
1043
1044         /* Possible we're not in the preferences if they have been reset. */
1045         BKE_keyconfig_pref_type_remove(kpt_rt);
1046
1047         /* update while blender is running */
1048         WM_main_add_notifier(NC_WINDOW, NULL);
1049 }
1050
1051 static StructRNA *rna_wmKeyConfigPref_register(
1052         Main *bmain, ReportList *reports, void *data, const char *identifier,
1053         StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
1054 {
1055         wmKeyConfigPrefType_Runtime *kpt_rt, dummy_kpt_rt = {{'\0'}};
1056         wmKeyConfigPref dummy_kpt = {NULL};
1057         PointerRNA dummy_ptr;
1058         // int have_function[1];
1059
1060         /* setup dummy keyconf-prefs & keyconf-prefs type to store static properties in */
1061         RNA_pointer_create(NULL, &RNA_KeyConfigPreferences, &dummy_kpt, &dummy_ptr);
1062
1063         /* validate the python class */
1064         if (validate(&dummy_ptr, data, NULL /* have_function */ ) != 0)
1065                 return NULL;
1066
1067         STRNCPY(dummy_kpt_rt.idname, dummy_kpt.idname);
1068         if (strlen(identifier) >= sizeof(dummy_kpt_rt.idname)) {
1069                 BKE_reportf(reports, RPT_ERROR, "Registering key-config preferences class: '%s' is too long, maximum length is %d",
1070                             identifier, (int)sizeof(dummy_kpt_rt.idname));
1071                 return NULL;
1072         }
1073
1074         /* check if we have registered this keyconf-prefs type before, and remove it */
1075         kpt_rt = BKE_keyconfig_pref_type_find(dummy_kpt.idname, true);
1076         if (kpt_rt && kpt_rt->ext.srna) {
1077                 rna_wmKeyConfigPref_unregister(bmain, kpt_rt->ext.srna);
1078         }
1079
1080         /* create a new keyconf-prefs type */
1081         kpt_rt = MEM_mallocN(sizeof(wmKeyConfigPrefType_Runtime), "keyconfigpreftype");
1082         memcpy(kpt_rt, &dummy_kpt_rt, sizeof(dummy_kpt_rt));
1083
1084         BKE_keyconfig_pref_type_add(kpt_rt);
1085
1086         kpt_rt->ext.srna = RNA_def_struct_ptr(&BLENDER_RNA, identifier, &RNA_KeyConfigPreferences);
1087         kpt_rt->ext.data = data;
1088         kpt_rt->ext.call = call;
1089         kpt_rt->ext.free = free;
1090         RNA_struct_blender_type_set(kpt_rt->ext.srna, kpt_rt);
1091
1092 //      kpt_rt->draw = (have_function[0]) ? header_draw : NULL;
1093
1094         /* update while blender is running */
1095         WM_main_add_notifier(NC_WINDOW, NULL);
1096
1097         return kpt_rt->ext.srna;
1098 }
1099
1100 /* placeholder, doesn't do anything useful yet */
1101 static StructRNA *rna_wmKeyConfigPref_refine(PointerRNA *ptr)
1102 {
1103         return (ptr->type) ? ptr->type : &RNA_KeyConfigPreferences;
1104 }
1105
1106 /** \} */
1107
1108
1109 static void rna_wmKeyMapItem_idname_get(PointerRNA *ptr, char *value)
1110 {
1111         wmKeyMapItem *kmi = ptr->data;
1112         WM_operator_py_idname(value, kmi->idname);
1113 }
1114
1115 static int rna_wmKeyMapItem_idname_length(PointerRNA *ptr)
1116 {
1117         wmKeyMapItem *kmi = ptr->data;
1118         char pyname[OP_MAX_TYPENAME];
1119
1120         WM_operator_py_idname(pyname, kmi->idname);
1121         return strlen(pyname);
1122 }
1123
1124 static void rna_wmKeyMapItem_idname_set(PointerRNA *ptr, const char *value)
1125 {
1126         wmKeyMapItem *kmi = ptr->data;
1127         char idname[OP_MAX_TYPENAME];
1128
1129         WM_operator_bl_idname(idname, value);
1130
1131         if (!STREQ(idname, kmi->idname)) {
1132                 BLI_strncpy(kmi->idname, idname, sizeof(kmi->idname));
1133
1134                 WM_keymap_properties_reset(kmi, NULL);
1135         }
1136 }
1137
1138 static void rna_wmKeyMapItem_name_get(PointerRNA *ptr, char *value)
1139 {
1140         wmKeyMapItem *kmi = ptr->data;
1141         wmOperatorType *ot = WM_operatortype_find(kmi->idname, 1);
1142         strcpy(value, ot ? RNA_struct_ui_name(ot->srna) : kmi->idname);
1143 }
1144
1145 static int rna_wmKeyMapItem_name_length(PointerRNA *ptr)
1146 {
1147         wmKeyMapItem *kmi = ptr->data;
1148         wmOperatorType *ot = WM_operatortype_find(kmi->idname, 1);
1149         return strlen(ot ? RNA_struct_ui_name(ot->srna) : kmi->idname);
1150 }
1151
1152 static bool rna_KeyMapItem_userdefined_get(PointerRNA *ptr)
1153 {
1154         wmKeyMapItem *kmi = ptr->data;
1155         return kmi->id < 0;
1156 }
1157
1158 static void rna_wmClipboard_get(PointerRNA *UNUSED(ptr), char *value)
1159 {
1160         char *pbuf;
1161         int pbuf_len;
1162
1163         pbuf = WM_clipboard_text_get(false, &pbuf_len);
1164         if (pbuf) {
1165                 memcpy(value, pbuf, pbuf_len + 1);
1166                 MEM_freeN(pbuf);
1167         }
1168         else {
1169                 value[0] = '\0';
1170         }
1171 }
1172
1173 static int rna_wmClipboard_length(PointerRNA *UNUSED(ptr))
1174 {
1175         char *pbuf;
1176         int pbuf_len;
1177
1178         pbuf = WM_clipboard_text_get(false, &pbuf_len);
1179         if (pbuf) {
1180                 MEM_freeN(pbuf);
1181         }
1182
1183         return pbuf_len;
1184 }
1185
1186 static void rna_wmClipboard_set(PointerRNA *UNUSED(ptr), const char *value)
1187 {
1188         WM_clipboard_text_set((void *) value, false);
1189 }
1190
1191 #ifdef WITH_PYTHON
1192
1193 static bool rna_operator_poll_cb(bContext *C, wmOperatorType *ot)
1194 {
1195         extern FunctionRNA rna_Operator_poll_func;
1196
1197         PointerRNA ptr;
1198         ParameterList list;
1199         FunctionRNA *func;
1200         void *ret;
1201         bool visible;
1202
1203         RNA_pointer_create(NULL, ot->ext.srna, NULL, &ptr); /* dummy */
1204         func = &rna_Operator_poll_func; /* RNA_struct_find_function(&ptr, "poll"); */
1205
1206         RNA_parameter_list_create(&list, &ptr, func);
1207         RNA_parameter_set_lookup(&list, "context", &C);
1208         ot->ext.call(C, &ptr, func, &list);
1209
1210         RNA_parameter_get_lookup(&list, "visible", &ret);
1211         visible = *(bool *)ret;
1212
1213         RNA_parameter_list_free(&list);
1214
1215         return visible;
1216 }
1217
1218 static int rna_operator_execute_cb(bContext *C, wmOperator *op)
1219 {
1220         extern FunctionRNA rna_Operator_execute_func;
1221
1222         PointerRNA opr;
1223         ParameterList list;
1224         FunctionRNA *func;
1225         void *ret;
1226         int result;
1227
1228         RNA_pointer_create(NULL, op->type->ext.srna, op, &opr);
1229         func = &rna_Operator_execute_func; /* RNA_struct_find_function(&opr, "execute"); */
1230
1231         RNA_parameter_list_create(&list, &opr, func);
1232         RNA_parameter_set_lookup(&list, "context", &C);
1233         op->type->ext.call(C, &opr, func, &list);
1234
1235         RNA_parameter_get_lookup(&list, "result", &ret);
1236         result = *(int *)ret;
1237
1238         RNA_parameter_list_free(&list);
1239
1240         return result;
1241 }
1242
1243 /* same as execute() but no return value */
1244 static bool rna_operator_check_cb(bContext *C, wmOperator *op)
1245 {
1246         extern FunctionRNA rna_Operator_check_func;
1247
1248         PointerRNA opr;
1249         ParameterList list;
1250         FunctionRNA *func;
1251         void *ret;
1252         bool result;
1253
1254         RNA_pointer_create(NULL, op->type->ext.srna, op, &opr);
1255         func = &rna_Operator_check_func; /* RNA_struct_find_function(&opr, "check"); */
1256
1257         RNA_parameter_list_create(&list, &opr, func);
1258         RNA_parameter_set_lookup(&list, "context", &C);
1259         op->type->ext.call(C, &opr, func, &list);
1260
1261         RNA_parameter_get_lookup(&list, "result", &ret);
1262         result = (*(bool *)ret) != 0;
1263
1264         RNA_parameter_list_free(&list);
1265
1266         return result;
1267 }
1268
1269 static int rna_operator_invoke_cb(bContext *C, wmOperator *op, const wmEvent *event)
1270 {
1271         extern FunctionRNA rna_Operator_invoke_func;
1272
1273         PointerRNA opr;
1274         ParameterList list;
1275         FunctionRNA *func;
1276         void *ret;
1277         int result;
1278
1279         RNA_pointer_create(NULL, op->type->ext.srna, op, &opr);
1280         func = &rna_Operator_invoke_func; /* RNA_struct_find_function(&opr, "invoke"); */
1281
1282         RNA_parameter_list_create(&list, &opr, func);
1283         RNA_parameter_set_lookup(&list, "context", &C);
1284         RNA_parameter_set_lookup(&list, "event", &event);
1285         op->type->ext.call(C, &opr, func, &list);
1286
1287         RNA_parameter_get_lookup(&list, "result", &ret);
1288         result = *(int *)ret;
1289
1290         RNA_parameter_list_free(&list);
1291
1292         return result;
1293 }
1294
1295 /* same as invoke */
1296 static int rna_operator_modal_cb(bContext *C, wmOperator *op, const wmEvent *event)
1297 {
1298         extern FunctionRNA rna_Operator_modal_func;
1299
1300         PointerRNA opr;
1301         ParameterList list;
1302         FunctionRNA *func;
1303         void *ret;
1304         int result;
1305
1306         RNA_pointer_create(NULL, op->type->ext.srna, op, &opr);
1307         func = &rna_Operator_modal_func; /* RNA_struct_find_function(&opr, "modal"); */
1308
1309         RNA_parameter_list_create(&list, &opr, func);
1310         RNA_parameter_set_lookup(&list, "context", &C);
1311         RNA_parameter_set_lookup(&list, "event", &event);
1312         op->type->ext.call(C, &opr, func, &list);
1313
1314         RNA_parameter_get_lookup(&list, "result", &ret);
1315         result = *(int *)ret;
1316
1317         RNA_parameter_list_free(&list);
1318
1319         return result;
1320 }
1321
1322 static void rna_operator_draw_cb(bContext *C, wmOperator *op)
1323 {
1324         extern FunctionRNA rna_Operator_draw_func;
1325
1326         PointerRNA opr;
1327         ParameterList list;
1328         FunctionRNA *func;
1329
1330         RNA_pointer_create(NULL, op->type->ext.srna, op, &opr);
1331         func = &rna_Operator_draw_func; /* RNA_struct_find_function(&opr, "draw"); */
1332
1333         RNA_parameter_list_create(&list, &opr, func);
1334         RNA_parameter_set_lookup(&list, "context", &C);
1335         op->type->ext.call(C, &opr, func, &list);
1336
1337         RNA_parameter_list_free(&list);
1338 }
1339
1340 /* same as exec(), but call cancel */
1341 static void rna_operator_cancel_cb(bContext *C, wmOperator *op)
1342 {
1343         extern FunctionRNA rna_Operator_cancel_func;
1344
1345         PointerRNA opr;
1346         ParameterList list;
1347         FunctionRNA *func;
1348
1349         RNA_pointer_create(NULL, op->type->ext.srna, op, &opr);
1350         func = &rna_Operator_cancel_func; /* RNA_struct_find_function(&opr, "cancel"); */
1351
1352         RNA_parameter_list_create(&list, &opr, func);
1353         RNA_parameter_set_lookup(&list, "context", &C);
1354         op->type->ext.call(C, &opr, func, &list);
1355
1356         RNA_parameter_list_free(&list);
1357 }
1358
1359 static void rna_Operator_unregister(struct Main *bmain, StructRNA *type);
1360
1361 /* bpy_operator_wrap.c */
1362 extern void BPY_RNA_operator_wrapper(wmOperatorType *ot, void *userdata);
1363 extern void BPY_RNA_operator_macro_wrapper(wmOperatorType *ot, void *userdata);
1364
1365 static StructRNA *rna_Operator_register(
1366         Main *bmain, ReportList *reports, void *data, const char *identifier,
1367         StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
1368 {
1369         wmOperatorType dummyot = {NULL};
1370         wmOperator dummyop = {NULL};
1371         PointerRNA dummyotr;
1372         int have_function[7];
1373
1374         struct {
1375                 char idname[OP_MAX_TYPENAME];
1376                 char name[OP_MAX_TYPENAME];
1377                 char description[RNA_DYN_DESCR_MAX];
1378                 char translation_context[RNA_DYN_DESCR_MAX];
1379                 char undo_group[OP_MAX_TYPENAME];
1380         } temp_buffers;
1381
1382         /* setup dummy operator & operator type to store static properties in */
1383         dummyop.type = &dummyot;
1384         dummyot.idname = temp_buffers.idname; /* only assigne the pointer, string is NULL'd */
1385         dummyot.name = temp_buffers.name; /* only assigne the pointer, string is NULL'd */
1386         dummyot.description = temp_buffers.description; /* only assigne the pointer, string is NULL'd */
1387         dummyot.translation_context = temp_buffers.translation_context; /* only assigne the pointer, string is NULL'd */
1388         dummyot.undo_group = temp_buffers.undo_group; /* only assigne the pointer, string is NULL'd */
1389         RNA_pointer_create(NULL, &RNA_Operator, &dummyop, &dummyotr);
1390
1391         /* clear in case they are left unset */
1392         temp_buffers.idname[0] = temp_buffers.name[0] = temp_buffers.description[0] = temp_buffers.undo_group[0] = '\0';
1393         /* We have to set default op context! */
1394         strcpy(temp_buffers.translation_context, BLT_I18NCONTEXT_OPERATOR_DEFAULT);
1395
1396         /* validate the python class */
1397         if (validate(&dummyotr, data, have_function) != 0)
1398                 return NULL;
1399
1400         /* check if we have registered this operator type before, and remove it */
1401         {
1402                 wmOperatorType *ot = WM_operatortype_find(dummyot.idname, true);
1403                 if (ot && ot->ext.srna)
1404                         rna_Operator_unregister(bmain, ot->ext.srna);
1405         }
1406
1407         if (!WM_operator_py_idname_ok_or_report(reports, identifier, dummyot.idname)) {
1408                 return NULL;
1409         }
1410
1411         char idname_conv[sizeof(dummyop.idname)];
1412         WM_operator_bl_idname(idname_conv, dummyot.idname); /* convert the idname from python */
1413
1414         if (!RNA_struct_available_or_report(reports, idname_conv)) {
1415                 return NULL;
1416         }
1417
1418         /* Convert foo.bar to FOO_OT_bar
1419          * allocate all strings at once. */
1420         {
1421                 const char *strings[] = {
1422                         idname_conv,
1423                         temp_buffers.name,
1424                         temp_buffers.description,
1425                         temp_buffers.translation_context,
1426                         temp_buffers.undo_group,
1427                 };
1428                 char *strings_table[ARRAY_SIZE(strings)];
1429                 BLI_string_join_array_by_sep_char_with_tableN('\0', strings_table, strings, ARRAY_SIZE(strings));
1430
1431                 dummyot.idname = strings_table[0];  /* allocated string stored here */
1432                 dummyot.name = strings_table[1];
1433                 dummyot.description = *strings_table[2] ? strings_table[2] : NULL;
1434                 dummyot.translation_context = strings_table[3];
1435                 dummyot.undo_group = strings_table[4];
1436                 BLI_assert(ARRAY_SIZE(strings) == 5);
1437         }
1438
1439         /* XXX, this doubles up with the operator name [#29666]
1440          * for now just remove from dir(bpy.types) */
1441
1442         /* create a new operator type */
1443         dummyot.ext.srna = RNA_def_struct_ptr(&BLENDER_RNA, dummyot.idname, &RNA_Operator);
1444         RNA_def_struct_flag(dummyot.ext.srna, STRUCT_NO_IDPROPERTIES); /* operator properties are registered separately */
1445         RNA_def_struct_property_tags(dummyot.ext.srna, rna_enum_operator_property_tags);
1446         RNA_def_struct_translation_context(dummyot.ext.srna, dummyot.translation_context);
1447         dummyot.ext.data = data;
1448         dummyot.ext.call = call;
1449         dummyot.ext.free = free;
1450
1451         dummyot.pyop_poll = (have_function[0]) ? rna_operator_poll_cb : NULL;
1452         dummyot.exec =      (have_function[1]) ? rna_operator_execute_cb : NULL;
1453         dummyot.check =     (have_function[2]) ? rna_operator_check_cb : NULL;
1454         dummyot.invoke =    (have_function[3]) ? rna_operator_invoke_cb : NULL;
1455         dummyot.modal =     (have_function[4]) ? rna_operator_modal_cb : NULL;
1456         dummyot.ui =        (have_function[5]) ? rna_operator_draw_cb : NULL;
1457         dummyot.cancel =    (have_function[6]) ? rna_operator_cancel_cb : NULL;
1458         WM_operatortype_append_ptr(BPY_RNA_operator_wrapper, (void *)&dummyot);
1459
1460         /* update while blender is running */
1461         WM_main_add_notifier(NC_SCREEN | NA_EDITED, NULL);
1462
1463         return dummyot.ext.srna;
1464 }
1465
1466 static void rna_Operator_unregister(struct Main *bmain, StructRNA *type)
1467 {
1468         const char *idname;
1469         wmOperatorType *ot = RNA_struct_blender_type_get(type);
1470         wmWindowManager *wm;
1471
1472         if (!ot)
1473                 return;
1474
1475         /* update while blender is running */
1476         wm = bmain->wm.first;
1477         if (wm) {
1478                 WM_operator_stack_clear(wm);
1479
1480                 WM_operator_handlers_clear(wm, ot);
1481         }
1482         WM_main_add_notifier(NC_SCREEN | NA_EDITED, NULL);
1483
1484         RNA_struct_free_extension(type, &ot->ext);
1485
1486         idname = ot->idname;
1487         WM_operatortype_remove_ptr(ot);
1488
1489         /* not to be confused with the RNA_struct_free that WM_operatortype_remove calls, they are 2 different srna's */
1490         RNA_struct_free(&BLENDER_RNA, type);
1491
1492         MEM_freeN((void *)idname);
1493 }
1494
1495 static void **rna_Operator_instance(PointerRNA *ptr)
1496 {
1497         wmOperator *op = ptr->data;
1498         return &op->py_instance;
1499 }
1500
1501 static StructRNA *rna_MacroOperator_register(
1502         Main *bmain, ReportList *reports, void *data, const char *identifier,
1503         StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
1504 {
1505         wmOperatorType dummyot = {NULL};
1506         wmOperator dummyop = {NULL};
1507         PointerRNA dummyotr;
1508         int have_function[4];
1509
1510         struct {
1511                 char idname[OP_MAX_TYPENAME];
1512                 char name[OP_MAX_TYPENAME];
1513                 char description[RNA_DYN_DESCR_MAX];
1514                 char translation_context[RNA_DYN_DESCR_MAX];
1515                 char undo_group[OP_MAX_TYPENAME];
1516         } temp_buffers;
1517
1518         /* setup dummy operator & operator type to store static properties in */
1519         dummyop.type = &dummyot;
1520         dummyot.idname = temp_buffers.idname; /* only assigne the pointer, string is NULL'd */
1521         dummyot.name = temp_buffers.name; /* only assigne the pointer, string is NULL'd */
1522         dummyot.description = temp_buffers.description; /* only assigne the pointer, string is NULL'd */
1523         dummyot.translation_context = temp_buffers.translation_context; /* only assigne the pointer, string is NULL'd */
1524         dummyot.undo_group = temp_buffers.undo_group; /* only assigne the pointer, string is NULL'd */
1525         RNA_pointer_create(NULL, &RNA_Macro, &dummyop, &dummyotr);
1526
1527         /* clear in case they are left unset */
1528         temp_buffers.idname[0] = temp_buffers.name[0] = temp_buffers.description[0] = temp_buffers.undo_group[0] = '\0';
1529         /* We have to set default op context! */
1530         strcpy(temp_buffers.translation_context, BLT_I18NCONTEXT_OPERATOR_DEFAULT);
1531
1532         /* validate the python class */
1533         if (validate(&dummyotr, data, have_function) != 0)
1534                 return NULL;
1535
1536         if (strlen(identifier) >= sizeof(dummyop.idname)) {
1537                 BKE_reportf(reports, RPT_ERROR, "Registering operator class: '%s' is too long, maximum length is %d",
1538                             identifier, (int)sizeof(dummyop.idname));
1539                 return NULL;
1540         }
1541
1542         /* check if we have registered this operator type before, and remove it */
1543         {
1544                 wmOperatorType *ot = WM_operatortype_find(dummyot.idname, true);
1545                 if (ot && ot->ext.srna)
1546                         rna_Operator_unregister(bmain, ot->ext.srna);
1547         }
1548
1549         if (!WM_operator_py_idname_ok_or_report(reports, identifier, dummyot.idname)) {
1550                 return NULL;
1551         }
1552
1553         char idname_conv[sizeof(dummyop.idname)];
1554         WM_operator_bl_idname(idname_conv, dummyot.idname); /* convert the idname from python */
1555
1556         if (!RNA_struct_available_or_report(reports, idname_conv)) {
1557                 return NULL;
1558         }
1559
1560         /* Convert foo.bar to FOO_OT_bar
1561          * allocate all strings at once. */
1562         {
1563                 const char *strings[] = {
1564                         idname_conv,
1565                         temp_buffers.name,
1566                         temp_buffers.description,
1567                         temp_buffers.translation_context,
1568                         temp_buffers.undo_group,
1569                 };
1570                 char *strings_table[ARRAY_SIZE(strings)];
1571                 BLI_string_join_array_by_sep_char_with_tableN('\0', strings_table, strings, ARRAY_SIZE(strings));
1572
1573                 dummyot.idname = strings_table[0];  /* allocated string stored here */
1574                 dummyot.name = strings_table[1];
1575                 dummyot.description = *strings_table[2] ? strings_table[2] : NULL;
1576                 dummyot.translation_context = strings_table[3];
1577                 dummyot.undo_group = strings_table[4];
1578                 BLI_assert(ARRAY_SIZE(strings) == 5);
1579         }
1580
1581         /* XXX, this doubles up with the operator name [#29666]
1582          * for now just remove from dir(bpy.types) */
1583
1584         /* create a new operator type */
1585         dummyot.ext.srna = RNA_def_struct_ptr(&BLENDER_RNA, dummyot.idname, &RNA_Operator);
1586         RNA_def_struct_translation_context(dummyot.ext.srna, dummyot.translation_context);
1587         dummyot.ext.data = data;
1588         dummyot.ext.call = call;
1589         dummyot.ext.free = free;
1590
1591         dummyot.pyop_poll = (have_function[0]) ? rna_operator_poll_cb : NULL;
1592         dummyot.ui =        (have_function[3]) ? rna_operator_draw_cb : NULL;
1593
1594         WM_operatortype_append_macro_ptr(BPY_RNA_operator_macro_wrapper, (void *)&dummyot);
1595
1596         /* update while blender is running */
1597         WM_main_add_notifier(NC_SCREEN | NA_EDITED, NULL);
1598
1599         return dummyot.ext.srna;
1600 }
1601 #endif /* WITH_PYTHON */
1602
1603 static StructRNA *rna_Operator_refine(PointerRNA *opr)
1604 {
1605         wmOperator *op = (wmOperator *)opr->data;
1606         return (op->type && op->type->ext.srna) ? op->type->ext.srna : &RNA_Operator;
1607 }
1608
1609 static StructRNA *rna_MacroOperator_refine(PointerRNA *opr)
1610 {
1611         wmOperator *op = (wmOperator *)opr->data;
1612         return (op->type && op->type->ext.srna) ? op->type->ext.srna : &RNA_Macro;
1613 }
1614
1615 /* just to work around 'const char *' warning and to ensure this is a python op */
1616 static void rna_Operator_bl_idname_set(PointerRNA *ptr, const char *value)
1617 {
1618         wmOperator *data = (wmOperator *)(ptr->data);
1619         char *str = (char *)data->type->idname;
1620         if (!str[0])
1621                 BLI_strncpy(str, value, OP_MAX_TYPENAME);    /* utf8 already ensured */
1622         else
1623                 assert(!"setting the bl_idname on a non-builtin operator");
1624 }
1625
1626 static void rna_Operator_bl_label_set(PointerRNA *ptr, const char *value)
1627 {
1628         wmOperator *data = (wmOperator *)(ptr->data);
1629         char *str = (char *)data->type->name;
1630         if (!str[0])
1631                 BLI_strncpy(str, value, OP_MAX_TYPENAME);    /* utf8 already ensured */
1632         else
1633                 assert(!"setting the bl_label on a non-builtin operator");
1634 }
1635
1636 static void rna_Operator_bl_translation_context_set(PointerRNA *ptr, const char *value)
1637 {
1638         wmOperator *data = (wmOperator *)(ptr->data);
1639         char *str = (char *)data->type->translation_context;
1640         if (!str[0])
1641                 BLI_strncpy(str, value, RNA_DYN_DESCR_MAX);    /* utf8 already ensured */
1642         else
1643                 assert(!"setting the bl_translation_context on a non-builtin operator");
1644 }
1645
1646 static void rna_Operator_bl_description_set(PointerRNA *ptr, const char *value)
1647 {
1648         wmOperator *data = (wmOperator *)(ptr->data);
1649         char *str = (char *)data->type->description;
1650         if (!str[0])
1651                 BLI_strncpy(str, value, RNA_DYN_DESCR_MAX);    /* utf8 already ensured */
1652         else
1653                 assert(!"setting the bl_description on a non-builtin operator");
1654 }
1655
1656 static void rna_Operator_bl_undo_group_set(PointerRNA *ptr, const char *value)
1657 {
1658         wmOperator *data = (wmOperator *)(ptr->data);
1659         char *str = (char *)data->type->undo_group;
1660         if (!str[0])
1661                 BLI_strncpy(str, value, OP_MAX_TYPENAME);    /* utf8 already ensured */
1662         else
1663                 assert(!"setting the bl_undo_group on a non-builtin operator");
1664 }
1665
1666 static void rna_KeyMapItem_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
1667 {
1668         wmKeyMapItem *kmi = ptr->data;
1669         WM_keyconfig_update_tag(NULL, kmi);
1670 }
1671
1672 #else /* RNA_RUNTIME */
1673
1674 /**
1675  * expose ``Operator.options`` as its own type so we can control each flags use (some are read-only).
1676  */
1677 static void rna_def_operator_options_runtime(BlenderRNA *brna)
1678 {
1679         StructRNA *srna;
1680         PropertyRNA *prop;
1681
1682         srna = RNA_def_struct(brna, "OperatorOptions", NULL);
1683         RNA_def_struct_ui_text(srna, "Operator Options", "Runtime options");
1684         RNA_def_struct_sdna(srna, "wmOperator");
1685
1686         prop = RNA_def_property(srna, "is_grab_cursor", PROP_BOOLEAN, PROP_BOOLEAN);
1687         RNA_def_property_boolean_sdna(prop, NULL, "flag", OP_IS_MODAL_GRAB_CURSOR);
1688         RNA_def_property_ui_text(prop, "Grab Cursor", "True when the cursor is grabbed");
1689         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1690
1691         prop = RNA_def_property(srna, "is_invoke", PROP_BOOLEAN, PROP_BOOLEAN);
1692         RNA_def_property_boolean_sdna(prop, NULL, "flag", OP_IS_INVOKE);
1693         RNA_def_property_ui_text(prop, "Invoke", "True when invoked (even if only the execute callbacks available)");
1694         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1695
1696         prop = RNA_def_property(srna, "is_repeat", PROP_BOOLEAN, PROP_BOOLEAN);
1697         RNA_def_property_boolean_sdna(prop, NULL, "flag", OP_IS_REPEAT);
1698         RNA_def_property_ui_text(prop, "Repeat", "True when run from the redo panel");
1699         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1700
1701         prop = RNA_def_property(srna, "use_cursor_region", PROP_BOOLEAN, PROP_BOOLEAN);
1702         RNA_def_property_boolean_sdna(prop, NULL, "flag", OP_IS_MODAL_CURSOR_REGION);
1703         RNA_def_property_ui_text(prop, "Focus Region", "Enable to use the region under the cursor for modal execution");
1704 }
1705
1706 static void rna_def_operator(BlenderRNA *brna)
1707 {
1708         StructRNA *srna;
1709         PropertyRNA *prop;
1710
1711         srna = RNA_def_struct(brna, "Operator", NULL);
1712         RNA_def_struct_ui_text(srna, "Operator", "Storage of an operator being executed, or registered after execution");
1713         RNA_def_struct_sdna(srna, "wmOperator");
1714         RNA_def_struct_refine_func(srna, "rna_Operator_refine");
1715 #ifdef WITH_PYTHON
1716         RNA_def_struct_register_funcs(srna, "rna_Operator_register", "rna_Operator_unregister", "rna_Operator_instance");
1717 #endif
1718         RNA_def_struct_translation_context(srna, BLT_I18NCONTEXT_OPERATOR_DEFAULT);
1719         RNA_def_struct_flag(srna, STRUCT_PUBLIC_NAMESPACE_INHERIT);
1720
1721         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1722         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1723         RNA_def_property_string_funcs(prop, "rna_Operator_name_get", "rna_Operator_name_length", NULL);
1724         RNA_def_property_ui_text(prop, "Name", "");
1725
1726         prop = RNA_def_property(srna, "properties", PROP_POINTER, PROP_NONE);
1727         RNA_def_property_flag(prop, PROP_NEVER_NULL);
1728         RNA_def_property_struct_type(prop, "OperatorProperties");
1729         RNA_def_property_ui_text(prop, "Properties", "");
1730         RNA_def_property_pointer_funcs(prop, "rna_Operator_properties_get", NULL, NULL, NULL);
1731
1732         prop = RNA_def_property(srna, "has_reports", PROP_BOOLEAN, PROP_NONE);
1733         RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* this is 'virtual' property */
1734         RNA_def_property_boolean_funcs(prop, "rna_Operator_has_reports_get", NULL);
1735         RNA_def_property_ui_text(prop, "Has Reports",
1736                                  "Operator has a set of reports (warnings and errors) from last execution");
1737
1738         prop = RNA_def_property(srna, "layout", PROP_POINTER, PROP_NONE);
1739         RNA_def_property_struct_type(prop, "UILayout");
1740
1741         prop = RNA_def_property(srna, "options", PROP_POINTER, PROP_NONE);
1742         RNA_def_property_flag(prop, PROP_NEVER_NULL);
1743         RNA_def_property_struct_type(prop, "OperatorOptions");
1744         RNA_def_property_pointer_funcs(prop, "rna_Operator_options_get", NULL, NULL, NULL);
1745         RNA_def_property_ui_text(prop, "Options", "Runtime options");
1746
1747         /* Registration */
1748         prop = RNA_def_property(srna, "bl_idname", PROP_STRING, PROP_NONE);
1749         RNA_def_property_string_sdna(prop, NULL, "type->idname");
1750         /* else it uses the pointer size!. -3 because '.' -> '_OT_' */
1751         RNA_def_property_string_maxlength(prop, OP_MAX_TYPENAME - 3);
1752         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_Operator_bl_idname_set");
1753         /* RNA_def_property_clear_flag(prop, PROP_EDITABLE); */
1754         RNA_def_property_flag(prop, PROP_REGISTER);
1755         RNA_def_struct_name_property(srna, prop);
1756
1757         prop = RNA_def_property(srna, "bl_label", PROP_STRING, PROP_NONE);
1758         RNA_def_property_string_sdna(prop, NULL, "type->name");
1759         RNA_def_property_string_maxlength(prop, RNA_DYN_DESCR_MAX); /* else it uses the pointer size! */
1760         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_Operator_bl_label_set");
1761         /* RNA_def_property_clear_flag(prop, PROP_EDITABLE); */
1762         RNA_def_property_flag(prop, PROP_REGISTER);
1763
1764         prop = RNA_def_property(srna, "bl_translation_context", PROP_STRING, PROP_NONE);
1765         RNA_def_property_string_sdna(prop, NULL, "type->translation_context");
1766         RNA_def_property_string_maxlength(prop, RNA_DYN_DESCR_MAX); /* else it uses the pointer size! */
1767         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_Operator_bl_translation_context_set");
1768         RNA_def_property_string_default(prop, BLT_I18NCONTEXT_OPERATOR_DEFAULT);
1769         RNA_def_property_flag(prop, PROP_REGISTER_OPTIONAL);
1770         RNA_def_property_clear_flag(prop, PROP_NEVER_NULL); /* check for NULL */
1771
1772         prop = RNA_def_property(srna, "bl_description", PROP_STRING, PROP_NONE);
1773         RNA_def_property_string_sdna(prop, NULL, "type->description");
1774         RNA_def_property_string_maxlength(prop, RNA_DYN_DESCR_MAX); /* else it uses the pointer size! */
1775         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_Operator_bl_description_set");
1776         /* RNA_def_property_clear_flag(prop, PROP_EDITABLE); */
1777         RNA_def_property_flag(prop, PROP_REGISTER_OPTIONAL);
1778         RNA_def_property_clear_flag(prop, PROP_NEVER_NULL); /* check for NULL */
1779
1780         prop = RNA_def_property(srna, "bl_undo_group", PROP_STRING, PROP_NONE);
1781         RNA_def_property_string_sdna(prop, NULL, "type->undo_group");
1782         RNA_def_property_string_maxlength(prop, OP_MAX_TYPENAME); /* else it uses the pointer size! */
1783         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_Operator_bl_undo_group_set");
1784         /* RNA_def_property_clear_flag(prop, PROP_EDITABLE); */
1785         RNA_def_property_flag(prop, PROP_REGISTER_OPTIONAL);
1786         RNA_def_property_clear_flag(prop, PROP_NEVER_NULL); /* check for NULL */
1787
1788         prop = RNA_def_property(srna, "bl_options", PROP_ENUM, PROP_NONE);
1789         RNA_def_property_enum_sdna(prop, NULL, "type->flag");
1790         RNA_def_property_enum_items(prop, operator_flag_items);
1791         RNA_def_property_flag(prop, PROP_REGISTER_OPTIONAL | PROP_ENUM_FLAG);
1792         RNA_def_property_ui_text(prop, "Options",  "Options for this operator type");
1793
1794         prop = RNA_def_property(srna, "macros", PROP_COLLECTION, PROP_NONE);
1795         RNA_def_property_collection_sdna(prop, NULL, "macro", NULL);
1796         RNA_def_property_struct_type(prop, "Macro");
1797         RNA_def_property_ui_text(prop, "Macros", "");
1798
1799         RNA_api_operator(srna);
1800
1801         srna = RNA_def_struct(brna, "OperatorProperties", NULL);
1802         RNA_def_struct_ui_text(srna, "Operator Properties", "Input properties of an Operator");
1803         RNA_def_struct_refine_func(srna, "rna_OperatorProperties_refine");
1804         RNA_def_struct_idprops_func(srna, "rna_OperatorProperties_idprops");
1805         RNA_def_struct_property_tags(srna, rna_enum_operator_property_tags);
1806         RNA_def_struct_flag(srna, STRUCT_NO_DATABLOCK_IDPROPERTIES);
1807 }
1808
1809 static void rna_def_macro_operator(BlenderRNA *brna)
1810 {
1811         StructRNA *srna;
1812         PropertyRNA *prop;
1813
1814         srna = RNA_def_struct(brna, "Macro", NULL);
1815         RNA_def_struct_ui_text(srna, "Macro Operator",
1816                                "Storage of a macro operator being executed, or registered after execution");
1817         RNA_def_struct_sdna(srna, "wmOperator");
1818         RNA_def_struct_refine_func(srna, "rna_MacroOperator_refine");
1819 #ifdef WITH_PYTHON
1820         RNA_def_struct_register_funcs(srna, "rna_MacroOperator_register", "rna_Operator_unregister",
1821                                       "rna_Operator_instance");
1822 #endif
1823         RNA_def_struct_translation_context(srna, BLT_I18NCONTEXT_OPERATOR_DEFAULT);
1824         RNA_def_struct_flag(srna, STRUCT_PUBLIC_NAMESPACE_INHERIT);
1825
1826         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1827         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1828         RNA_def_property_string_funcs(prop, "rna_Operator_name_get", "rna_Operator_name_length", NULL);
1829         RNA_def_property_ui_text(prop, "Name", "");
1830
1831         prop = RNA_def_property(srna, "properties", PROP_POINTER, PROP_NONE);
1832         RNA_def_property_flag(prop, PROP_NEVER_NULL);
1833         RNA_def_property_struct_type(prop, "OperatorProperties");
1834         RNA_def_property_ui_text(prop, "Properties", "");
1835         RNA_def_property_pointer_funcs(prop, "rna_Operator_properties_get", NULL, NULL, NULL);
1836
1837         /* Registration */
1838         prop = RNA_def_property(srna, "bl_idname", PROP_STRING, PROP_NONE);
1839         RNA_def_property_string_sdna(prop, NULL, "type->idname");
1840         RNA_def_property_string_maxlength(prop, OP_MAX_TYPENAME); /* else it uses the pointer size! */
1841         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_Operator_bl_idname_set");
1842         /* RNA_def_property_clear_flag(prop, PROP_EDITABLE); */
1843         RNA_def_property_flag(prop, PROP_REGISTER);
1844         RNA_def_struct_name_property(srna, prop);
1845
1846         prop = RNA_def_property(srna, "bl_label", PROP_STRING, PROP_NONE);
1847         RNA_def_property_string_sdna(prop, NULL, "type->name");
1848         RNA_def_property_string_maxlength(prop, RNA_DYN_DESCR_MAX); /* else it uses the pointer size! */
1849         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_Operator_bl_label_set");
1850         /* RNA_def_property_clear_flag(prop, PROP_EDITABLE); */
1851         RNA_def_property_flag(prop, PROP_REGISTER);
1852
1853         prop = RNA_def_property(srna, "bl_translation_context", PROP_STRING, PROP_NONE);
1854         RNA_def_property_string_sdna(prop, NULL, "type->translation_context");
1855         RNA_def_property_string_maxlength(prop, RNA_DYN_DESCR_MAX); /* else it uses the pointer size! */
1856         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_Operator_bl_translation_context_set");
1857         RNA_def_property_string_default(prop, BLT_I18NCONTEXT_OPERATOR_DEFAULT);
1858         RNA_def_property_flag(prop, PROP_REGISTER_OPTIONAL);
1859         RNA_def_property_clear_flag(prop, PROP_NEVER_NULL); /* check for NULL */
1860
1861         prop = RNA_def_property(srna, "bl_description", PROP_STRING, PROP_NONE);
1862         RNA_def_property_string_sdna(prop, NULL, "type->description");
1863         RNA_def_property_string_maxlength(prop, RNA_DYN_DESCR_MAX); /* else it uses the pointer size! */
1864         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_Operator_bl_description_set");
1865         /* RNA_def_property_clear_flag(prop, PROP_EDITABLE); */
1866         RNA_def_property_flag(prop, PROP_REGISTER_OPTIONAL);
1867         RNA_def_property_clear_flag(prop, PROP_NEVER_NULL); /* check for NULL */
1868
1869         prop = RNA_def_property(srna, "bl_undo_group", PROP_STRING, PROP_NONE);
1870         RNA_def_property_string_sdna(prop, NULL, "type->undo_group");
1871         RNA_def_property_string_maxlength(prop, OP_MAX_TYPENAME); /* else it uses the pointer size! */
1872         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_Operator_bl_undo_group_set");
1873         /* RNA_def_property_clear_flag(prop, PROP_EDITABLE); */
1874         RNA_def_property_flag(prop, PROP_REGISTER_OPTIONAL);
1875         RNA_def_property_clear_flag(prop, PROP_NEVER_NULL); /* check for NULL */
1876
1877         prop = RNA_def_property(srna, "bl_options", PROP_ENUM, PROP_NONE);
1878         RNA_def_property_enum_sdna(prop, NULL, "type->flag");
1879         RNA_def_property_enum_items(prop, operator_flag_items);
1880         RNA_def_property_flag(prop, PROP_REGISTER_OPTIONAL | PROP_ENUM_FLAG);
1881         RNA_def_property_ui_text(prop, "Options",  "Options for this operator type");
1882
1883         RNA_api_macro(srna);
1884 }
1885
1886 static void rna_def_operator_type_macro(BlenderRNA *brna)
1887 {
1888         StructRNA *srna;
1889         PropertyRNA *prop;
1890
1891         srna = RNA_def_struct(brna, "OperatorMacro", NULL);
1892         RNA_def_struct_ui_text(srna, "Operator Macro", "Storage of a sub operator in a macro after it has been added");
1893         RNA_def_struct_sdna(srna, "wmOperatorTypeMacro");
1894
1895 /*      prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE); */
1896 /*      RNA_def_property_clear_flag(prop, PROP_EDITABLE); */
1897 /*      RNA_def_property_string_sdna(prop, NULL, "idname"); */
1898 /*      RNA_def_property_ui_text(prop, "Name", "Name of the sub operator"); */
1899 /*      RNA_def_struct_name_property(srna, prop); */
1900
1901         prop = RNA_def_property(srna, "properties", PROP_POINTER, PROP_NONE);
1902         RNA_def_property_flag(prop, PROP_NEVER_NULL);
1903         RNA_def_property_struct_type(prop, "OperatorProperties");
1904         RNA_def_property_ui_text(prop, "Properties", "");
1905         RNA_def_property_pointer_funcs(prop, "rna_OperatorMacro_properties_get", NULL, NULL, NULL);
1906 }
1907
1908 static void rna_def_operator_utils(BlenderRNA *brna)
1909 {
1910         StructRNA *srna;
1911         PropertyRNA *prop;
1912
1913         srna = RNA_def_struct(brna, "OperatorMousePath", "PropertyGroup");
1914         RNA_def_struct_ui_text(srna, "Operator Mouse Path", "Mouse path values for operators that record such paths");
1915
1916         prop = RNA_def_property(srna, "loc", PROP_FLOAT, PROP_XYZ);
1917         RNA_def_property_flag(prop, PROP_IDPROPERTY);
1918         RNA_def_property_array(prop, 2);
1919         RNA_def_property_ui_text(prop, "Location", "Mouse location");
1920
1921         prop = RNA_def_property(srna, "time", PROP_FLOAT, PROP_NONE);
1922         RNA_def_property_flag(prop, PROP_IDPROPERTY);
1923         RNA_def_property_ui_text(prop, "Time", "Time of mouse location");
1924 }
1925
1926 static void rna_def_operator_filelist_element(BlenderRNA *brna)
1927 {
1928         StructRNA *srna;
1929         PropertyRNA *prop;
1930
1931         srna = RNA_def_struct(brna, "OperatorFileListElement", "PropertyGroup");
1932         RNA_def_struct_ui_text(srna, "Operator File List Element", "");
1933
1934
1935         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_FILENAME);
1936         RNA_def_property_flag(prop, PROP_IDPROPERTY);
1937         RNA_def_property_ui_text(prop, "Name", "Name of a file or directory within a file list");
1938 }
1939
1940 static void rna_def_event(BlenderRNA *brna)
1941 {
1942         StructRNA *srna;
1943         PropertyRNA *prop;
1944
1945         srna = RNA_def_struct(brna, "Event", NULL);
1946         RNA_def_struct_ui_text(srna, "Event", "Window Manager Event");
1947         RNA_def_struct_sdna(srna, "wmEvent");
1948
1949         RNA_define_verify_sdna(0); /* not in sdna */
1950
1951         /* strings */
1952         prop = RNA_def_property(srna, "ascii", PROP_STRING, PROP_NONE);
1953         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1954         RNA_def_property_string_funcs(prop, "rna_Event_ascii_get", "rna_Event_ascii_length", NULL);
1955         RNA_def_property_ui_text(prop, "ASCII", "Single ASCII character for this event");
1956
1957
1958         prop = RNA_def_property(srna, "unicode", PROP_STRING, PROP_NONE);
1959         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1960         RNA_def_property_string_funcs(prop, "rna_Event_unicode_get", "rna_Event_unicode_length", NULL);
1961         RNA_def_property_ui_text(prop, "Unicode", "Single unicode character for this event");
1962
1963         /* enums */
1964         prop = RNA_def_property(srna, "value", PROP_ENUM, PROP_NONE);
1965         RNA_def_property_enum_sdna(prop, NULL, "val");
1966         RNA_def_property_enum_items(prop, rna_enum_event_value_items);
1967         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1968         RNA_def_property_ui_text(prop, "Value",  "The type of event, only applies to some");
1969
1970         prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
1971         RNA_def_property_enum_sdna(prop, NULL, "type");
1972         RNA_def_property_enum_items(prop, rna_enum_event_type_items);
1973         RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_UI_EVENTS);
1974         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1975         RNA_def_property_ui_text(prop, "Type",  "");
1976
1977
1978         /* mouse */
1979         prop = RNA_def_property(srna, "mouse_x", PROP_INT, PROP_NONE);
1980         RNA_def_property_int_sdna(prop, NULL, "x");
1981         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1982         RNA_def_property_ui_text(prop, "Mouse X Position", "The window relative horizontal location of the mouse");
1983
1984         prop = RNA_def_property(srna, "mouse_y", PROP_INT, PROP_NONE);
1985         RNA_def_property_int_sdna(prop, NULL, "y");
1986         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1987         RNA_def_property_ui_text(prop, "Mouse Y Position", "The window relative vertical location of the mouse");
1988
1989         prop = RNA_def_property(srna, "mouse_region_x", PROP_INT, PROP_NONE);
1990         RNA_def_property_int_sdna(prop, NULL, "mval[0]");
1991         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1992         RNA_def_property_ui_text(prop, "Mouse X Position", "The region relative horizontal location of the mouse");
1993
1994         prop = RNA_def_property(srna, "mouse_region_y", PROP_INT, PROP_NONE);
1995         RNA_def_property_int_sdna(prop, NULL, "mval[1]");
1996         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1997         RNA_def_property_ui_text(prop, "Mouse Y Position", "The region relative vertical location of the mouse");
1998
1999         prop = RNA_def_property(srna, "mouse_prev_x", PROP_INT, PROP_NONE);
2000         RNA_def_property_int_sdna(prop, NULL, "prevx");
2001         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2002         RNA_def_property_ui_text(prop, "Mouse Previous X Position", "The window relative horizontal location of the mouse");
2003
2004         prop = RNA_def_property(srna, "mouse_prev_y", PROP_INT, PROP_NONE);
2005         RNA_def_property_int_sdna(prop, NULL, "prevy");
2006         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2007         RNA_def_property_ui_text(prop, "Mouse Previous Y Position", "The window relative vertical location of the mouse");
2008
2009         prop = RNA_def_property(srna, "pressure", PROP_FLOAT, PROP_NONE);
2010         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2011         RNA_def_property_float_funcs(prop, "rna_Event_pressure_get", NULL, NULL);
2012         RNA_def_property_ui_text(prop, "Tablet Pressure", "The pressure of the tablet or 1.0 if no tablet present");
2013
2014         prop = RNA_def_property(srna, "tilt", PROP_FLOAT, PROP_XYZ_LENGTH);
2015         RNA_def_property_array(prop, 2);
2016         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2017         RNA_def_property_float_funcs(prop, "rna_Event_tilt_get", NULL, NULL);
2018         RNA_def_property_ui_text(prop, "Tablet Tilt", "The pressure of the tablet or zeroes if no tablet present");
2019
2020         prop = RNA_def_property(srna, "is_tablet", PROP_BOOLEAN, PROP_NONE);
2021         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2022         RNA_def_property_boolean_funcs(prop, "rna_Event_is_tablet_get", NULL);
2023         RNA_def_property_ui_text(prop, "Is Tablet", "The event has tablet data");
2024
2025         prop = RNA_def_property(srna, "is_mouse_absolute", PROP_BOOLEAN, PROP_NONE);
2026         RNA_def_property_boolean_sdna(prop, NULL, "is_motion_absolute", 1);
2027         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2028         RNA_def_property_ui_text(prop, "Absolute Motion", "The last motion event was an absolute input");
2029
2030         /* modifiers */
2031         prop = RNA_def_property(srna, "shift", PROP_BOOLEAN, PROP_NONE);
2032         RNA_def_property_boolean_sdna(prop, NULL, "shift", 1);
2033         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2034         RNA_def_property_ui_text(prop, "Shift", "True when the Shift key is held");
2035
2036         prop = RNA_def_property(srna, "ctrl", PROP_BOOLEAN, PROP_NONE);
2037         RNA_def_property_boolean_sdna(prop, NULL, "ctrl", 1);
2038         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2039         RNA_def_property_ui_text(prop, "Ctrl", "True when the Ctrl key is held");
2040
2041         prop = RNA_def_property(srna, "alt", PROP_BOOLEAN, PROP_NONE);
2042         RNA_def_property_boolean_sdna(prop, NULL, "alt", 1);
2043         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2044         RNA_def_property_ui_text(prop, "Alt", "True when the Alt/Option key is held");
2045
2046         prop = RNA_def_property(srna, "oskey", PROP_BOOLEAN, PROP_NONE);
2047         RNA_def_property_boolean_sdna(prop, NULL, "oskey", 1);
2048         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2049         RNA_def_property_ui_text(prop, "OS Key", "True when the Cmd key is held");
2050
2051         RNA_define_verify_sdna(1); /* not in sdna */
2052 }
2053
2054 static void rna_def_timer(BlenderRNA *brna)
2055 {
2056         StructRNA *srna;
2057         PropertyRNA *prop;
2058
2059         srna = RNA_def_struct(brna, "Timer", NULL);
2060         RNA_def_struct_ui_text(srna, "Timer", "Window event timer");
2061         RNA_def_struct_sdna(srna, "wmTimer");
2062
2063         RNA_define_verify_sdna(0); /* not in sdna */
2064
2065         /* could wrap more, for now this is enough */
2066         prop = RNA_def_property(srna, "time_step", PROP_FLOAT, PROP_NONE);
2067         RNA_def_property_float_sdna(prop, NULL, "timestep");
2068         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2069         RNA_def_property_ui_text(prop, "Time Step", "");
2070
2071         prop = RNA_def_property(srna, "time_delta", PROP_FLOAT, PROP_NONE);
2072         RNA_def_property_float_sdna(prop, NULL, "delta");
2073         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2074         RNA_def_property_ui_text(prop, "Delta", "Time since last step in seconds");
2075
2076         prop = RNA_def_property(srna, "time_duration", PROP_FLOAT, PROP_NONE);
2077         RNA_def_property_float_sdna(prop, NULL, "duration");
2078         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2079         RNA_def_property_ui_text(prop, "Delta", "Time since last step in seconds");
2080
2081         RNA_define_verify_sdna(1); /* not in sdna */
2082 }
2083
2084 static void rna_def_popup_menu_wrapper(
2085         BlenderRNA *brna, const char *rna_type, const char *c_type, const char *layout_get_fn)
2086 {
2087         StructRNA *srna;
2088         PropertyRNA *prop;
2089
2090         srna = RNA_def_struct(brna, rna_type, NULL);
2091         /* UI name isn't visible, name same as type. */
2092         RNA_def_struct_ui_text(srna, rna_type, "");
2093         RNA_def_struct_sdna(srna, c_type);
2094
2095         RNA_define_verify_sdna(0); /* not in sdna */
2096
2097         /* could wrap more, for now this is enough */
2098         prop = RNA_def_property(srna, "layout", PROP_POINTER, PROP_NONE);
2099         RNA_def_property_struct_type(prop, "UILayout");
2100         RNA_def_property_pointer_funcs(prop, layout_get_fn,
2101                                        NULL, NULL, NULL);
2102
2103         RNA_define_verify_sdna(1); /* not in sdna */
2104 }
2105
2106 static void rna_def_popupmenu(BlenderRNA *brna)
2107 {
2108         rna_def_popup_menu_wrapper(brna, "UIPopupMenu", "uiPopupMenu", "rna_PopupMenu_layout_get");
2109 }
2110
2111 static void rna_def_popovermenu(BlenderRNA *brna)
2112 {
2113         rna_def_popup_menu_wrapper(brna, "UIPopover", "uiPopover", "rna_PopoverMenu_layout_get");
2114 }
2115
2116 static void rna_def_piemenu(BlenderRNA *brna)
2117 {
2118         rna_def_popup_menu_wrapper(brna, "UIPieMenu", "uiPieMenu", "rna_PieMenu_layout_get");
2119 }
2120
2121 static void rna_def_window_stereo3d(BlenderRNA *brna)
2122 {
2123         StructRNA *srna;
2124         PropertyRNA *prop;
2125
2126         srna = RNA_def_struct(brna, "Stereo3dDisplay", NULL);
2127         RNA_def_struct_sdna(srna, "Stereo3dFormat");
2128         RNA_def_struct_clear_flag(srna, STRUCT_UNDO);
2129         RNA_def_struct_ui_text(srna, "Stereo 3D Display", "Settings for stereo 3D display");
2130
2131         prop = RNA_def_property(srna, "display_mode", PROP_ENUM, PROP_NONE);
2132         RNA_def_property_enum_items(prop, rna_enum_stereo3d_display_items);
2133         RNA_def_property_ui_text(prop, "Display Mode", "");
2134
2135         prop = RNA_def_property(srna, "anaglyph_type", PROP_ENUM, PROP_NONE);
2136         RNA_def_property_enum_items(prop, rna_enum_stereo3d_anaglyph_type_items);
2137         RNA_def_property_ui_text(prop, "Anaglyph Type", "");
2138
2139         prop = RNA_def_property(srna, "interlace_type", PROP_ENUM, PROP_NONE);
2140         RNA_def_property_enum_items(prop, rna_enum_stereo3d_interlace_type_items);
2141         RNA_def_property_ui_text(prop, "Interlace Type", "");
2142
2143         prop = RNA_def_property(srna, "use_interlace_swap", PROP_BOOLEAN, PROP_BOOLEAN);
2144         RNA_def_property_boolean_sdna(prop, NULL, "flag", S3D_INTERLACE_SWAP);
2145         RNA_def_property_ui_text(prop, "Swap Left/Right", "Swap left and right stereo channels");
2146
2147         prop = RNA_def_property(srna, "use_sidebyside_crosseyed", PROP_BOOLEAN, PROP_BOOLEAN);
2148         RNA_def_property_boolean_sdna(prop, NULL, "flag", S3D_SIDEBYSIDE_CROSSEYED);
2149         RNA_def_property_ui_text(prop, "Cross-Eyed", "Right eye should see left image and vice-versa");
2150 }
2151
2152 static void rna_def_window(BlenderRNA *brna)
2153 {
2154         StructRNA *srna;
2155         PropertyRNA *prop;
2156
2157         srna = RNA_def_struct(brna, "Window", NULL);
2158         RNA_def_struct_ui_text(srna, "Window", "Open window");
2159         RNA_def_struct_sdna(srna, "wmWindow");
2160
2161         prop = RNA_def_property(srna, "parent", PROP_POINTER, PROP_NONE);
2162         RNA_def_property_ui_text(prop, "Parent Window", "Active workspace and scene follow this window");
2163
2164         rna_def_window_stereo3d(brna);
2165
2166         prop = RNA_def_property(srna, "scene", PROP_POINTER, PROP_NONE);
2167         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_NULL);
2168         RNA_def_property_pointer_funcs(prop, NULL, "rna_Window_scene_set", NULL, NULL);
2169         RNA_def_property_ui_text(prop, "Scene", "Active scene to be edited in the window");
2170         RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
2171         RNA_def_property_update(prop, 0, "rna_Window_scene_update");
2172
2173         prop = RNA_def_property(srna, "workspace", PROP_POINTER, PROP_NONE);
2174         RNA_def_property_flag(prop, PROP_NEVER_NULL);
2175         RNA_def_property_struct_type(prop, "WorkSpace");
2176         RNA_def_property_ui_text(prop, "Workspace", "Active workspace showing in the window");
2177         RNA_def_property_pointer_funcs(prop, "rna_Window_workspace_get", "rna_Window_workspace_set", NULL, NULL);
2178         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_CONTEXT_UPDATE);
2179         RNA_def_property_update(prop, 0, "rna_Window_workspace_update");
2180
2181         prop = RNA_def_property(srna, "screen", PROP_POINTER, PROP_NONE);
2182         RNA_def_property_struct_type(prop, "Screen");
2183         RNA_def_property_ui_text(prop, "Screen", "Active workspace screen showing in the window");
2184         RNA_def_property_pointer_funcs(prop, "rna_Window_screen_get", "rna_Window_screen_set", NULL,
2185                                        "rna_Window_screen_assign_poll");
2186         RNA_def_property_flag(prop, PROP_NEVER_NULL | PROP_EDITABLE | PROP_CONTEXT_UPDATE);
2187         RNA_def_property_update(prop, 0, "rna_workspace_screen_update");
2188
2189         prop = RNA_def_property(srna, "view_layer", PROP_POINTER, PROP_NONE);
2190         RNA_def_property_struct_type(prop, "ViewLayer");
2191         RNA_def_property_pointer_funcs(prop, "rna_Window_view_layer_get", "rna_Window_view_layer_set", NULL, NULL);
2192         RNA_def_property_ui_text(prop, "Active View Layer", "The active workspace view layer showing in the window");
2193         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_NULL);
2194         RNA_def_property_update(prop, NC_SCREEN | ND_LAYER, NULL);
2195
2196         prop = RNA_def_property(srna, "x", PROP_INT, PROP_NONE);
2197         RNA_def_property_int_sdna(prop, NULL, "posx");
2198         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2199         RNA_def_property_ui_text(prop, "X Position", "Horizontal location of the window");
2200
2201         prop = RNA_def_property(srna, "y", PROP_INT, PROP_NONE);
2202         RNA_def_property_int_sdna(prop, NULL, "posy");
2203         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2204         RNA_def_property_ui_text(prop, "Y Position", "Vertical location of the window");
2205
2206         prop = RNA_def_property(srna, "width", PROP_INT, PROP_UNSIGNED);
2207         RNA_def_property_int_sdna(prop, NULL, "sizex");
2208         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2209         RNA_def_property_ui_text(prop, "Width", "Window width");
2210
2211         prop = RNA_def_property(srna, "height", PROP_INT, PROP_UNSIGNED);
2212         RNA_def_property_int_sdna(prop, NULL, "sizey");
2213         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2214         RNA_def_property_ui_text(prop, "Height", "Window height");
2215
2216         prop = RNA_def_property(srna, "stereo_3d_display", PROP_POINTER, PROP_NONE);
2217         RNA_def_property_pointer_sdna(prop, NULL, "stereo3d_format");
2218         RNA_def_property_flag(prop, PROP_NEVER_NULL);
2219         RNA_def_property_struct_type(prop, "Stereo3dDisplay");
2220         RNA_def_property_ui_text(prop, "Stereo 3D Display", "Settings for stereo 3d display");
2221
2222         RNA_api_window(srna);
2223 }
2224
2225 /* curve.splines */
2226 static void rna_def_wm_keyconfigs(BlenderRNA *brna, PropertyRNA *cprop)
2227 {
2228         StructRNA *srna;
2229         PropertyRNA *prop;
2230
2231         RNA_def_property_srna(cprop, "KeyConfigurations");
2232         srna = RNA_def_struct(brna, "KeyConfigurations", NULL);
2233         RNA_def_struct_sdna(srna, "wmWindowManager");
2234         RNA_def_struct_ui_text(srna, "KeyConfigs", "Collection of KeyConfigs");
2235
2236         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
2237         RNA_def_property_struct_type(prop, "KeyConfig");
2238         RNA_def_property_pointer_funcs(prop, "rna_WindowManager_active_keyconfig_get",
2239                                        "rna_WindowManager_active_keyconfig_set", NULL, NULL);
2240         RNA_def_property_flag(prop, PROP_EDITABLE);
2241         RNA_def_property_ui_text(prop, "Active KeyConfig", "Active key configuration (preset)");
2242
2243         prop = RNA_def_property(srna, "default", PROP_POINTER, PROP_NEVER_NULL);
2244         RNA_def_property_pointer_sdna(prop, NULL, "defaultconf");
2245         RNA_def_property_struct_type(prop, "KeyConfig");
2246         RNA_def_property_ui_text(prop, "Default Key Configuration", "Default builtin key configuration");
2247
2248         prop = RNA_def_property(srna, "addon", PROP_POINTER, PROP_NEVER_NULL);
2249         RNA_def_property_pointer_sdna(prop, NULL, "addonconf");
2250         RNA_def_property_struct_type(prop, "KeyConfig");
2251         RNA_def_property_ui_text(prop, "Add-on Key Configuration",
2252                                  "Key configuration that can be extended by add-ons, and is added to the active "
2253                                  "configuration when handling events");
2254
2255         prop = RNA_def_property(srna, "user", PROP_POINTER, PROP_NEVER_NULL);
2256         RNA_def_property_pointer_sdna(prop, NULL, "userconf");
2257         RNA_def_property_struct_type(prop, "KeyConfig");
2258         RNA_def_property_ui_text(prop, "User Key Configuration",
2259                                  "Final key configuration that combines keymaps from the active and add-on configurations, "
2260                                  "and can be edited by the user");
2261
2262         RNA_api_keyconfigs(srna);
2263 }
2264
2265 static void rna_def_windowmanager(BlenderRNA *brna)
2266 {
2267         StructRNA *srna;
2268         PropertyRNA *prop;
2269
2270         srna = RNA_def_struct(brna, "WindowManager", "ID");
2271         RNA_def_struct_ui_text(srna, "Window Manager",
2272                                "Window manager data-block defining open windows and other user interface data");
2273         RNA_def_struct_clear_flag(srna, STRUCT_ID_REFCOUNT);
2274         RNA_def_struct_sdna(srna, "wmWindowManager");
2275
2276         prop = RNA_def_property(srna, "operators", PROP_COLLECTION, PROP_NONE);
2277         RNA_def_property_struct_type(prop, "Operator");
2278         RNA_def_property_ui_text(prop, "Operators", "Operator registry");
2279
2280         prop = RNA_def_property(srna, "windows", PROP_COLLECTION, PROP_NONE);
2281         RNA_def_property_struct_type(prop, "Window");
2282         RNA_def_property_ui_text(prop, "Windows", "Open windows");
2283
2284         prop = RNA_def_property(srna, "keyconfigs", PROP_COLLECTION, PROP_NONE);
2285         RNA_def_property_struct_type(prop, "KeyConfig");
2286         RNA_def_property_ui_text(prop, "Key Configurations", "Registered key configurations");
2287         rna_def_wm_keyconfigs(brna, prop);
2288
2289         prop = RNA_def_property(srna, "clipboard", PROP_STRING, PROP_NONE);
2290         RNA_def_property_string_funcs(prop, "rna_wmClipboard_get", "rna_wmClipboard_length", "rna_wmClipboard_set");
2291         RNA_def_property_ui_text(prop, "Text Clipboard", "");
2292
2293         RNA_api_wm(srna);
2294 }
2295
2296 /* keyconfig.items */
2297 static void rna_def_keymap_items(BlenderRNA *brna, PropertyRNA *cprop)
2298 {
2299         StructRNA *srna;
2300
2301         RNA_def_property_srna(cprop, "KeyMapItems");
2302         srna = RNA_def_struct(brna, "KeyMapItems", NULL);
2303         RNA_def_struct_sdna(srna, "wmKeyMap");
2304         RNA_def_struct_ui_text(srna, "KeyMap Items", "Collection of keymap items");
2305
2306         RNA_api_keymapitems(srna);
2307 }
2308
2309 static void rna_def_wm_keymaps(BlenderRNA *brna, PropertyRNA *cprop)
2310 {
2311         StructRNA *srna;
2312
2313         RNA_def_property_srna(cprop, "KeyMaps");
2314         srna = RNA_def_struct(brna, "KeyMaps", NULL);
2315         RNA_def_struct_sdna(srna, "wmKeyConfig");
2316         RNA_def_struct_ui_text(srna, "Key Maps", "Collection of keymaps");
2317
2318         RNA_api_keymaps(srna);
2319 }
2320
2321 static void rna_def_keyconfig_prefs(BlenderRNA *brna)
2322 {
2323         StructRNA *srna;
2324         PropertyRNA *prop;
2325
2326         srna = RNA_def_struct(brna, "KeyConfigPreferences", NULL);
2327         RNA_def_struct_ui_text(srna, "Key-Config Preferences", "");
2328         RNA_def_struct_sdna(srna, "wmKeyConfigPref");  /* WARNING: only a bAddon during registration */
2329
2330         RNA_def_struct_refine_func(srna, "rna_wmKeyConfigPref_refine");
2331         RNA_def_struct_register_funcs(srna, "rna_wmKeyConfigPref_register", "rna_wmKeyConfigPref_unregister", NULL);
2332         RNA_def_struct_idprops_func(srna, "rna_wmKeyConfigPref_idprops");
2333         RNA_def_struct_flag(srna, STRUCT_NO_DATABLOCK_IDPROPERTIES);  /* Mandatory! */
2334
2335         /* registration */
2336         RNA_define_verify_sdna(0);
2337         prop = RNA_def_property(srna, "bl_idname", PROP_STRING, PROP_NONE);
2338         RNA_def_property_string_sdna(prop, NULL, "idname");
2339         RNA_def_property_flag(prop, PROP_REGISTER);
2340         RNA_define_verify_sdna(1);
2341 }
2342
2343 static void rna_def_keyconfig(BlenderRNA *brna)
2344 {
2345         StructRNA *srna;
2346         PropertyRNA *prop;
2347
2348         static const EnumPropertyItem map_type_items[] = {
2349                 {KMI_TYPE_KEYBOARD, "KEYBOARD", 0, "Keyboard", ""},
2350                 {KMI_TYPE_TWEAK, "TWEAK", 0, "Tweak", ""},
2351                 {KMI_TYPE_MOUSE, "MOUSE", 0, "Mouse", ""},
2352                 {KMI_TYPE_NDOF, "NDOF", 0, "NDOF", ""},
2353                 {KMI_TYPE_TEXTINPUT, "TEXTINPUT", 0, "Text Input", ""},
2354                 {KMI_TYPE_TIMER, "TIMER", 0, "Timer", ""},
2355                 {0, NULL, 0, NULL, NULL}
2356         };
2357
2358         /* KeyConfig */
2359         srna = RNA_def_struct(brna, "KeyConfig", NULL);
2360         RNA_def_struct_sdna(srna, "wmKeyConfig");
2361         RNA_def_struct_ui_text(srna, "Key Configuration", "Input configuration, including keymaps");
2362
2363         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
2364         RNA_def_property_string_sdna(prop, NULL, "idname");
2365         RNA_def_property_ui_text(prop, "Name", "Name of the key configuration");
2366         RNA_def_struct_name_property(srna, prop);
2367
2368         prop = RNA_def_property(srna, "keymaps", PROP_COLLECTION, PROP_NONE);
2369         RNA_def_property_struct_type(prop, "KeyMap");
2370         RNA_def_property_ui_text(prop, "Key Maps", "Key maps configured as part of this configuration");
2371         rna_def_wm_keymaps(brna, prop);
2372
2373         prop = RNA_def_property(srna, "is_user_defined", PROP_BOOLEAN, PROP_NONE);
2374         RNA_def_property_boolean_sdna(prop, NULL, "flag", KEYCONF_USER);
2375         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2376         RNA_def_property_ui_text(prop, "User Defined", "Indicates that a keyconfig was defined by the user");
2377
2378         /* Collection active property */
2379         prop = RNA_def_property(srna, "preferences", PROP_POINTER, PROP_NONE);
2380         RNA_def_property_struct_type(prop, "KeyConfigPreferences");
2381         RNA_def_property_pointer_funcs(prop, "rna_wmKeyConfig_preferences_get", NULL, NULL, NULL);
2382
2383         RNA_api_keyconfig(srna);
2384
2385         /* KeyMap */
2386         srna = RNA_def_struct(brna, "KeyMap", NULL);
2387         RNA_def_struct_sdna(srna, "wmKeyMap");
2388         RNA_def_struct_ui_text(srna, "Key Map", "Input configuration, including keymaps");
2389
2390         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
2391         RNA_def_property_string_sdna(prop, NULL, "idname");
2392         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2393         RNA_def_property_ui_text(prop, "Name", "Name of the key map");
2394         RNA_def_struct_name_property(srna, prop);
2395
2396         prop = RNA_def_property(srna, "bl_owner_id", PROP_STRING, PROP_NONE);
2397         RNA_def_property_string_sdna(prop, NULL, "owner_id");
2398         RNA_def_property_ui_text(prop, "Owner", "Internal owner");
2399
2400         prop = RNA_def_property(srna, "space_type", PROP_ENUM, PROP_NONE);
2401         RNA_def_property_enum_sdna(prop, NULL, "spaceid");
2402         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2403         RNA_def_property_enum_items(prop, rna_enum_space_type_items);
2404         RNA_def_property_ui_text(prop, "Space Type", "Optional space type keymap is associated with");
2405
2406         prop = RNA_def_property(srna, "region_type", PROP_ENUM, PROP_NONE);
2407         RNA_def_property_enum_sdna(prop, NULL, "regionid");
2408         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2409         RNA_def_property_enum_items(prop, rna_enum_region_type_items);
2410         RNA_def_property_ui_text(prop, "Region Type", "Optional region type keymap is associated with");
2411
2412         prop = RNA_def_property(srna, "keymap_items", PROP_COLLECTION, PROP_NONE);
2413         RNA_def_property_collection_sdna(prop, NULL, "items", NULL);
2414         RNA_def_property_struct_type(prop, "KeyMapItem");
2415         RNA_def_property_ui_text(prop, "Items", "Items in the keymap, linking an operator to an input event");
2416         rna_def_keymap_items(brna, prop);
2417
2418         prop = RNA_def_property(srna, "is_user_modified", PROP_BOOLEAN, PROP_NONE);
2419         RNA_def_property_boolean_sdna(prop, NULL, "flag", KEYMAP_USER_MODIFIED);
2420         RNA_def_property_ui_text(prop, "User Defined", "Keymap is defined by the user");
2421
2422         prop = RNA_def_property(srna, "is_modal", PROP_BOOLEAN, PROP_NONE);
2423         RNA_def_property_boolean_sdna(prop, NULL, "flag", KEYMAP_MODAL);
2424         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2425         RNA_def_property_ui_text(prop, "Modal Keymap",
2426                                  "Indicates that a keymap is used for translate modal events for an operator");
2427
2428         prop = RNA_def_property(srna, "show_expanded_items", PROP_BOOLEAN, PROP_NONE);
2429         RNA_def_property_boolean_sdna(prop, NULL, "flag", KEYMAP_EXPANDED);
2430         RNA_def_property_ui_text(prop, "Items Expanded", "Expanded in the user interface");
2431         RNA_def_property_ui_icon(prop, ICON_DISCLOSURE_TRI_RIGHT, 1);
2432
2433         prop = RNA_def_property(srna, "show_expanded_children", PROP_BOOLEAN, PROP_NONE);
2434         RNA_def_property_boolean_sdna(prop, NULL, "flag", KEYMAP_CHILDREN_EXPANDED);
2435         RNA_def_property_ui_text(prop, "Children Expanded", "Children expanded in the user interface");
2436         RNA_def_property_ui_icon(prop, ICON_DISCLOSURE_TRI_RIGHT, 1);
2437
2438
2439         RNA_api_keymap(srna);
2440
2441         /* KeyMapItem */
2442         srna = RNA_def_struct(brna, "KeyMapItem", NULL);
2443         RNA_def_struct_sdna(srna, "wmKeyMapItem");
2444         RNA_def_struct_ui_text(srna, "Key Map Item", "Item in a Key Map");
2445
2446         prop = RNA_def_property(srna, "idname", PROP_STRING, PROP_NONE);
2447         RNA_def_property_string_sdna(prop, NULL, "idname");
2448         RNA_def_property_ui_text(prop, "Identifier", "Identifier of operator to call on input event");
2449         RNA_def_property_string_funcs(prop, "rna_wmKeyMapItem_idname_get", "rna_wmKeyMapItem_idname_length",
2450                                       "rna_wmKeyMapItem_idname_set");
2451         RNA_def_struct_name_property(srna, prop);
2452         RNA_def_property_update(prop, 0, "rna_KeyMapItem_update");
2453
2454         /* this is in fact the operator name, but if the operator can't be found we
2455          * fallback on the operator ID */
2456         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
2457         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2458         RNA_def_property_ui_text(prop, "Name", "Name of operator (translated) to call on input event");
2459         RNA_def_property_string_funcs(prop, "rna_wmKeyMapItem_name_get", "rna_wmKeyMapItem_name_length", NULL);
2460
2461         prop = RNA_def_property(srna, "properties", PROP_POINTER, PROP_NONE);
2462         RNA_def_property_struct_type(prop, "OperatorProperties");
2463         RNA_def_property_pointer_funcs(prop, "rna_KeyMapItem_properties_get", NULL, NULL, NULL);
2464         RNA_def_property_ui_text(prop, "Properties", "Properties to set when the operator is called");
2465         RNA_def_property_update(prop, 0, "rna_KeyMapItem_update");
2466
2467         prop = RNA_def_property(srna, "map_type", PROP_ENUM, PROP_NONE);
2468         RNA_def_property_enum_sdna(prop, NULL, "maptype");
2469         RNA_def_property_enum_items(prop, map_type_items);
2470         RNA_def_property_enum_funcs(prop, "rna_wmKeyMapItem_map_type_get", "rna_wmKeyMapItem_map_type_set", NULL);
2471         RNA_def_property_ui_text(prop, "Map Type", "Type of event mapping");
2472         RNA_def_property_update(prop, 0, "rna_KeyMapItem_update");
2473
2474         prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
2475         RNA_def_property_enum_sdna(prop, NULL, "type");
2476         RNA_def_property_enum_items(prop, rna_enum_event_type_items);
2477         RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_UI_EVENTS);
2478         RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_KeyMapItem_type_itemf");
2479         RNA_def_property_ui_text(prop, "Type", "Type of event");
2480         RNA_def_property_update(prop, 0, "rna_KeyMapItem_update");
2481
2482         prop = RNA_def_property(srna, "value", PROP_ENUM, PROP_NONE);
2483         RNA_def_property_enum_sdna(prop, NULL, "val");
2484         RNA_def_property_enum_items(prop, rna_enum_event_value_items);
2485         RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_KeyMapItem_value_itemf");
2486         RNA_def_property_ui_text(prop, "Value", "");
2487         RNA_def_property_update(prop, 0, "rna_KeyMapItem_update");
2488
2489         prop = RNA_def_property(srna, "id", PROP_INT, PROP_NONE);
2490         RNA_def_property_int_sdna(prop, NULL, "id");
2491         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2492         RNA_def_property_ui_text(prop, "ID", "ID of the item");
2493         RNA_def_property_update(prop, 0, "rna_KeyMapItem_update");
2494
2495         prop = RNA_def_property(srna, "any", PROP_BOOLEAN, PROP_NONE);
2496         RNA_def_property_boolean_funcs(prop, "rna_KeyMapItem_any_get", "rna_KeyMapItem_any_set");
2497         RNA_def_property_ui_text(prop, "Any", "Any modifier keys pressed");
2498         RNA_def_property_update(prop, 0, "rna_KeyMapItem_update");
2499
2500         prop = RNA_def_property(srna, "shift", PROP_BOOLEAN, PROP_NONE);
2501         RNA_def_property_boolean_sdna(prop, NULL, "shift", 0);
2502         RNA_def_property_boolean_funcs(prop, "rna_KeyMapItem_shift_get", NULL);
2503 /*      RNA_def_property_enum_sdna(prop, NULL, "shift"); */
2504 /*      RNA_def_property_enum_items(prop, keymap_modifiers_items); */
2505         RNA_def_property_ui_text(prop, "Shift", "Shift key pressed");
2506         RNA_def_property_update(prop, 0, "rna_KeyMapItem_update");
2507
2508         prop = RNA_def_property(srna, "ctrl", PROP_BOOLEAN, PROP_NONE);
2509         RNA_def_property_boolean_sdna(prop, NULL, "ctrl", 0);
2510         RNA_def_property_boolean_funcs(prop, "rna_KeyMapItem_ctrl_get", NULL);
2511 /*      RNA_def_property_enum_sdna(prop, NULL, "ctrl"); */
2512 /*      RNA_def_property_enum_items(prop, keymap_modifiers_items); */
2513         RNA_def_property_ui_text(prop, "Ctrl", "Control key pressed");
2514         RNA_def_property_update(prop, 0, "rna_KeyMapItem_update");
2515
2516         prop = RNA_def_property(srna, "alt", PROP_BOOLEAN, PROP_NONE);
2517         RNA_def_property_boolean_sdna(prop, NULL, "alt", 0);
2518         RNA_def_property_boolean_funcs(prop, "rna_KeyMapItem_alt_get", NULL);
2519 /*      RNA_def_property_enum_sdna(prop, NULL, "alt"); */
2520 /*      RNA_def_property_enum_items(prop, keymap_modifiers_items); */
2521         RNA_def_property_ui_text(prop, "Alt", "Alt key pressed");
2522         RNA_def_property_update(prop, 0, "rna_KeyMapItem_update");
2523
2524         prop = RNA_def_property(srna, "oskey", PROP_BOOLEAN, PROP_NONE);
2525         RNA_def_property_boolean_sdna(prop, NULL, "oskey", 0);
2526         RNA_def_property_boolean_funcs(prop, "rna_KeyMapItem_oskey_get", NULL);
2527 /*      RNA_def_property_enum_sdna(prop, NULL, "oskey"); */
2528 /*      RNA_def_property_enum_items(prop, keymap_modifiers_items); */
2529         RNA_def_property_ui_text(prop, "OS Key", "Operating system key pressed");
2530         RNA_def_property_update(prop, 0, "rna_KeyMapItem_update");
2531
2532         prop = RNA_def_property(srna, "key_modifier", PROP_ENUM, PROP_NONE);
2533         RNA_def_property_enum_sdna(prop, NULL, "keymodifier");
2534         RNA_def_property_enum_items(prop, rna_enum_event_type_items);
2535         RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_UI_EVENTS);
2536         RNA_def_property_enum_funcs(prop, NULL, "rna_wmKeyMapItem_keymodifier_set", NULL);
2537         RNA_def_property_ui_text(prop, "Key Modifier", "Regular key pressed as a modifier");
2538         RNA_def_property_update(prop, 0, "rna_KeyMapItem_update");
2539
2540         prop = RNA_def_property(srna, "show_expanded", PROP_BOOLEAN, PROP_NONE);
2541         RNA_def_property_boolean_sdna(prop, NULL, "flag", KMI_EXPANDED);
2542         RNA_def_property_ui_text(prop, "Expanded", "Show key map event and property details in the user interface");
2543         RNA_def_property_ui_icon(prop, ICON_DISCLOSURE_TRI_RIGHT, 1);
2544
2545         prop = RNA_def_property(srna, "propvalue", PROP_ENUM, PROP_NONE);
2546         RNA_def_property_enum_sdna(prop, NULL, "propvalue");
2547         RNA_def_property_enum_items(prop, rna_enum_keymap_propvalue_items);
2548         RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_KeyMapItem_propvalue_itemf");
2549         RNA_def_property_ui_text(prop, "Property Value", "The value this event translates to in a modal keymap");
2550         RNA_def_property_update(prop, 0, "rna_KeyMapItem_update");
2551
2552         prop = RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
2553         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", KMI_INACTIVE);
2554         RNA_def_property_ui_text(prop, "Active", "Activate or deactivate item");
2555         RNA_def_property_ui_icon(prop, ICON_CHECKBOX_DEHLT, 1);
2556         RNA_def_property_update(prop, 0, "rna_KeyMapItem_update");
2557
2558         prop = RNA_def_property(srna, "is_user_modified", PROP_BOOLEAN, PROP_NONE);
2559         RNA_def_property_boolean_sdna(prop, NULL, "flag", KMI_USER_MODIFIED);
2560         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2561         RNA_def_property_ui_text(prop, "User Modified", "Is this keymap item modified by the user");
2562
2563         prop = RNA_def_property(srna, "is_user_defined", PROP_BOOLEAN, PROP_NONE);
2564         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2565         RNA_def_property_ui_text(prop, "User Defined",
2566                                  "Is this keymap item user defined (doesn't just replace a builtin item)");
2567         RNA_def_property_boolean_funcs(prop, "rna_KeyMapItem_userdefined_get", NULL);
2568
2569         RNA_api_keymapitem(srna);
2570 }
2571
2572 void RNA_def_wm(BlenderRNA *brna)
2573 {
2574         rna_def_operator(brna);
2575         rna_def_operator_options_runtime(brna);
2576         rna_def_operator_utils(brna);
2577         rna_def_operator_filelist_element(brna);
2578         rna_def_macro_operator(brna);
2579         rna_def_operator_type_macro(brna);
2580         rna_def_event(brna);
2581         rna_def_timer(brna);
2582         rna_def_popupmenu(brna);
2583         rna_def_popovermenu(brna);
2584         rna_def_piemenu(brna);
2585         rna_def_window(brna);
2586         rna_def_windowmanager(brna);
2587         rna_def_keyconfig_prefs(brna);
2588         rna_def_keyconfig(brna);
2589 }
2590
2591 #endif /* RNA_RUNTIME */