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