Cleanup: use `rna_enum_` prefix for RNA enums
[blender.git] / source / blender / makesdna / DNA_windowmanager_types.h
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version. 
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2007 Blender Foundation.
19  * All rights reserved.
20  *
21  * 
22  * Contributor(s): Blender Foundation
23  *
24  * ***** END GPL LICENSE BLOCK *****
25  */
26
27 /** \file DNA_windowmanager_types.h
28  *  \ingroup DNA
29  */
30
31 #ifndef __DNA_WINDOWMANAGER_TYPES_H__
32 #define __DNA_WINDOWMANAGER_TYPES_H__
33
34 #include "DNA_listBase.h"
35 #include "DNA_vec_types.h"
36 #include "DNA_userdef_types.h"
37
38 #include "DNA_ID.h"
39
40 /* defined here: */
41 struct wmWindowManager;
42 struct wmWindow;
43
44 struct wmEvent;
45 struct wmGesture;
46 struct wmOperatorType;
47 struct wmOperator;
48 struct wmKeyMap;
49 struct wmKeyConfig;
50
51 /* forwards */
52 struct bContext;
53 struct bScreen;
54 struct wmSubWindow;
55 struct wmTimer;
56 struct PointerRNA;
57 struct ReportList;
58 struct Report;
59 struct uiLayout;
60 struct Stereo3dFormat;
61
62 #define OP_MAX_TYPENAME 64
63 #define KMAP_MAX_NAME   64
64
65 /* keep in sync with 'rna_enum_wm_report_items' in wm_rna.c */
66 typedef enum ReportType {
67         RPT_DEBUG                   = (1 << 0),
68         RPT_INFO                    = (1 << 1),
69         RPT_OPERATOR                = (1 << 2),
70         RPT_PROPERTY                = (1 << 3),
71         RPT_WARNING                 = (1 << 4),
72         RPT_ERROR                   = (1 << 5),
73         RPT_ERROR_INVALID_INPUT     = (1 << 6),
74         RPT_ERROR_INVALID_CONTEXT   = (1 << 7),
75         RPT_ERROR_OUT_OF_MEMORY     = (1 << 8),
76 } ReportType;
77
78 #define RPT_DEBUG_ALL       (RPT_DEBUG)
79 #define RPT_INFO_ALL        (RPT_INFO)
80 #define RPT_OPERATOR_ALL    (RPT_OPERATOR)
81 #define RPT_PROPERTY_ALL    (RPT_PROPERTY)
82 #define RPT_WARNING_ALL     (RPT_WARNING)
83 #define RPT_ERROR_ALL       (RPT_ERROR|RPT_ERROR_INVALID_INPUT|RPT_ERROR_INVALID_CONTEXT|RPT_ERROR_OUT_OF_MEMORY)
84
85 enum ReportListFlags {
86         RPT_PRINT   = (1 << 0),
87         RPT_STORE   = (1 << 1),
88         RPT_FREE    = (1 << 2),
89         RPT_OP_HOLD = (1 << 3), /* don't move them into the operator global list (caller will use) */
90 };
91
92 /* These two Lines with # tell makesdna this struct can be excluded. */
93 #
94 #
95 typedef struct Report {
96         struct Report *next, *prev;
97         short type;  /* ReportType */
98         short flag;
99         int len;  /* strlen(message), saves some time calculating the word wrap  */
100         const char *typestr;
101         const char *message;
102 } Report;
103
104 /* saved in the wm, don't remove */
105 typedef struct ReportList {
106         ListBase list;
107         int printlevel;  /* ReportType */
108         int storelevel;  /* ReportType */
109         int flag, pad;
110         struct wmTimer *reporttimer;
111 } ReportList;
112
113 /* timer customdata to control reports display */
114 /* These two Lines with # tell makesdna this struct can be excluded. */
115 #
116 #
117 typedef struct ReportTimerInfo {
118         float col[3];
119         float grayscale;
120         float widthfac;
121 } ReportTimerInfo;
122
123 /* reports need to be before wmWindowManager */
124
125
126 /* windowmanager is saved, tag WMAN */
127 typedef struct wmWindowManager {
128         ID id;
129
130         struct wmWindow *windrawable, *winactive;  /* separate active from drawable */
131         ListBase windows;
132
133         int initialized;                  /* set on file read */
134         short file_saved;                 /* indicator whether data was saved */
135         short op_undo_depth;              /* operator stack depth to avoid nested undo pushes */
136
137         ListBase operators;               /* operator registry */
138
139         ListBase queue;                   /* refresh/redraw wmNotifier structs */
140
141         struct ReportList reports;        /* information and error reports */
142
143         ListBase jobs;                    /* threaded jobs manager */
144
145         ListBase paintcursors;            /* extra overlay cursors to draw, like circles */
146
147         ListBase drags;                   /* active dragged items */
148
149         ListBase keyconfigs;              /* known key configurations */
150         struct wmKeyConfig *defaultconf;  /* default configuration */
151         struct wmKeyConfig *addonconf;    /* addon configuration */
152         struct wmKeyConfig *userconf;     /* user configuration */
153
154         ListBase timers;                  /* active timers */
155         struct wmTimer *autosavetimer;    /* timer for auto save */
156
157         char is_interface_locked;               /* indicates whether interface is locked for user interaction */
158         char par[7];
159 } wmWindowManager;
160
161 /* wmWindowManager.initialized */
162 enum {
163         WM_INIT_WINDOW = (1<<0),
164         WM_INIT_KEYMAP = (1<<1),
165 };
166
167 /* IME is win32 only! */
168 #ifndef WIN32
169 #  ifdef __GNUC__
170 #    define ime_data ime_data __attribute__ ((deprecated))
171 #  endif
172 #endif
173
174 /* the savable part, rest of data is local in ghostwinlay */
175 typedef struct wmWindow {
176         struct wmWindow *next, *prev;
177
178         void *ghostwin;             /* don't want to include ghost.h stuff */
179
180         struct bScreen *screen;     /* active screen */
181         struct bScreen *newscreen;  /* temporary when switching */
182         char screenname[64];        /* MAX_ID_NAME for matching window with active screen after file read */
183
184         short posx, posy, sizex, sizey;  /* window coords */
185         short windowstate;  /* borderless, full */
186         short monitor;      /* multiscreen... no idea how to store yet */
187         short active;       /* set to 1 if an active window, for quick rejects */
188         short cursor;       /* current mouse cursor type */
189         short lastcursor;   /* previous cursor when setting modal one */
190         short modalcursor;  /* the current modal cursor */
191         short grabcursor;           /* cursor grab mode */
192         short addmousemove; /* internal: tag this for extra mousemove event, makes cursors/buttons active on UI switching */
193
194         int winid;                  /* winid also in screens, is for retrieving this window after read */
195
196         short lock_pie_event;      /* internal, lock pie creation from this event until released */
197         short last_pie_event;      /* exception to the above rule for nested pies, store last pie event for operators
198                                     * that spawn a new pie right after destruction of last pie */
199
200         struct wmEvent *eventstate;   /* storage for event system */
201
202         struct wmSubWindow *curswin;  /* internal for wm_subwindow.c only */
203
204         struct wmGesture *tweak;      /* internal for wm_operators.c */
205
206         /* Input Method Editor data - complex character input (esp. for asian character input)
207          * Currently WIN32, runtime-only data */
208         struct wmIMEData *ime_data;
209
210         int drawmethod, drawfail;     /* internal for wm_draw.c only */
211         ListBase drawdata;            /* internal for wm_draw.c only */
212
213         ListBase queue;               /* all events (ghost level events were handled) */
214         ListBase handlers;            /* window+screen handlers, handled last */
215         ListBase modalhandlers;       /* priority handlers, handled first */
216
217         ListBase subwindows;          /* opengl stuff for sub windows, see notes in wm_subwindow.c */
218         ListBase gesture;             /* gesture stuff */
219
220         struct Stereo3dFormat *stereo3d_format; /* properties for stereoscopic displays */
221 } wmWindow;
222
223 #ifdef ime_data
224 #  undef ime_data
225 #endif
226
227 /* These two Lines with # tell makesdna this struct can be excluded. */
228 /* should be something like DNA_EXCLUDE 
229  * but the preprocessor first removes all comments, spaces etc */
230 #
231 #
232 typedef struct wmOperatorTypeMacro {
233         struct wmOperatorTypeMacro *next, *prev;
234
235         /* operator id */
236         char idname[64];
237         /* rna pointer to access properties, like keymap */
238         struct IDProperty *properties;  /* operator properties, assigned to ptr->data and can be written to a file */
239         struct PointerRNA *ptr;
240 } wmOperatorTypeMacro;
241
242 /* partial copy of the event, for matching by eventhandler */
243 typedef struct wmKeyMapItem {
244         struct wmKeyMapItem *next, *prev;
245
246         /* operator */
247         char idname[64];                /* used to retrieve operator type pointer */
248         IDProperty *properties;         /* operator properties, assigned to ptr->data and can be written to a file */
249
250         /* modal */
251         char propvalue_str[64];         /* runtime temporary storage for loading */
252         short propvalue;                /* if used, the item is from modal map */
253
254         /* event */
255         short type;                     /* event code itself */
256         short val;                      /* KM_ANY, KM_PRESS, KM_NOTHING etc */
257         short shift, ctrl, alt, oskey;  /* oskey is apple or windowskey, value denotes order of pressed */
258         short keymodifier;              /* rawkey modifier */
259
260         /* flag: inactive, expanded */
261         short flag;
262
263         /* runtime */
264         short maptype;                  /* keymap editor */
265         short id;                       /* unique identifier. Positive for kmi that override builtins, negative otherwise */
266         short pad;
267         struct PointerRNA *ptr;         /* rna pointer to access properties */
268 } wmKeyMapItem;
269
270 /* used instead of wmKeyMapItem for diff keymaps */
271 typedef struct wmKeyMapDiffItem {
272         struct wmKeyMapDiffItem *next, *prev;
273
274         wmKeyMapItem *remove_item;
275         wmKeyMapItem *add_item;
276 } wmKeyMapDiffItem;
277
278 /* wmKeyMapItem.flag */
279 enum {
280         KMI_INACTIVE       = (1 << 0),
281         KMI_EXPANDED       = (1 << 1),
282         KMI_USER_MODIFIED  = (1 << 2),
283         KMI_UPDATE         = (1 << 3),
284 };
285
286 /* wmKeyMapItem.maptype */
287 enum {
288         KMI_TYPE_KEYBOARD   = 0,
289         KMI_TYPE_MOUSE      = 1,
290         KMI_TYPE_TWEAK      = 2,
291         KMI_TYPE_TEXTINPUT  = 3,
292         KMI_TYPE_TIMER      = 4,
293         KMI_TYPE_NDOF       = 5,
294 };
295
296 /* stored in WM, the actively used keymaps */
297 typedef struct wmKeyMap {
298         struct wmKeyMap *next, *prev;
299
300         ListBase items;
301         ListBase diff_items;
302
303         char idname[64];  /* global editor keymaps, or for more per space/region */
304         short spaceid;    /* same IDs as in DNA_space_types.h */
305         short regionid;   /* see above */
306
307         short flag;       /* general flags */
308         short kmi_id;     /* last kmi id */
309
310         /* runtime */
311         int (*poll)(struct bContext *);  /* verify if enabled in the current context */
312         void *modal_items;               /* for modal, EnumPropertyItem for now */
313 } wmKeyMap;
314
315 /* wmKeyMap.flag */
316 enum {
317         KEYMAP_MODAL              = (1 << 0),  /* modal map, not using operatornames */
318         KEYMAP_USER               = (1 << 1),  /* user keymap */
319         KEYMAP_EXPANDED           = (1 << 2),
320         KEYMAP_CHILDREN_EXPANDED  = (1 << 3),
321         KEYMAP_DIFF               = (1 << 4),  /* diff keymap for user preferences */
322         KEYMAP_USER_MODIFIED      = (1 << 5),  /* keymap has user modifications */
323         KEYMAP_UPDATE             = (1 << 6),
324 };
325
326 typedef struct wmKeyConfig {
327         struct wmKeyConfig *next, *prev;
328
329         char idname[64];    /* unique name */
330         char basename[64];  /* idname of configuration this is derives from, "" if none */
331
332         ListBase keymaps;
333         int actkeymap, flag;
334 } wmKeyConfig;
335
336 /* wmKeyConfig.flag */
337 enum {
338         KEYCONF_USER          = (1 << 1),  /* And what about (1 << 0)? */
339         KEYCONF_INIT_DEFAULT  = (1 << 2),
340 };
341
342 /* this one is the operator itself, stored in files for macros etc */
343 /* operator + operatortype should be able to redo entirely, but for different contextes */
344 typedef struct wmOperator {
345         struct wmOperator *next, *prev;
346
347         /* saved */
348         char idname[64];              /* used to retrieve type pointer */
349         IDProperty *properties;       /* saved, user-settable properties */
350
351         /* runtime */
352         struct wmOperatorType *type;  /* operator type definition from idname */
353         void *customdata;             /* custom storage, only while operator runs */
354         void *py_instance;            /* python stores the class instance here */
355
356         struct PointerRNA *ptr;       /* rna pointer to access properties */
357         struct ReportList *reports;   /* errors and warnings storage */
358
359         ListBase macro;               /* list of operators, can be a tree */
360         struct wmOperator *opm;       /* current running macro, not saved */
361         struct uiLayout *layout;      /* runtime for drawing */
362         short flag, pad[3];
363
364 } wmOperator;
365
366 /* operator type return flags: exec(), invoke() modal(), return values */
367 enum {
368         OPERATOR_RUNNING_MODAL  = (1 << 0),
369         OPERATOR_CANCELLED      = (1 << 1),
370         OPERATOR_FINISHED       = (1 << 2),
371         /* add this flag if the event should pass through */
372         OPERATOR_PASS_THROUGH   = (1 << 3),
373         /* in case operator got executed outside WM code... like via fileselect */
374         OPERATOR_HANDLED        = (1 << 4),
375         /* used for operators that act indirectly (eg. popup menu)
376          * note: this isn't great design (using operators to trigger UI) avoid where possible. */
377         OPERATOR_INTERFACE      = (1 << 5),
378 };
379 #define OPERATOR_FLAGS_ALL ( \
380         OPERATOR_RUNNING_MODAL | \
381         OPERATOR_CANCELLED | \
382         OPERATOR_FINISHED | \
383         OPERATOR_PASS_THROUGH | \
384         OPERATOR_HANDLED | \
385         OPERATOR_INTERFACE | \
386         0)
387
388 /* sanity checks for debug mode only */
389 #define OPERATOR_RETVAL_CHECK(ret) (void)ret, BLI_assert(ret != 0 && (ret & OPERATOR_FLAGS_ALL) == ret)
390
391 /* wmOperator flag */
392 enum {
393         /* low level flag so exec() operators can tell if they were invoked, use with care.
394          * typically this shouldn't make any difference, but it rare cases its needed (see smooth-view) */
395         OP_IS_INVOKE = (1 << 0),
396
397         /* When the cursor is grabbed */
398         OP_IS_MODAL_GRAB_CURSOR    = (1 << 1),
399
400         /* allow modal operators to have the region under the cursor for their context
401          * (the regiontype is maintained to prevent errors) */
402         OP_IS_MODAL_CURSOR_REGION = (1 << 2),
403 };
404
405 #endif /* __DNA_WINDOWMANAGER_TYPES_H__ */