72c23f29b31297dcace41bb2586d96fbfa729a93
[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 = ptr->id.data;
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->id.data, &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->id.data, &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->id.data, &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 = value.id.data;
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 void rna_Operator_unregister(struct Main *bmain, StructRNA *type);
1424
1425 /* bpy_operator_wrap.c */
1426 extern void BPY_RNA_operator_wrapper(wmOperatorType *ot, void *userdata);
1427 extern void BPY_RNA_operator_macro_wrapper(wmOperatorType *ot, void *userdata);
1428
1429 static StructRNA *rna_Operator_register(Main *bmain,
1430                                         ReportList *reports,
1431                                         void *data,
1432                                         const char *identifier,
1433                                         StructValidateFunc validate,
1434                                         StructCallbackFunc call,
1435                                         StructFreeFunc free)
1436 {
1437   wmOperatorType dummyot = {NULL};
1438   wmOperator dummyop = {NULL};
1439   PointerRNA dummyotr;
1440   int have_function[7];
1441
1442   struct {
1443     char idname[OP_MAX_TYPENAME];
1444     char name[OP_MAX_TYPENAME];
1445     char description[RNA_DYN_DESCR_MAX];
1446     char translation_context[RNA_DYN_DESCR_MAX];
1447     char undo_group[OP_MAX_TYPENAME];
1448   } temp_buffers;
1449
1450   /* setup dummy operator & operator type to store static properties in */
1451   dummyop.type = &dummyot;
1452   dummyot.idname = temp_buffers.idname;           /* only assigne the pointer, string is NULL'd */
1453   dummyot.name = temp_buffers.name;               /* only assigne the pointer, string is NULL'd */
1454   dummyot.description = temp_buffers.description; /* only assigne the pointer, string is NULL'd */
1455   dummyot.translation_context =
1456       temp_buffers.translation_context;         /* only assigne the pointer, string is NULL'd */
1457   dummyot.undo_group = temp_buffers.undo_group; /* only assigne the pointer, string is NULL'd */
1458   RNA_pointer_create(NULL, &RNA_Operator, &dummyop, &dummyotr);
1459
1460   /* clear in case they are left unset */
1461   temp_buffers.idname[0] = temp_buffers.name[0] = temp_buffers.description[0] =
1462       temp_buffers.undo_group[0] = '\0';
1463   /* We have to set default op context! */
1464   strcpy(temp_buffers.translation_context, BLT_I18NCONTEXT_OPERATOR_DEFAULT);
1465
1466   /* validate the python class */
1467   if (validate(&dummyotr, data, have_function) != 0) {
1468     return NULL;
1469   }
1470
1471   /* check if we have registered this operator type before, and remove it */
1472   {
1473     wmOperatorType *ot = WM_operatortype_find(dummyot.idname, true);
1474     if (ot && ot->ext.srna) {
1475       rna_Operator_unregister(bmain, ot->ext.srna);
1476     }
1477   }
1478
1479   if (!WM_operator_py_idname_ok_or_report(reports, identifier, dummyot.idname)) {
1480     return NULL;
1481   }
1482
1483   char idname_conv[sizeof(dummyop.idname)];
1484   WM_operator_bl_idname(idname_conv, dummyot.idname); /* convert the idname from python */
1485
1486   if (!RNA_struct_available_or_report(reports, idname_conv)) {
1487     return NULL;
1488   }
1489
1490   /* Convert foo.bar to FOO_OT_bar
1491    * allocate all strings at once. */
1492   {
1493     const char *strings[] = {
1494         idname_conv,
1495         temp_buffers.name,
1496         temp_buffers.description,
1497         temp_buffers.translation_context,
1498         temp_buffers.undo_group,
1499     };
1500     char *strings_table[ARRAY_SIZE(strings)];
1501     BLI_string_join_array_by_sep_char_with_tableN(
1502         '\0', strings_table, strings, ARRAY_SIZE(strings));
1503
1504     dummyot.idname = strings_table[0]; /* allocated string stored here */
1505     dummyot.name = strings_table[1];
1506     dummyot.description = *strings_table[2] ? strings_table[2] : NULL;
1507     dummyot.translation_context = strings_table[3];
1508     dummyot.undo_group = strings_table[4];
1509     BLI_assert(ARRAY_SIZE(strings) == 5);
1510   }
1511
1512   /* XXX, this doubles up with the operator name [#29666]
1513    * for now just remove from dir(bpy.types) */
1514
1515   /* create a new operator type */
1516   dummyot.ext.srna = RNA_def_struct_ptr(&BLENDER_RNA, dummyot.idname, &RNA_Operator);
1517   RNA_def_struct_flag(dummyot.ext.srna,
1518                       STRUCT_NO_IDPROPERTIES); /* operator properties are registered separately */
1519   RNA_def_struct_property_tags(dummyot.ext.srna, rna_enum_operator_property_tags);
1520   RNA_def_struct_translation_context(dummyot.ext.srna, dummyot.translation_context);
1521   dummyot.ext.data = data;
1522   dummyot.ext.call = call;
1523   dummyot.ext.free = free;
1524
1525   dummyot.pyop_poll = (have_function[0]) ? rna_operator_poll_cb : NULL;
1526   dummyot.exec = (have_function[1]) ? rna_operator_execute_cb : NULL;
1527   dummyot.check = (have_function[2]) ? rna_operator_check_cb : NULL;
1528   dummyot.invoke = (have_function[3]) ? rna_operator_invoke_cb : NULL;
1529   dummyot.modal = (have_function[4]) ? rna_operator_modal_cb : NULL;
1530   dummyot.ui = (have_function[5]) ? rna_operator_draw_cb : NULL;
1531   dummyot.cancel = (have_function[6]) ? rna_operator_cancel_cb : NULL;
1532   WM_operatortype_append_ptr(BPY_RNA_operator_wrapper, (void *)&dummyot);
1533
1534   /* update while blender is running */
1535   WM_main_add_notifier(NC_SCREEN | NA_EDITED, NULL);
1536
1537   return dummyot.ext.srna;
1538 }
1539
1540 static void rna_Operator_unregister(struct Main *bmain, StructRNA *type)
1541 {
1542   const char *idname;
1543   wmOperatorType *ot = RNA_struct_blender_type_get(type);
1544   wmWindowManager *wm;
1545
1546   if (!ot) {
1547     return;
1548   }
1549
1550   /* update while blender is running */
1551   wm = bmain->wm.first;
1552   if (wm) {
1553     WM_operator_stack_clear(wm);
1554
1555     WM_operator_handlers_clear(wm, ot);
1556   }
1557   WM_main_add_notifier(NC_SCREEN | NA_EDITED, NULL);
1558
1559   RNA_struct_free_extension(type, &ot->ext);
1560
1561   idname = ot->idname;
1562   WM_operatortype_remove_ptr(ot);
1563
1564   /* Not to be confused with the RNA_struct_free that WM_operatortype_remove calls,
1565    * they are 2 different srna's. */
1566   RNA_struct_free(&BLENDER_RNA, type);
1567
1568   MEM_freeN((void *)idname);
1569 }
1570
1571 static void **rna_Operator_instance(PointerRNA *ptr)
1572 {
1573   wmOperator *op = ptr->data;
1574   return &op->py_instance;
1575 }
1576
1577 static StructRNA *rna_MacroOperator_register(Main *bmain,
1578                                              ReportList *reports,
1579                                              void *data,
1580                                              const char *identifier,
1581                                              StructValidateFunc validate,
1582                                              StructCallbackFunc call,
1583                                              StructFreeFunc free)
1584 {
1585   wmOperatorType dummyot = {NULL};
1586   wmOperator dummyop = {NULL};
1587   PointerRNA dummyotr;
1588   int have_function[4];
1589
1590   struct {
1591     char idname[OP_MAX_TYPENAME];
1592     char name[OP_MAX_TYPENAME];
1593     char description[RNA_DYN_DESCR_MAX];
1594     char translation_context[RNA_DYN_DESCR_MAX];
1595     char undo_group[OP_MAX_TYPENAME];
1596   } temp_buffers;
1597
1598   /* setup dummy operator & operator type to store static properties in */
1599   dummyop.type = &dummyot;
1600   dummyot.idname = temp_buffers.idname;           /* only assigne the pointer, string is NULL'd */
1601   dummyot.name = temp_buffers.name;               /* only assigne the pointer, string is NULL'd */
1602   dummyot.description = temp_buffers.description; /* only assigne the pointer, string is NULL'd */
1603   dummyot.translation_context =
1604       temp_buffers.translation_context;         /* only assigne the pointer, string is NULL'd */
1605   dummyot.undo_group = temp_buffers.undo_group; /* only assigne the pointer, string is NULL'd */
1606   RNA_pointer_create(NULL, &RNA_Macro, &dummyop, &dummyotr);
1607
1608   /* clear in case they are left unset */
1609   temp_buffers.idname[0] = temp_buffers.name[0] = temp_buffers.description[0] =
1610       temp_buffers.undo_group[0] = '\0';
1611   /* We have to set default op context! */
1612   strcpy(temp_buffers.translation_context, BLT_I18NCONTEXT_OPERATOR_DEFAULT);
1613
1614   /* validate the python class */
1615   if (validate(&dummyotr, data, have_function) != 0) {
1616     return NULL;
1617   }
1618
1619   if (strlen(identifier) >= sizeof(dummyop.idname)) {
1620     BKE_reportf(reports,
1621                 RPT_ERROR,
1622                 "Registering operator class: '%s' is too long, maximum length is %d",
1623                 identifier,
1624                 (int)sizeof(dummyop.idname));
1625     return NULL;
1626   }
1627
1628   /* check if we have registered this operator type before, and remove it */
1629   {
1630     wmOperatorType *ot = WM_operatortype_find(dummyot.idname, true);
1631     if (ot && ot->ext.srna) {
1632       rna_Operator_unregister(bmain, ot->ext.srna);
1633     }
1634   }
1635
1636   if (!WM_operator_py_idname_ok_or_report(reports, identifier, dummyot.idname)) {
1637     return NULL;
1638   }
1639
1640   char idname_conv[sizeof(dummyop.idname)];
1641   WM_operator_bl_idname(idname_conv, dummyot.idname); /* convert the idname from python */
1642
1643   if (!RNA_struct_available_or_report(reports, idname_conv)) {
1644     return NULL;
1645   }
1646
1647   /* Convert foo.bar to FOO_OT_bar
1648    * allocate all strings at once. */
1649   {
1650     const char *strings[] = {
1651         idname_conv,
1652         temp_buffers.name,
1653         temp_buffers.description,
1654         temp_buffers.translation_context,
1655         temp_buffers.undo_group,
1656     };
1657     char *strings_table[ARRAY_SIZE(strings)];
1658     BLI_string_join_array_by_sep_char_with_tableN(
1659         '\0', strings_table, strings, ARRAY_SIZE(strings));
1660
1661     dummyot.idname = strings_table[0]; /* allocated string stored here */
1662     dummyot.name = strings_table[1];
1663     dummyot.description = *strings_table[2] ? strings_table[2] : NULL;
1664     dummyot.translation_context = strings_table[3];
1665     dummyot.undo_group = strings_table[4];
1666     BLI_assert(ARRAY_SIZE(strings) == 5);
1667   }
1668
1669   /* XXX, this doubles up with the operator name [#29666]
1670    * for now just remove from dir(bpy.types) */
1671
1672   /* create a new operator type */
1673   dummyot.ext.srna = RNA_def_struct_ptr(&BLENDER_RNA, dummyot.idname, &RNA_Operator);
1674   RNA_def_struct_translation_context(dummyot.ext.srna, dummyot.translation_context);
1675   dummyot.ext.data = data;
1676   dummyot.ext.call = call;
1677   dummyot.ext.free = free;
1678
1679   dummyot.pyop_poll = (have_function[0]) ? rna_operator_poll_cb : NULL;
1680   dummyot.ui = (have_function[3]) ? rna_operator_draw_cb : NULL;
1681
1682   WM_operatortype_append_macro_ptr(BPY_RNA_operator_macro_wrapper, (void *)&dummyot);
1683
1684   /* update while blender is running */
1685   WM_main_add_notifier(NC_SCREEN | NA_EDITED, NULL);
1686
1687   return dummyot.ext.srna;
1688 }
1689 #  endif /* WITH_PYTHON */
1690
1691 static StructRNA *rna_Operator_refine(PointerRNA *opr)
1692 {
1693   wmOperator *op = (wmOperator *)opr->data;
1694   return (op->type && op->type->ext.srna) ? op->type->ext.srna : &RNA_Operator;
1695 }
1696
1697 static StructRNA *rna_MacroOperator_refine(PointerRNA *opr)
1698 {
1699   wmOperator *op = (wmOperator *)opr->data;
1700   return (op->type && op->type->ext.srna) ? op->type->ext.srna : &RNA_Macro;
1701 }
1702
1703 /* just to work around 'const char *' warning and to ensure this is a python op */
1704 static void rna_Operator_bl_idname_set(PointerRNA *ptr, const char *value)
1705 {
1706   wmOperator *data = (wmOperator *)(ptr->data);
1707   char *str = (char *)data->type->idname;
1708   if (!str[0]) {
1709     BLI_strncpy(str, value, OP_MAX_TYPENAME); /* utf8 already ensured */
1710   }
1711   else {
1712     assert(!"setting the bl_idname on a non-builtin operator");
1713   }
1714 }
1715
1716 static void rna_Operator_bl_label_set(PointerRNA *ptr, const char *value)
1717 {
1718   wmOperator *data = (wmOperator *)(ptr->data);
1719   char *str = (char *)data->type->name;
1720   if (!str[0]) {
1721     BLI_strncpy(str, value, OP_MAX_TYPENAME); /* utf8 already ensured */
1722   }
1723   else {
1724     assert(!"setting the bl_label on a non-builtin operator");
1725   }
1726 }
1727
1728 static void rna_Operator_bl_translation_context_set(PointerRNA *ptr, const char *value)
1729 {
1730   wmOperator *data = (wmOperator *)(ptr->data);
1731   char *str = (char *)data->type->translation_context;
1732   if (!str[0]) {
1733     BLI_strncpy(str, value, RNA_DYN_DESCR_MAX); /* utf8 already ensured */
1734   }
1735   else {
1736     assert(!"setting the bl_translation_context on a non-builtin operator");
1737   }
1738 }
1739
1740 static void rna_Operator_bl_description_set(PointerRNA *ptr, const char *value)
1741 {
1742   wmOperator *data = (wmOperator *)(ptr->data);
1743   char *str = (char *)data->type->description;
1744   if (!str[0]) {
1745     BLI_strncpy(str, value, RNA_DYN_DESCR_MAX); /* utf8 already ensured */
1746   }
1747   else {
1748     assert(!"setting the bl_description on a non-builtin operator");
1749   }
1750 }
1751
1752 static void rna_Operator_bl_undo_group_set(PointerRNA *ptr, const char *value)
1753 {
1754   wmOperator *data = (wmOperator *)(ptr->data);
1755   char *str = (char *)data->type->undo_group;
1756   if (!str[0]) {
1757     BLI_strncpy(str, value, OP_MAX_TYPENAME); /* utf8 already ensured */
1758   }
1759   else {
1760     assert(!"setting the bl_undo_group on a non-builtin operator");
1761   }
1762 }
1763
1764 static void rna_KeyMapItem_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
1765 {
1766   wmKeyMapItem *kmi = ptr->data;
1767   WM_keyconfig_update_tag(NULL, kmi);
1768 }
1769
1770 #else /* RNA_RUNTIME */
1771
1772 /**
1773  * expose ``Operator.options`` as its own type so we can control each flags use
1774  * (some are read-only).
1775  */
1776 static void rna_def_operator_options_runtime(BlenderRNA *brna)
1777 {
1778   StructRNA *srna;
1779   PropertyRNA *prop;
1780
1781   srna = RNA_def_struct(brna, "OperatorOptions", NULL);
1782   RNA_def_struct_ui_text(srna, "Operator Options", "Runtime options");
1783   RNA_def_struct_sdna(srna, "wmOperator");
1784
1785   prop = RNA_def_property(srna, "is_grab_cursor", PROP_BOOLEAN, PROP_BOOLEAN);
1786   RNA_def_property_boolean_sdna(prop, NULL, "flag", OP_IS_MODAL_GRAB_CURSOR);
1787   RNA_def_property_ui_text(prop, "Grab Cursor", "True when the cursor is grabbed");
1788   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1789
1790   prop = RNA_def_property(srna, "is_invoke", PROP_BOOLEAN, PROP_BOOLEAN);
1791   RNA_def_property_boolean_sdna(prop, NULL, "flag", OP_IS_INVOKE);
1792   RNA_def_property_ui_text(
1793       prop, "Invoke", "True when invoked (even if only the execute callbacks available)");
1794   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1795
1796   prop = RNA_def_property(srna, "is_repeat", PROP_BOOLEAN, PROP_BOOLEAN);
1797   RNA_def_property_boolean_sdna(prop, NULL, "flag", OP_IS_REPEAT);
1798   RNA_def_property_ui_text(prop, "Repeat", "True when run from the redo panel");
1799   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1800
1801   prop = RNA_def_property(srna, "use_cursor_region", PROP_BOOLEAN, PROP_BOOLEAN);
1802   RNA_def_property_boolean_sdna(prop, NULL, "flag", OP_IS_MODAL_CURSOR_REGION);
1803   RNA_def_property_ui_text(
1804       prop, "Focus Region", "Enable to use the region under the cursor for modal execution");
1805 }
1806
1807 static void rna_def_operator(BlenderRNA *brna)
1808 {
1809   StructRNA *srna;
1810   PropertyRNA *prop;
1811
1812   srna = RNA_def_struct(brna, "Operator", NULL);
1813   RNA_def_struct_ui_text(
1814       srna, "Operator", "Storage of an operator being executed, or registered after execution");
1815   RNA_def_struct_sdna(srna, "wmOperator");
1816   RNA_def_struct_refine_func(srna, "rna_Operator_refine");
1817 #  ifdef WITH_PYTHON
1818   RNA_def_struct_register_funcs(
1819       srna, "rna_Operator_register", "rna_Operator_unregister", "rna_Operator_instance");
1820 #  endif
1821   RNA_def_struct_translation_context(srna, BLT_I18NCONTEXT_OPERATOR_DEFAULT);
1822   RNA_def_struct_flag(srna, STRUCT_PUBLIC_NAMESPACE_INHERIT);
1823
1824   prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1825   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1826   RNA_def_property_string_funcs(prop, "rna_Operator_name_get", "rna_Operator_name_length", NULL);
1827   RNA_def_property_ui_text(prop, "Name", "");
1828
1829   prop = RNA_def_property(srna, "properties", PROP_POINTER, PROP_NONE);
1830   RNA_def_property_flag(prop, PROP_NEVER_NULL);
1831   RNA_def_property_struct_type(prop, "OperatorProperties");
1832   RNA_def_property_ui_text(prop, "Properties", "");
1833   RNA_def_property_pointer_funcs(prop, "rna_Operator_properties_get", NULL, NULL, NULL);
1834
1835   prop = RNA_def_property(srna, "has_reports", PROP_BOOLEAN, PROP_NONE);
1836   RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* this is 'virtual' property */
1837   RNA_def_property_boolean_funcs(prop, "rna_Operator_has_reports_get", NULL);
1838   RNA_def_property_ui_text(
1839       prop,
1840       "Has Reports",
1841       "Operator has a set of reports (warnings and errors) from last execution");
1842
1843   prop = RNA_def_property(srna, "layout", PROP_POINTER, PROP_NONE);
1844   RNA_def_property_struct_type(prop, "UILayout");
1845
1846   prop = RNA_def_property(srna, "options", PROP_POINTER, PROP_NONE);
1847   RNA_def_property_flag(prop, PROP_NEVER_NULL);
1848   RNA_def_property_struct_type(prop, "OperatorOptions");
1849   RNA_def_property_pointer_funcs(prop, "rna_Operator_options_get", NULL, NULL, NULL);
1850   RNA_def_property_ui_text(prop, "Options", "Runtime options");
1851
1852   /* Registration */
1853   prop = RNA_def_property(srna, "bl_idname", PROP_STRING, PROP_NONE);
1854   RNA_def_property_string_sdna(prop, NULL, "type->idname");
1855   /* else it uses the pointer size!. -3 because '.' -> '_OT_' */
1856   RNA_def_property_string_maxlength(prop, OP_MAX_TYPENAME - 3);
1857   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_Operator_bl_idname_set");
1858   /* RNA_def_property_clear_flag(prop, PROP_EDITABLE); */
1859   RNA_def_property_flag(prop, PROP_REGISTER);
1860   RNA_def_struct_name_property(srna, prop);
1861
1862   prop = RNA_def_property(srna, "bl_label", PROP_STRING, PROP_NONE);
1863   RNA_def_property_string_sdna(prop, NULL, "type->name");
1864   RNA_def_property_string_maxlength(prop, RNA_DYN_DESCR_MAX); /* else it uses the pointer size! */
1865   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_Operator_bl_label_set");
1866   /* RNA_def_property_clear_flag(prop, PROP_EDITABLE); */
1867   RNA_def_property_flag(prop, PROP_REGISTER);
1868
1869   prop = RNA_def_property(srna, "bl_translation_context", PROP_STRING, PROP_NONE);
1870   RNA_def_property_string_sdna(prop, NULL, "type->translation_context");
1871   RNA_def_property_string_maxlength(prop, RNA_DYN_DESCR_MAX); /* else it uses the pointer size! */
1872   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_Operator_bl_translation_context_set");
1873   RNA_def_property_string_default(prop, BLT_I18NCONTEXT_OPERATOR_DEFAULT);
1874   RNA_def_property_flag(prop, PROP_REGISTER_OPTIONAL);
1875   RNA_def_property_clear_flag(prop, PROP_NEVER_NULL); /* check for NULL */
1876
1877   prop = RNA_def_property(srna, "bl_description", PROP_STRING, PROP_NONE);
1878   RNA_def_property_string_sdna(prop, NULL, "type->description");
1879   RNA_def_property_string_maxlength(prop, RNA_DYN_DESCR_MAX); /* else it uses the pointer size! */
1880   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_Operator_bl_description_set");
1881   /* RNA_def_property_clear_flag(prop, PROP_EDITABLE); */
1882   RNA_def_property_flag(prop, PROP_REGISTER_OPTIONAL);
1883   RNA_def_property_clear_flag(prop, PROP_NEVER_NULL); /* check for NULL */
1884
1885   prop = RNA_def_property(srna, "bl_undo_group", PROP_STRING, PROP_NONE);
1886   RNA_def_property_string_sdna(prop, NULL, "type->undo_group");
1887   RNA_def_property_string_maxlength(prop, OP_MAX_TYPENAME); /* else it uses the pointer size! */
1888   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_Operator_bl_undo_group_set");
1889   /* RNA_def_property_clear_flag(prop, PROP_EDITABLE); */
1890   RNA_def_property_flag(prop, PROP_REGISTER_OPTIONAL);
1891   RNA_def_property_clear_flag(prop, PROP_NEVER_NULL); /* check for NULL */
1892
1893   prop = RNA_def_property(srna, "bl_options", PROP_ENUM, PROP_NONE);
1894   RNA_def_property_enum_sdna(prop, NULL, "type->flag");
1895   RNA_def_property_enum_items(prop, operator_flag_items);
1896   RNA_def_property_flag(prop, PROP_REGISTER_OPTIONAL | PROP_ENUM_FLAG);
1897   RNA_def_property_ui_text(prop, "Options", "Options for this operator type");
1898
1899   prop = RNA_def_property(srna, "macros", PROP_COLLECTION, PROP_NONE);
1900   RNA_def_property_collection_sdna(prop, NULL, "macro", NULL);
1901   RNA_def_property_struct_type(prop, "Macro");
1902   RNA_def_property_ui_text(prop, "Macros", "");
1903
1904   RNA_api_operator(srna);
1905
1906   srna = RNA_def_struct(brna, "OperatorProperties", NULL);
1907   RNA_def_struct_ui_text(srna, "Operator Properties", "Input properties of an Operator");
1908   RNA_def_struct_refine_func(srna, "rna_OperatorProperties_refine");
1909   RNA_def_struct_idprops_func(srna, "rna_OperatorProperties_idprops");
1910   RNA_def_struct_property_tags(srna, rna_enum_operator_property_tags);
1911   RNA_def_struct_flag(srna, STRUCT_NO_DATABLOCK_IDPROPERTIES);
1912   RNA_def_struct_clear_flag(srna, STRUCT_UNDO);
1913 }
1914
1915 static void rna_def_macro_operator(BlenderRNA *brna)
1916 {
1917   StructRNA *srna;
1918   PropertyRNA *prop;
1919
1920   srna = RNA_def_struct(brna, "Macro", NULL);
1921   RNA_def_struct_ui_text(
1922       srna,
1923       "Macro Operator",
1924       "Storage of a macro operator being executed, or registered after execution");
1925   RNA_def_struct_sdna(srna, "wmOperator");
1926   RNA_def_struct_refine_func(srna, "rna_MacroOperator_refine");
1927 #  ifdef WITH_PYTHON
1928   RNA_def_struct_register_funcs(
1929       srna, "rna_MacroOperator_register", "rna_Operator_unregister", "rna_Operator_instance");
1930 #  endif
1931   RNA_def_struct_translation_context(srna, BLT_I18NCONTEXT_OPERATOR_DEFAULT);
1932   RNA_def_struct_flag(srna, STRUCT_PUBLIC_NAMESPACE_INHERIT);
1933
1934   prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1935   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1936   RNA_def_property_string_funcs(prop, "rna_Operator_name_get", "rna_Operator_name_length", NULL);
1937   RNA_def_property_ui_text(prop, "Name", "");
1938
1939   prop = RNA_def_property(srna, "properties", PROP_POINTER, PROP_NONE);
1940   RNA_def_property_flag(prop, PROP_NEVER_NULL);
1941   RNA_def_property_struct_type(prop, "OperatorProperties");
1942   RNA_def_property_ui_text(prop, "Properties", "");
1943   RNA_def_property_pointer_funcs(prop, "rna_Operator_properties_get", NULL, NULL, NULL);
1944
1945   /* Registration */
1946   prop = RNA_def_property(srna, "bl_idname", PROP_STRING, PROP_NONE);
1947   RNA_def_property_string_sdna(prop, NULL, "type->idname");
1948   RNA_def_property_string_maxlength(prop, OP_MAX_TYPENAME); /* else it uses the pointer size! */
1949   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_Operator_bl_idname_set");
1950   /* RNA_def_property_clear_flag(prop, PROP_EDITABLE); */
1951   RNA_def_property_flag(prop, PROP_REGISTER);
1952   RNA_def_struct_name_property(srna, prop);
1953
1954   prop = RNA_def_property(srna, "bl_label", PROP_STRING, PROP_NONE);
1955   RNA_def_property_string_sdna(prop, NULL, "type->name");
1956   RNA_def_property_string_maxlength(prop, RNA_DYN_DESCR_MAX); /* else it uses the pointer size! */
1957   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_Operator_bl_label_set");
1958   /* RNA_def_property_clear_flag(prop, PROP_EDITABLE); */
1959   RNA_def_property_flag(prop, PROP_REGISTER);
1960
1961   prop = RNA_def_property(srna, "bl_translation_context", PROP_STRING, PROP_NONE);
1962   RNA_def_property_string_sdna(prop, NULL, "type->translation_context");
1963   RNA_def_property_string_maxlength(prop, RNA_DYN_DESCR_MAX); /* else it uses the pointer size! */
1964   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_Operator_bl_translation_context_set");
1965   RNA_def_property_string_default(prop, BLT_I18NCONTEXT_OPERATOR_DEFAULT);
1966   RNA_def_property_flag(prop, PROP_REGISTER_OPTIONAL);
1967   RNA_def_property_clear_flag(prop, PROP_NEVER_NULL); /* check for NULL */
1968
1969   prop = RNA_def_property(srna, "bl_description", PROP_STRING, PROP_NONE);
1970   RNA_def_property_string_sdna(prop, NULL, "type->description");
1971   RNA_def_property_string_maxlength(prop, RNA_DYN_DESCR_MAX); /* else it uses the pointer size! */
1972   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_Operator_bl_description_set");
1973   /* RNA_def_property_clear_flag(prop, PROP_EDITABLE); */
1974   RNA_def_property_flag(prop, PROP_REGISTER_OPTIONAL);
1975   RNA_def_property_clear_flag(prop, PROP_NEVER_NULL); /* check for NULL */
1976
1977   prop = RNA_def_property(srna, "bl_undo_group", PROP_STRING, PROP_NONE);
1978   RNA_def_property_string_sdna(prop, NULL, "type->undo_group");
1979   RNA_def_property_string_maxlength(prop, OP_MAX_TYPENAME); /* else it uses the pointer size! */
1980   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_Operator_bl_undo_group_set");
1981   /* RNA_def_property_clear_flag(prop, PROP_EDITABLE); */
1982   RNA_def_property_flag(prop, PROP_REGISTER_OPTIONAL);
1983   RNA_def_property_clear_flag(prop, PROP_NEVER_NULL); /* check for NULL */
1984
1985   prop = RNA_def_property(srna, "bl_options", PROP_ENUM, PROP_NONE);
1986   RNA_def_property_enum_sdna(prop, NULL, "type->flag");
1987   RNA_def_property_enum_items(prop, operator_flag_items);
1988   RNA_def_property_flag(prop, PROP_REGISTER_OPTIONAL | PROP_ENUM_FLAG);
1989   RNA_def_property_ui_text(prop, "Options", "Options for this operator type");
1990
1991   RNA_api_macro(srna);
1992 }
1993
1994 static void rna_def_operator_type_macro(BlenderRNA *brna)
1995 {
1996   StructRNA *srna;
1997   PropertyRNA *prop;
1998
1999   srna = RNA_def_struct(brna, "OperatorMacro", NULL);
2000   RNA_def_struct_ui_text(
2001       srna, "Operator Macro", "Storage of a sub operator in a macro after it has been added");
2002   RNA_def_struct_sdna(srna, "wmOperatorTypeMacro");
2003
2004   /*  prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE); */
2005   /*  RNA_def_property_clear_flag(prop, PROP_EDITABLE); */
2006   /*  RNA_def_property_string_sdna(prop, NULL, "idname"); */
2007   /*  RNA_def_property_ui_text(prop, "Name", "Name of the sub operator"); */
2008   /*  RNA_def_struct_name_property(srna, prop); */
2009
2010   prop = RNA_def_property(srna, "properties", PROP_POINTER, PROP_NONE);
2011   RNA_def_property_flag(prop, PROP_NEVER_NULL);
2012   RNA_def_property_struct_type(prop, "OperatorProperties");
2013   RNA_def_property_ui_text(prop, "Properties", "");
2014   RNA_def_property_pointer_funcs(prop, "rna_OperatorMacro_properties_get", NULL, NULL, NULL);
2015 }
2016
2017 static void rna_def_operator_utils(BlenderRNA *brna)
2018 {
2019   StructRNA *srna;
2020   PropertyRNA *prop;
2021
2022   srna = RNA_def_struct(brna, "OperatorMousePath", "PropertyGroup");
2023   RNA_def_struct_ui_text(
2024       srna, "Operator Mouse Path", "Mouse path values for operators that record such paths");
2025
2026   prop = RNA_def_property(srna, "loc", PROP_FLOAT, PROP_XYZ);
2027   RNA_def_property_flag(prop, PROP_IDPROPERTY);
2028   RNA_def_property_array(prop, 2);
2029   RNA_def_property_ui_text(prop, "Location", "Mouse location");
2030
2031   prop = RNA_def_property(srna, "time", PROP_FLOAT, PROP_NONE);
2032   RNA_def_property_flag(prop, PROP_IDPROPERTY);
2033   RNA_def_property_ui_text(prop, "Time", "Time of mouse location");
2034 }
2035
2036 static void rna_def_operator_filelist_element(BlenderRNA *brna)
2037 {
2038   StructRNA *srna;
2039   PropertyRNA *prop;
2040
2041   srna = RNA_def_struct(brna, "OperatorFileListElement", "PropertyGroup");
2042   RNA_def_struct_ui_text(srna, "Operator File List Element", "");
2043
2044   prop = RNA_def_property(srna, "name", PROP_STRING, PROP_FILENAME);
2045   RNA_def_property_flag(prop, PROP_IDPROPERTY);
2046   RNA_def_property_ui_text(prop, "Name", "Name of a file or directory within a file list");
2047 }
2048
2049 static void rna_def_event(BlenderRNA *brna)
2050 {
2051   StructRNA *srna;
2052   PropertyRNA *prop;
2053
2054   srna = RNA_def_struct(brna, "Event", NULL);
2055   RNA_def_struct_ui_text(srna, "Event", "Window Manager Event");
2056   RNA_def_struct_sdna(srna, "wmEvent");
2057
2058   RNA_define_verify_sdna(0); /* not in sdna */
2059
2060   /* strings */
2061   prop = RNA_def_property(srna, "ascii", PROP_STRING, PROP_NONE);
2062   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2063   RNA_def_property_string_funcs(prop, "rna_Event_ascii_get", "rna_Event_ascii_length", NULL);
2064   RNA_def_property_ui_text(prop, "ASCII", "Single ASCII character for this event");
2065
2066   prop = RNA_def_property(srna, "unicode", PROP_STRING, PROP_NONE);
2067   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2068   RNA_def_property_string_funcs(prop, "rna_Event_unicode_get", "rna_Event_unicode_length", NULL);
2069   RNA_def_property_ui_text(prop, "Unicode", "Single unicode character for this event");
2070
2071   /* enums */
2072   prop = RNA_def_property(srna, "value", PROP_ENUM, PROP_NONE);
2073   RNA_def_property_enum_sdna(prop, NULL, "val");
2074   RNA_def_property_enum_items(prop, rna_enum_event_value_items);
2075   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2076   RNA_def_property_ui_text(prop, "Value", "The type of event, only applies to some");
2077
2078   prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
2079   RNA_def_property_enum_sdna(prop, NULL, "type");
2080   RNA_def_property_enum_items(prop, rna_enum_event_type_items);
2081   RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_UI_EVENTS);
2082   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2083   RNA_def_property_ui_text(prop, "Type", "");
2084
2085   /* mouse */
2086   prop = RNA_def_property(srna, "mouse_x", PROP_INT, PROP_NONE);
2087   RNA_def_property_int_sdna(prop, NULL, "x");
2088   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2089   RNA_def_property_ui_text(
2090       prop, "Mouse X Position", "The window relative horizontal location of the mouse");
2091
2092   prop = RNA_def_property(srna, "mouse_y", PROP_INT, PROP_NONE);
2093   RNA_def_property_int_sdna(prop, NULL, "y");
2094   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2095   RNA_def_property_ui_text(
2096       prop, "Mouse Y Position", "The window relative vertical location of the mouse");
2097
2098   prop = RNA_def_property(srna, "mouse_region_x", PROP_INT, PROP_NONE);
2099   RNA_def_property_int_sdna(prop, NULL, "mval[0]");
2100   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2101   RNA_def_property_ui_text(
2102       prop, "Mouse X Position", "The region relative horizontal location of the mouse");
2103
2104   prop = RNA_def_property(srna, "mouse_region_y", PROP_INT, PROP_NONE);
2105   RNA_def_property_int_sdna(prop, NULL, "mval[1]");
2106   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2107   RNA_def_property_ui_text(
2108       prop, "Mouse Y Position", "The region relative vertical location of the mouse");
2109
2110   prop = RNA_def_property(srna, "mouse_prev_x", PROP_INT, PROP_NONE);
2111   RNA_def_property_int_sdna(prop, NULL, "prevx");
2112   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2113   RNA_def_property_ui_text(
2114       prop, "Mouse Previous X Position", "The window relative horizontal location of the mouse");
2115
2116   prop = RNA_def_property(srna, "mouse_prev_y", PROP_INT, PROP_NONE);
2117   RNA_def_property_int_sdna(prop, NULL, "prevy");
2118   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2119   RNA_def_property_ui_text(
2120       prop, "Mouse Previous Y Position", "The window relative vertical location of the mouse");
2121
2122   prop = RNA_def_property(srna, "pressure", PROP_FLOAT, PROP_NONE);
2123   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2124   RNA_def_property_float_funcs(prop, "rna_Event_pressure_get", NULL, NULL);
2125   RNA_def_property_ui_text(
2126       prop, "Tablet Pressure", "The pressure of the tablet or 1.0 if no tablet present");
2127
2128   prop = RNA_def_property(srna, "tilt", PROP_FLOAT, PROP_XYZ_LENGTH);
2129   RNA_def_property_array(prop, 2);
2130   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2131   RNA_def_property_float_funcs(prop, "rna_Event_tilt_get", NULL, NULL);
2132   RNA_def_property_ui_text(
2133       prop, "Tablet Tilt", "The pressure of the tablet or zeroes if no tablet present");
2134
2135   prop = RNA_def_property(srna, "is_tablet", PROP_BOOLEAN, PROP_NONE);
2136   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2137   RNA_def_property_boolean_funcs(prop, "rna_Event_is_tablet_get", NULL);
2138   RNA_def_property_ui_text(prop, "Is Tablet", "The event has tablet data");
2139
2140   prop = RNA_def_property(srna, "is_mouse_absolute", PROP_BOOLEAN, PROP_NONE);
2141   RNA_def_property_boolean_sdna(prop, NULL, "is_motion_absolute", 1);
2142   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2143   RNA_def_property_ui_text(prop, "Absolute Motion", "The last motion event was an absolute input");
2144
2145   /* modifiers */
2146   prop = RNA_def_property(srna, "shift", PROP_BOOLEAN, PROP_NONE);
2147   RNA_def_property_boolean_sdna(prop, NULL, "shift", 1);
2148   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2149   RNA_def_property_ui_text(prop, "Shift", "True when the Shift key is held");
2150   RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_ID_WINDOWMANAGER);
2151
2152   prop = RNA_def_property(srna, "ctrl", PROP_BOOLEAN, PROP_NONE);
2153   RNA_def_property_boolean_sdna(prop, NULL, "ctrl", 1);
2154   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2155   RNA_def_property_ui_text(prop, "Ctrl", "True when the Ctrl key is held");
2156
2157   prop = RNA_def_property(srna, "alt", PROP_BOOLEAN, PROP_NONE);
2158   RNA_def_property_boolean_sdna(prop, NULL, "alt", 1);
2159   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2160   RNA_def_property_ui_text(prop, "Alt", "True when the Alt/Option key is held");
2161
2162   prop = RNA_def_property(srna, "oskey", PROP_BOOLEAN, PROP_NONE);
2163   RNA_def_property_boolean_sdna(prop, NULL, "oskey", 1);
2164   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2165   RNA_def_property_ui_text(prop, "OS Key", "True when the Cmd key is held");
2166
2167   RNA_define_verify_sdna(1); /* not in sdna */
2168 }
2169
2170 static void rna_def_timer(BlenderRNA *brna)
2171 {
2172   StructRNA *srna;
2173   PropertyRNA *prop;
2174
2175   srna = RNA_def_struct(brna, "Timer", NULL);
2176   RNA_def_struct_ui_text(srna, "Timer", "Window event timer");
2177   RNA_def_struct_sdna(srna, "wmTimer");
2178
2179   RNA_define_verify_sdna(0); /* not in sdna */
2180
2181   /* could wrap more, for now this is enough */
2182   prop = RNA_def_property(srna, "time_step", PROP_FLOAT, PROP_NONE);
2183   RNA_def_property_float_sdna(prop, NULL, "timestep");
2184   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2185   RNA_def_property_ui_text(prop, "Time Step", "");
2186
2187   prop = RNA_def_property(srna, "time_delta", PROP_FLOAT, PROP_NONE);
2188   RNA_def_property_float_sdna(prop, NULL, "delta");
2189   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2190   RNA_def_property_ui_text(prop, "Delta", "Time since last step in seconds");
2191
2192   prop = RNA_def_property(srna, "time_duration", PROP_FLOAT, PROP_NONE);
2193   RNA_def_property_float_sdna(prop, NULL, "duration");
2194   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2195   RNA_def_property_ui_text(prop, "Delta", "Time since last step in seconds");
2196
2197   RNA_define_verify_sdna(1); /* not in sdna */
2198 }
2199
2200 static void rna_def_popup_menu_wrapper(BlenderRNA *brna,
2201                                        const char *rna_type,
2202                                        const char *c_type,
2203                                        const char *layout_get_fn)
2204 {
2205   StructRNA *srna;
2206   PropertyRNA *prop;
2207
2208   srna = RNA_def_struct(brna, rna_type, NULL);
2209   /* UI name isn't visible, name same as type. */
2210   RNA_def_struct_ui_text(srna, rna_type, "");
2211   RNA_def_struct_sdna(srna, c_type);
2212
2213   RNA_define_verify_sdna(0); /* not in sdna */
2214
2215   /* could wrap more, for now this is enough */
2216   prop = RNA_def_property(srna, "layout", PROP_POINTER, PROP_NONE);
2217   RNA_def_property_struct_type(prop, "UILayout");
2218   RNA_def_property_pointer_funcs(prop, layout_get_fn, NULL, NULL, NULL);
2219
2220   RNA_define_verify_sdna(1); /* not in sdna */
2221 }
2222
2223 static void rna_def_popupmenu(BlenderRNA *brna)
2224 {
2225   rna_def_popup_menu_wrapper(brna, "UIPopupMenu", "uiPopupMenu", "rna_PopupMenu_layout_get");
2226 }
2227
2228 static void rna_def_popovermenu(BlenderRNA *brna)
2229 {
2230   rna_def_popup_menu_wrapper(brna, "UIPopover", "uiPopover", "rna_PopoverMenu_layout_get");
2231 }
2232
2233 static void rna_def_piemenu(BlenderRNA *brna)
2234 {
2235   rna_def_popup_menu_wrapper(brna, "UIPieMenu", "uiPieMenu", "rna_PieMenu_layout_get");
2236 }
2237
2238 static void rna_def_window_stereo3d(BlenderRNA *brna)
2239 {
2240   StructRNA *srna;
2241   PropertyRNA *prop;
2242
2243   srna = RNA_def_struct(brna, "Stereo3dDisplay", NULL);
2244   RNA_def_struct_sdna(srna, "Stereo3dFormat");
2245   RNA_def_struct_clear_flag(srna, STRUCT_UNDO);
2246   RNA_def_struct_ui_text(srna, "Stereo 3D Display", "Settings for stereo 3D display");
2247
2248   prop = RNA_def_property(srna, "display_mode", PROP_ENUM, PROP_NONE);
2249   RNA_def_property_enum_items(prop, rna_enum_stereo3d_display_items);
2250   RNA_def_property_ui_text(prop, "Display Mode", "");
2251
2252   prop = RNA_def_property(srna, "anaglyph_type", PROP_ENUM, PROP_NONE);
2253   RNA_def_property_enum_items(prop, rna_enum_stereo3d_anaglyph_type_items);
2254   RNA_def_property_ui_text(prop, "Anaglyph Type", "");
2255
2256   prop = RNA_def_property(srna, "interlace_type", PROP_ENUM, PROP_NONE);
2257   RNA_def_property_enum_items(prop, rna_enum_stereo3d_interlace_type_items);
2258   RNA_def_property_ui_text(prop, "Interlace Type", "");
2259
2260   prop = RNA_def_property(srna, "use_interlace_swap", PROP_BOOLEAN, PROP_BOOLEAN);
2261   RNA_def_property_boolean_sdna(prop, NULL, "flag", S3D_INTERLACE_SWAP);
2262   RNA_def_property_ui_text(prop, "Swap Left/Right", "Swap left and right stereo channels");
2263
2264   prop = RNA_def_property(srna, "use_sidebyside_crosseyed", PROP_BOOLEAN, PROP_BOOLEAN);
2265   RNA_def_property_boolean_sdna(prop, NULL, "flag", S3D_SIDEBYSIDE_CROSSEYED);
2266   RNA_def_property_ui_text(prop, "Cross-Eyed", "Right eye should see left image and vice-versa");
2267 }
2268
2269 static void rna_def_window(BlenderRNA *brna)
2270 {
2271   StructRNA *srna;
2272   PropertyRNA *prop;
2273
2274   srna = RNA_def_struct(brna, "Window", NULL);
2275   RNA_def_struct_ui_text(srna, "Window", "Open window");
2276   RNA_def_struct_sdna(srna, "wmWindow");
2277
2278   prop = RNA_def_property(srna, "parent", PROP_POINTER, PROP_NONE);
2279   RNA_def_property_ui_text(prop, "Parent Window", "Active workspace and scene follow this window");
2280
2281   rna_def_window_stereo3d(brna);
2282
2283   prop = RNA_def_property(srna, "scene", PROP_POINTER, PROP_NONE);
2284   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_NULL);
2285   RNA_def_property_pointer_funcs(prop, NULL, "rna_Window_scene_set", NULL, NULL);
2286   RNA_def_property_ui_text(prop, "Scene", "Active scene to be edited in the window");
2287   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
2288   RNA_def_property_update(prop, 0, "rna_Window_scene_update");
2289
2290   prop = RNA_def_property(srna, "workspace", PROP_POINTER, PROP_NONE);
2291   RNA_def_property_flag(prop, PROP_NEVER_NULL);
2292   RNA_def_property_struct_type(prop, "WorkSpace");
2293   RNA_def_property_ui_text(prop, "Workspace", "Active workspace showing in the window");
2294   RNA_def_property_pointer_funcs(
2295       prop, "rna_Window_workspace_get", "rna_Window_workspace_set", NULL, NULL);
2296   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_CONTEXT_UPDATE);
2297   RNA_def_property_update(prop, 0, "rna_Window_workspace_update");
2298
2299   prop = RNA_def_property(srna, "screen", PROP_POINTER, PROP_NONE);
2300   RNA_def_property_struct_type(prop, "Screen");
2301   RNA_def_property_ui_text(prop, "Screen", "Active workspace screen showing in the window");
2302   RNA_def_property_pointer_funcs(prop,
2303                                  "rna_Window_screen_get",
2304                                  "rna_Window_screen_set",
2305                                  NULL,
2306                                  "rna_Window_screen_assign_poll");
2307   RNA_def_property_flag(prop, PROP_NEVER_NULL | PROP_EDITABLE | PROP_CONTEXT_UPDATE);
2308   RNA_def_property_update(prop, 0, "rna_workspace_screen_update");
2309
2310   prop = RNA_def_property(srna, "view_layer", PROP_POINTER, PROP_NONE);
2311   RNA_def_property_struct_type(prop, "ViewLayer");
2312   RNA_def_property_pointer_funcs(
2313       prop, "rna_Window_view_layer_get", "rna_Window_view_layer_set", NULL, NULL);
2314   RNA_def_property_ui_text(
2315       prop, "Active View Layer", "The active workspace view layer showing in the window");
2316   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_NULL);
2317   RNA_def_property_update(prop, NC_SCREEN | ND_LAYER, NULL);
2318
2319   prop = RNA_def_property(srna, "x", PROP_INT, PROP_NONE);
2320   RNA_def_property_int_sdna(prop, NULL, "posx");
2321   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2322   RNA_def_property_ui_text(prop, "X Position", "Horizontal location of the window");
2323
2324   prop = RNA_def_property(srna, "y", PROP_INT, PROP_NONE);
2325   RNA_def_property_int_sdna(prop, NULL, "posy");
2326   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2327   RNA_def_property_ui_text(prop, "Y Position", "Vertical location of the window");
2328
2329   prop = RNA_def_property(srna, "width", PROP_INT, PROP_UNSIGNED);
2330   RNA_def_property_int_sdna(prop, NULL, "sizex");
2331   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2332   RNA_def_property_ui_text(prop, "Width", "Window width");
2333
2334   prop = RNA_def_property(srna, "height", PROP_INT, PROP_UNSIGNED);
2335   RNA_def_property_int_sdna(prop, NULL, "sizey");
2336   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2337   RNA_def_property_ui_text(prop, "Height", "Window height");
2338
2339   prop = RNA_def_property(srna, "stereo_3d_display", PROP_POINTER, PROP_NONE);
2340   RNA_def_property_pointer_sdna(prop, NULL, "stereo3d_format");
2341   RNA_def_property_flag(prop, PROP_NEVER_NULL);
2342   RNA_def_property_struct_type(prop, "Stereo3dDisplay");
2343   RNA_def_property_ui_text(prop, "Stereo 3D Display", "Settings for stereo 3d display");
2344
2345   RNA_api_window(srna);
2346 }
2347
2348 /* curve.splines */
2349 static void rna_def_wm_keyconfigs(BlenderRNA *brna, PropertyRNA *cprop)
2350 {
2351   StructRNA *srna;
2352   PropertyRNA *prop;
2353
2354   RNA_def_property_srna(cprop, "KeyConfigurations");
2355   srna = RNA_def_struct(brna, "KeyConfigurations", NULL);
2356   RNA_def_struct_sdna(srna, "wmWindowManager");
2357   RNA_def_struct_ui_text(srna, "KeyConfigs", "Collection of KeyConfigs");
2358
2359   prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
2360   RNA_def_property_struct_type(prop, "KeyConfig");
2361   RNA_def_property_pointer_funcs(prop,
2362                                  "rna_WindowManager_active_keyconfig_get",
2363                                  "rna_WindowManager_active_keyconfig_set",
2364                                  NULL,
2365                                  NULL);
2366   RNA_def_property_flag(prop, PROP_EDITABLE);
2367   RNA_def_property_ui_text(prop, "Active KeyConfig", "Active key configuration (preset)");
2368
2369   prop = RNA_def_property(srna, "default", PROP_POINTER, PROP_NEVER_NULL);
2370   RNA_def_property_pointer_sdna(prop, NULL, "defaultconf");
2371   RNA_def_property_struct_type(prop, "KeyConfig");
2372   RNA_def_property_ui_text(prop, "Default Key Configuration", "Default builtin key configuration");
2373
2374   prop = RNA_def_property(srna, "addon", PROP_POINTER, PROP_NEVER_NULL);
2375   RNA_def_property_pointer_sdna(prop, NULL, "addonconf");
2376   RNA_def_property_struct_type(prop, "KeyConfig");
2377   RNA_def_property_ui_text(
2378       prop,
2379       "Add-on Key Configuration",
2380       "Key configuration that can be extended by add-ons, and is added to the active "
2381       "configuration when handling events");
2382
2383   prop = RNA_def_property(srna, "user", PROP_POINTER, PROP_NEVER_NULL);
2384   RNA_def_property_pointer_sdna(prop, NULL, "userconf");
2385   RNA_def_property_struct_type(prop, "KeyConfig");
2386   RNA_def_property_ui_text(
2387       prop,
2388       "User Key Configuration",
2389       "Final key configuration that combines keymaps from the active and add-on configurations, "
2390       "and can be edited by the user");
2391
2392   RNA_api_keyconfigs(srna);
2393 }
2394
2395 static void rna_def_windowmanager(BlenderRNA *brna)
2396 {
2397   StructRNA *srna;
2398   PropertyRNA *prop;
2399
2400   srna = RNA_def_struct(brna, "WindowManager", "ID");
2401   RNA_def_struct_ui_text(
2402       srna,
2403       "Window Manager",
2404       "Window manager data-block defining open windows and other user interface data");
2405   RNA_def_struct_clear_flag(srna, STRUCT_ID_REFCOUNT);
2406   RNA_def_struct_sdna(srna, "wmWindowManager");
2407
2408   prop = RNA_def_property(srna, "operators", PROP_COLLECTION, PROP_NONE);
2409   RNA_def_property_struct_type(prop, "Operator");
2410   RNA_def_property_ui_text(prop, "Operators", "Operator registry");
2411
2412   prop = RNA_def_property(srna, "windows", PROP_COLLECTION, PROP_NONE);
2413   RNA_def_property_struct_type(prop, "Window");
2414   RNA_def_property_ui_text(prop, "Windows", "Open windows");
2415
2416   prop = RNA_def_property(srna, "keyconfigs", PROP_COLLECTION, PROP_NONE);
2417   RNA_def_property_struct_type(prop, "KeyConfig");
2418   RNA_def_property_ui_text(prop, "Key Configurations", "Registered key configurations");
2419   rna_def_wm_keyconfigs(brna, prop);
2420
2421   prop = RNA_def_property(srna, "clipboard", PROP_STRING, PROP_NONE);
2422   RNA_def_property_string_funcs(
2423       prop, "rna_wmClipboard_get", "rna_wmClipboard_length", "rna_wmClipboard_set");
2424   RNA_def_property_ui_text(prop, "Text Clipboard", "");
2425
2426   RNA_api_wm(srna);
2427 }
2428
2429 /* keyconfig.items */
2430 static void rna_def_keymap_items(BlenderRNA *brna, PropertyRNA *cprop)
2431 {
2432   StructRNA *srna;
2433
2434   RNA_def_property_srna(cprop, "KeyMapItems");
2435   srna = RNA_def_struct(brna, "KeyMapItems", NULL);
2436   RNA_def_struct_sdna(srna, "wmKeyMap");
2437   RNA_def_struct_ui_text(srna, "KeyMap Items", "Collection of keymap items");
2438
2439   RNA_api_keymapitems(srna);
2440 }
2441
2442 static void rna_def_wm_keymaps(BlenderRNA *brna, PropertyRNA *cprop)
2443 {
2444   StructRNA *srna;
2445
2446   RNA_def_property_srna(cprop, "KeyMaps");
2447   srna = RNA_def_struct(brna, "KeyMaps", NULL);
2448   RNA_def_struct_sdna(srna, "wmKeyConfig");
2449   RNA_def_struct_ui_text(srna, "Key Maps", "Collection of keymaps");
2450
2451   RNA_api_keymaps(srna);
2452 }
2453
2454 static void rna_def_keyconfig_prefs(BlenderRNA *brna)
2455 {
2456   StructRNA *srna;
2457   PropertyRNA *prop;
2458
2459   srna = RNA_def_struct(brna, "KeyConfigPreferences", NULL);
2460   RNA_def_struct_ui_text(srna, "Key-Config Preferences", "");
2461   RNA_def_struct_sdna(srna, "wmKeyConfigPref"); /* WARNING: only a bAddon during registration */
2462
2463   RNA_def_struct_refine_func(srna, "rna_wmKeyConfigPref_refine");
2464   RNA_def_struct_register_funcs(
2465       srna, "rna_wmKeyConfigPref_register", "rna_wmKeyConfigPref_unregister", NULL);
2466   RNA_def_struct_idprops_func(srna, "rna_wmKeyConfigPref_idprops");
2467   RNA_def_struct_flag(srna, STRUCT_NO_DATABLOCK_IDPROPERTIES); /* Mandatory! */
2468
2469   /* registration */
2470   RNA_define_verify_sdna(0);
2471   prop = RNA_def_property(srna, "bl_idname", PROP_STRING, PROP_NONE);
2472   RNA_def_property_string_sdna(prop, NULL, "idname");
2473   RNA_def_property_flag(prop, PROP_REGISTER);
2474   RNA_define_verify_sdna(1);
2475 }
2476
2477 static void rna_def_keyconfig(BlenderRNA *brna)
2478 {
2479   StructRNA *srna;
2480   PropertyRNA *prop;
2481
2482   static const EnumPropertyItem map_type_items[] = {
2483       {KMI_TYPE_KEYBOARD, "KEYBOARD", 0, "Keyboard", ""},
2484       {KMI_TYPE_TWEAK, "TWEAK", 0, "Tweak", ""},
2485       {KMI_TYPE_MOUSE, "MOUSE", 0, "Mouse", ""},
2486       {KMI_TYPE_NDOF, "NDOF", 0, "NDOF", ""},
2487       {KMI_TYPE_TEXTINPUT, "TEXTINPUT", 0, "Text Input", ""},
2488       {KMI_TYPE_TIMER, "TIMER", 0, "Timer", ""},
2489       {0, NULL, 0, NULL, NULL},
2490   };
2491
2492   /* KeyConfig */
2493   srna = RNA_def_struct(brna, "KeyConfig", NULL);
2494   RNA_def_struct_sdna(srna, "wmKeyConfig");
2495   RNA_def_struct_ui_text(srna, "Key Configuration", "Input configuration, including keymaps");
2496
2497   prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
2498   RNA_def_property_string_sdna(prop, NULL, "idname");
2499   RNA_def_property_ui_text(prop, "Name", "Name of the key configuration");
2500   RNA_def_struct_name_property(srna, prop);
2501
2502   prop = RNA_def_property(srna, "keymaps", PROP_COLLECTION, PROP_NONE);
2503   RNA_def_property_struct_type(prop, "KeyMap");
2504   RNA_def_property_ui_text(prop, "Key Maps", "Key maps configured as part of this configuration");
2505   rna_def_wm_keymaps(brna, prop);
2506
2507   prop = RNA_def_property(srna, "is_user_defined", PROP_BOOLEAN, PROP_NONE);
2508   RNA_def_property_boolean_sdna(prop, NULL, "flag", KEYCONF_USER);
2509   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2510   RNA_def_property_ui_text(
2511       prop, "User Defined", "Indicates that a keyconfig was defined by the user");
2512
2513   /* Collection active property */
2514   prop = RNA_def_property(srna, "preferences", PROP_POINTER, PROP_NONE);
2515   RNA_def_property_struct_type(prop, "KeyConfigPreferences");
2516   RNA_def_property_pointer_funcs(prop, "rna_wmKeyConfig_preferences_get", NULL, NULL, NULL);
2517
2518   RNA_api_keyconfig(srna);
2519
2520   /* KeyMap */
2521   srna = RNA_def_struct(brna, "KeyMap", NULL);
2522   RNA_def_struct_sdna(srna, "wmKeyMap");
2523   RNA_def_struct_ui_text(srna, "Key Map", "Input configuration, including keymaps");
2524
2525   prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
2526   RNA_def_property_string_sdna(prop, NULL, "idname");
2527   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2528   RNA_def_property_ui_text(prop, "Name", "Name of the key map");
2529   RNA_def_struct_name_property(srna, prop);
2530
2531   prop = RNA_def_property(srna, "bl_owner_id", PROP_STRING, PROP_NONE);
2532   RNA_def_property_string_sdna(prop, NULL, "owner_id");
2533   RNA_def_property_ui_text(prop, "Owner", "Internal owner");
2534
2535   prop = RNA_def_property(srna, "space_type", PROP_ENUM, PROP_NONE);
2536   RNA_def_property_enum_sdna(prop, NULL, "spaceid");
2537   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2538   RNA_def_property_enum_items(prop, rna_enum_space_type_items);
2539   RNA_def_property_ui_text(prop, "Space Type", "Optional space type keymap is associated with");
2540
2541   prop = RNA_def_property(srna, "region_type", PROP_ENUM, PROP_NONE);
2542   RNA_def_property_enum_sdna(prop, NULL, "regionid");
2543   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2544   RNA_def_property_enum_items(prop, rna_enum_region_type_items);
2545   RNA_def_property_ui_text(prop, "Region Type", "Optional region type keymap is associated with");
2546
2547   prop = RNA_def_property(srna, "keymap_items", PROP_COLLECTION, PROP_NONE);
2548   RNA_def_property_collection_sdna(prop, NULL, "items", NULL);
2549   RNA_def_property_struct_type(prop, "KeyMapItem");
2550   RNA_def_property_ui_text(
2551       prop, "Items", "Items in the keymap, linking an operator to an input event");
2552   rna_def_keymap_items(brna, prop);
2553
2554   prop = RNA_def_property(srna, "is_user_modified", PROP_BOOLEAN, PROP_NONE);
2555   RNA_def_property_boolean_sdna(prop, NULL, "flag", KEYMAP_USER_MODIFIED);
2556   RNA_def_property_ui_text(prop, "User Defined", "Keymap is defined by the user");
2557
2558   prop = RNA_def_property(srna, "is_modal", PROP_BOOLEAN, PROP_NONE);
2559   RNA_def_property_boolean_sdna(prop, NULL, "flag", KEYMAP_MODAL);
2560   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2561   RNA_def_property_ui_text(
2562       prop,
2563       "Modal Keymap",
2564       "Indicates that a keymap is used for translate modal events for an operator");
2565
2566   prop = RNA_def_property(srna, "show_expanded_items", PROP_BOOLEAN, PROP_NONE);
2567   RNA_def_property_boolean_sdna(prop, NULL, "flag", KEYMAP_EXPANDED);
2568   RNA_def_property_ui_text(prop, "Items Expanded", "Expanded in the user interface");
2569   RNA_def_property_ui_icon(prop, ICON_DISCLOSURE_TRI_RIGHT, 1);
2570
2571   prop = RNA_def_property(srna, "show_expanded_children", PROP_BOOLEAN, PROP_NONE);
2572   RNA_def_property_boolean_sdna(prop, NULL, "flag", KEYMAP_CHILDREN_EXPANDED);
2573   RNA_def_property_ui_text(prop, "Children Expanded", "Children expanded in the user interface");
2574   RNA_def_property_ui_icon(prop, ICON_DISCLOSURE_TRI_RIGHT, 1);
2575
2576   RNA_api_keymap(srna);
2577
2578   /* KeyMapItem */
2579   srna = RNA_def_struct(brna, "KeyMapItem", NULL);
2580   RNA_def_struct_sdna(srna, "wmKeyMapItem");
2581   RNA_def_struct_ui_text(srna, "Key Map Item", "Item in a Key Map");
2582
2583   prop = RNA_def_property(srna, "idname", PROP_STRING, PROP_NONE);
2584   RNA_def_property_string_sdna(prop, NULL, "idname");
2585   RNA_def_property_ui_text(prop, "Identifier", "Identifier of operator to call on input event");
2586   RNA_def_property_string_funcs(prop,
2587                                 "rna_wmKeyMapItem_idname_get",
2588                                 "rna_wmKeyMapItem_idname_length",
2589                                 "rna_wmKeyMapItem_idname_set");
2590   RNA_def_struct_name_property(srna, prop);
2591   RNA_def_property_update(prop, 0, "rna_KeyMapItem_update");
2592
2593   /* this is in fact the operator name, but if the operator can't be found we
2594    * fallback on the operator ID */
2595   prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
2596   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2597   RNA_def_property_ui_text(prop, "Name", "Name of operator (translated) to call on input event");
2598   RNA_def_property_string_funcs(
2599       prop, "rna_wmKeyMapItem_name_get", "rna_wmKeyMapItem_name_length", NULL);
2600
2601   prop = RNA_def_property(srna, "properties", PROP_POINTER, PROP_NONE);
2602   RNA_def_property_struct_type(prop, "OperatorProperties");
2603   RNA_def_property_pointer_funcs(prop, "rna_KeyMapItem_properties_get", NULL, NULL, NULL);
2604   RNA_def_property_ui_text(prop, "Properties", "Properties to set when the operator is called");
2605   RNA_def_property_update(prop, 0, "rna_KeyMapItem_update");
2606
2607   prop = RNA_def_property(srna, "map_type", PROP_ENUM, PROP_NONE);
2608   RNA_def_property_enum_sdna(prop, NULL, "maptype");
2609   RNA_def_property_enum_items(prop, map_type_items);
2610   RNA_def_property_enum_funcs(
2611       prop, "rna_wmKeyMapItem_map_type_get", "rna_wmKeyMapItem_map_type_set", NULL);
2612   RNA_def_property_ui_text(prop, "Map Type", "Type of event mapping");
2613   RNA_def_property_update(prop, 0, "rna_KeyMapItem_update");
2614
2615   prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
2616   RNA_def_property_enum_sdna(prop, NULL, "type");
2617   RNA_def_property_enum_items(prop, rna_enum_event_type_items);
2618   RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_UI_EVENTS);
2619   RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_KeyMapItem_type_itemf");
2620   RNA_def_property_ui_text(prop, "Type", "Type of event");
2621   RNA_def_property_update(prop, 0, "rna_KeyMapItem_update");
2622
2623   prop = RNA_def_property(srna, "value", PROP_ENUM, PROP_NONE);
2624   RNA_def_property_enum_sdna(prop, NULL, "val");
2625   RNA_def_property_enum_items(prop, rna_enum_event_value_items);
2626   RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_KeyMapItem_value_itemf");
2627   RNA_def_property_ui_text(prop, "Value", "");
2628   RNA_def_property_update(prop, 0, "rna_KeyMapItem_update");
2629
2630   prop = RNA_def_property(srna, "id", PROP_INT, PROP_NONE);
2631   RNA_def_property_int_sdna(prop, NULL, "id");
2632   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2633   RNA_def_property_ui_text(prop, "ID", "ID of the item");
2634   RNA_def_property_update(prop, 0, "rna_KeyMapItem_update");
2635
2636   prop = RNA_def_property(srna, "any", PROP_BOOLEAN, PROP_NONE);
2637   RNA_def_property_boolean_funcs(prop, "rna_KeyMapItem_any_get", "rna_KeyMapItem_any_set");
2638   RNA_def_property_ui_text(prop, "Any", "Any modifier keys pressed");
2639   RNA_def_property_update(prop, 0, "rna_KeyMapItem_update");
2640
2641   prop = RNA_def_property(srna, "shift", PROP_BOOLEAN, PROP_NONE);
2642   RNA_def_property_boolean_sdna(prop, NULL, "shift", 0);
2643   RNA_def_property_boolean_funcs(prop, "rna_KeyMapItem_shift_get", NULL);
2644   /*  RNA_def_property_enum_sdna(prop, NULL, "shift"); */
2645   /*  RNA_def_property_enum_items(prop, keymap_modifiers_items); */
2646   RNA_def_property_ui_text(prop, "Shift", "Shift key pressed");
2647   RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_ID_WINDOWMANAGER);
2648   RNA_def_property_update(prop, 0, "rna_KeyMapItem_update");
2649
2650   prop = RNA_def_property(srna, "ctrl", PROP_BOOLEAN, PROP_NONE);
2651   RNA_def_property_boolean_sdna(prop, NULL, "ctrl", 0);
2652   RNA_def_property_boolean_funcs(prop, "rna_KeyMapItem_ctrl_get", NULL);
2653   /*  RNA_def_property_enum_sdna(prop, NULL, "ctrl"); */
2654   /*  RNA_def_property_enum_items(prop, keymap_modifiers_items); */
2655   RNA_def_property_ui_text(prop, "Ctrl", "Control key pressed");
2656   RNA_def_property_update(prop, 0, "rna_KeyMapItem_update");
2657
2658   prop = RNA_def_property(srna, "alt", PROP_BOOLEAN, PROP_NONE);
2659   RNA_def_property_boolean_sdna(prop, NULL, "alt", 0);
2660   RNA_def_property_boolean_funcs(prop, "rna_KeyMapItem_alt_get", NULL);
2661   /*  RNA_def_property_enum_sdna(prop, NULL, "alt"); */
2662   /*  RNA_def_property_enum_items(prop, keymap_modifiers_items); */
2663   RNA_def_property_ui_text(prop, "Alt", "Alt key pressed");
2664   RNA_def_property_update(prop, 0, "rna_KeyMapItem_update");
2665
2666   prop = RNA_def_property(srna, "oskey", PROP_BOOLEAN, PROP_NONE);
2667   RNA_def_property_boolean_sdna(prop, NULL, "oskey", 0);
2668   RNA_def_property_boolean_funcs(prop, "rna_KeyMapItem_oskey_get", NULL);
2669   /*  RNA_def_property_enum_sdna(prop, NULL, "oskey"); */
2670   /*  RNA_def_property_enum_items(prop, keymap_modifiers_items); */
2671   RNA_def_property_ui_text(prop, "OS Key", "Operating system key pressed");
2672   RNA_def_property_update(prop, 0, "rna_KeyMapItem_update");
2673
2674   prop = RNA_def_property(srna, "key_modifier", PROP_ENUM, PROP_NONE);
2675   RNA_def_property_enum_sdna(prop, NULL, "keymodifier");
2676   RNA_def_property_enum_items(prop, rna_enum_event_type_items);
2677   RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_UI_EVENTS);
2678   RNA_def_property_enum_funcs(prop, NULL, "rna_wmKeyMapItem_keymodifier_set", NULL);
2679   RNA_def_property_ui_text(prop, "Key Modifier", "Regular key pressed as a modifier");
2680   RNA_def_property_update(prop, 0, "rna_KeyMapItem_update");
2681
2682   prop = RNA_def_property(srna, "show_expanded", PROP_BOOLEAN, PROP_NONE);
2683   RNA_def_property_flag(prop, PROP_NO_DEG_UPDATE);
2684   RNA_def_property_boolean_sdna(prop, NULL, "flag", KMI_EXPANDED);
2685   RNA_def_property_ui_text(
2686       prop, "Expanded", "Show key map event and property details in the user interface");
2687   RNA_def_property_ui_icon(prop, ICON_DISCLOSURE_TRI_RIGHT, 1);
2688
2689   prop = RNA_def_property(srna, "propvalue", PROP_ENUM, PROP_NONE);
2690   RNA_def_property_enum_sdna(prop, NULL, "propvalue");
2691   RNA_def_property_enum_items(prop, rna_enum_keymap_propvalue_items);
2692   RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_KeyMapItem_propvalue_itemf");
2693   RNA_def_property_ui_text(
2694       prop, "Property Value", "The value this event translates to in a modal keymap");
2695   RNA_def_property_update(prop, 0, "rna_KeyMapItem_update");
2696
2697   prop = RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
2698   RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", KMI_INACTIVE);
2699   RNA_def_property_ui_text(prop, "Active", "Activate or deactivate item");
2700   RNA_def_property_ui_icon(prop, ICON_CHECKBOX_DEHLT, 1);
2701   RNA_def_property_update(prop, 0, "rna_KeyMapItem_update");
2702
2703   prop = RNA_def_property(srna, "is_user_modified", PROP_BOOLEAN, PROP_NONE);
2704   RNA_def_property_boolean_sdna(prop, NULL, "flag", KMI_USER_MODIFIED);
2705   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2706   RNA_def_property_ui_text(prop, "User Modified", "Is this keymap item modified by the user");
2707
2708   prop = RNA_def_property(srna, "is_user_defined", PROP_BOOLEAN, PROP_NONE);
2709   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2710   RNA_def_property_ui_text(
2711       prop,
2712       "User Defined",
2713       "Is this keymap item user defined (doesn't just replace a builtin item)");
2714   RNA_def_property_boolean_funcs(prop, "rna_KeyMapItem_userdefined_get", NULL);
2715
2716   RNA_api_keymapitem(srna);
2717 }
2718
2719 void RNA_def_wm(BlenderRNA *brna)
2720 {
2721   rna_def_operator(brna);
2722   rna_def_operator_options_runtime(brna);
2723   rna_def_operator_utils(brna);
2724   rna_def_operator_filelist_element(brna);
2725   rna_def_macro_operator(brna);
2726   rna_def_operator_type_macro(brna);
2727   rna_def_event(brna);
2728   rna_def_timer(brna);
2729   rna_def_popupmenu(brna);
2730   rna_def_popovermenu(brna);
2731   rna_def_piemenu(brna);
2732   rna_def_window(brna);
2733   rna_def_windowmanager(brna);
2734   rna_def_keyconfig_prefs(brna);
2735   rna_def_keyconfig(brna);
2736 }
2737
2738 #endif /* RNA_RUNTIME */