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