cf8dbdd8c630cf85d8cb47957c5dd1fcdff01e30
[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         short multisamples; /* amount of samples for OpenGL FSA the ghost window was created with, if zero no FSA */
194         short pad[3];
195
196         int winid;                  /* winid also in screens, is for retrieving this window after read */
197
198         short lock_pie_event;      /* internal, lock pie creation from this event until released */
199         short last_pie_event;      /* exception to the above rule for nested pies, store last pie event for operators
200                                     * that spawn a new pie right after destruction of last pie */
201
202         struct wmEvent *eventstate;   /* storage for event system */
203
204         struct wmSubWindow *curswin;  /* internal for wm_subwindow.c only */
205
206         struct wmGesture *tweak;      /* internal for wm_operators.c */
207
208         /* Input Method Editor data - complex character input (esp. for asian character input)
209          * Currently WIN32, runtime-only data */
210         struct wmIMEData *ime_data;
211
212         int drawmethod, drawfail;     /* internal for wm_draw.c only */
213         ListBase drawdata;            /* internal for wm_draw.c only */
214
215         ListBase queue;               /* all events (ghost level events were handled) */
216         ListBase handlers;            /* window+screen handlers, handled last */
217         ListBase modalhandlers;       /* priority handlers, handled first */
218
219         ListBase subwindows;          /* opengl stuff for sub windows, see notes in wm_subwindow.c */
220         ListBase gesture;             /* gesture stuff */
221
222         struct Stereo3dFormat *stereo3d_format; /* properties for stereoscopic displays */
223
224         /* custom drawing callbacks */
225         ListBase drawcalls;
226 } wmWindow;
227
228 #ifdef ime_data
229 #  undef ime_data
230 #endif
231
232 /* These two Lines with # tell makesdna this struct can be excluded. */
233 /* should be something like DNA_EXCLUDE 
234  * but the preprocessor first removes all comments, spaces etc */
235 #
236 #
237 typedef struct wmOperatorTypeMacro {
238         struct wmOperatorTypeMacro *next, *prev;
239
240         /* operator id */
241         char idname[64];
242         /* rna pointer to access properties, like keymap */
243         struct IDProperty *properties;  /* operator properties, assigned to ptr->data and can be written to a file */
244         struct PointerRNA *ptr;
245 } wmOperatorTypeMacro;
246
247 /* partial copy of the event, for matching by eventhandler */
248 typedef struct wmKeyMapItem {
249         struct wmKeyMapItem *next, *prev;
250
251         /* operator */
252         char idname[64];                /* used to retrieve operator type pointer */
253         IDProperty *properties;         /* operator properties, assigned to ptr->data and can be written to a file */
254
255         /* modal */
256         char propvalue_str[64];         /* runtime temporary storage for loading */
257         short propvalue;                /* if used, the item is from modal map */
258
259         /* event */
260         short type;                     /* event code itself */
261         short val;                      /* KM_ANY, KM_PRESS, KM_NOTHING etc */
262         short shift, ctrl, alt, oskey;  /* oskey is apple or windowskey, value denotes order of pressed */
263         short keymodifier;              /* rawkey modifier */
264
265         /* flag: inactive, expanded */
266         short flag;
267
268         /* runtime */
269         short maptype;                  /* keymap editor */
270         short id;                       /* unique identifier. Positive for kmi that override builtins, negative otherwise */
271         short pad;
272         struct PointerRNA *ptr;         /* rna pointer to access properties */
273 } wmKeyMapItem;
274
275 /* used instead of wmKeyMapItem for diff keymaps */
276 typedef struct wmKeyMapDiffItem {
277         struct wmKeyMapDiffItem *next, *prev;
278
279         wmKeyMapItem *remove_item;
280         wmKeyMapItem *add_item;
281 } wmKeyMapDiffItem;
282
283 /* wmKeyMapItem.flag */
284 enum {
285         KMI_INACTIVE       = (1 << 0),
286         KMI_EXPANDED       = (1 << 1),
287         KMI_USER_MODIFIED  = (1 << 2),
288         KMI_UPDATE         = (1 << 3),
289 };
290
291 /* wmKeyMapItem.maptype */
292 enum {
293         KMI_TYPE_KEYBOARD   = 0,
294         KMI_TYPE_MOUSE      = 1,
295         KMI_TYPE_TWEAK      = 2,
296         KMI_TYPE_TEXTINPUT  = 3,
297         KMI_TYPE_TIMER      = 4,
298         KMI_TYPE_NDOF       = 5,
299 };
300
301 /* stored in WM, the actively used keymaps */
302 typedef struct wmKeyMap {
303         struct wmKeyMap *next, *prev;
304
305         ListBase items;
306         ListBase diff_items;
307
308         char idname[64];  /* global editor keymaps, or for more per space/region */
309         short spaceid;    /* same IDs as in DNA_space_types.h */
310         short regionid;   /* see above */
311
312         short flag;       /* general flags */
313         short kmi_id;     /* last kmi id */
314
315         /* runtime */
316         int (*poll)(struct bContext *);  /* verify if enabled in the current context */
317         const void *modal_items;         /* for modal, EnumPropertyItem for now */
318 } wmKeyMap;
319
320 /* wmKeyMap.flag */
321 enum {
322         KEYMAP_MODAL              = (1 << 0),  /* modal map, not using operatornames */
323         KEYMAP_USER               = (1 << 1),  /* user keymap */
324         KEYMAP_EXPANDED           = (1 << 2),
325         KEYMAP_CHILDREN_EXPANDED  = (1 << 3),
326         KEYMAP_DIFF               = (1 << 4),  /* diff keymap for user preferences */
327         KEYMAP_USER_MODIFIED      = (1 << 5),  /* keymap has user modifications */
328         KEYMAP_UPDATE             = (1 << 6),
329 };
330
331 typedef struct wmKeyConfig {
332         struct wmKeyConfig *next, *prev;
333
334         char idname[64];    /* unique name */
335         char basename[64];  /* idname of configuration this is derives from, "" if none */
336
337         ListBase keymaps;
338         int actkeymap, flag;
339 } wmKeyConfig;
340
341 /* wmKeyConfig.flag */
342 enum {
343         KEYCONF_USER          = (1 << 1),  /* And what about (1 << 0)? */
344         KEYCONF_INIT_DEFAULT  = (1 << 2),
345 };
346
347 /* this one is the operator itself, stored in files for macros etc */
348 /* operator + operatortype should be able to redo entirely, but for different contextes */
349 typedef struct wmOperator {
350         struct wmOperator *next, *prev;
351
352         /* saved */
353         char idname[64];              /* used to retrieve type pointer */
354         IDProperty *properties;       /* saved, user-settable properties */
355
356         /* runtime */
357         struct wmOperatorType *type;  /* operator type definition from idname */
358         void *customdata;             /* custom storage, only while operator runs */
359         void *py_instance;            /* python stores the class instance here */
360
361         struct PointerRNA *ptr;       /* rna pointer to access properties */
362         struct ReportList *reports;   /* errors and warnings storage */
363
364         ListBase macro;               /* list of operators, can be a tree */
365         struct wmOperator *opm;       /* current running macro, not saved */
366         struct uiLayout *layout;      /* runtime for drawing */
367         short flag, pad[3];
368
369 } wmOperator;
370
371 /* operator type return flags: exec(), invoke() modal(), return values */
372 enum {
373         OPERATOR_RUNNING_MODAL  = (1 << 0),
374         OPERATOR_CANCELLED      = (1 << 1),
375         OPERATOR_FINISHED       = (1 << 2),
376         /* add this flag if the event should pass through */
377         OPERATOR_PASS_THROUGH   = (1 << 3),
378         /* in case operator got executed outside WM code... like via fileselect */
379         OPERATOR_HANDLED        = (1 << 4),
380         /* used for operators that act indirectly (eg. popup menu)
381          * note: this isn't great design (using operators to trigger UI) avoid where possible. */
382         OPERATOR_INTERFACE      = (1 << 5),
383 };
384 #define OPERATOR_FLAGS_ALL ( \
385         OPERATOR_RUNNING_MODAL | \
386         OPERATOR_CANCELLED | \
387         OPERATOR_FINISHED | \
388         OPERATOR_PASS_THROUGH | \
389         OPERATOR_HANDLED | \
390         OPERATOR_INTERFACE | \
391         0)
392
393 /* sanity checks for debug mode only */
394 #define OPERATOR_RETVAL_CHECK(ret) (void)ret, BLI_assert(ret != 0 && (ret & OPERATOR_FLAGS_ALL) == ret)
395
396 /* wmOperator flag */
397 enum {
398         /* low level flag so exec() operators can tell if they were invoked, use with care.
399          * typically this shouldn't make any difference, but it rare cases its needed (see smooth-view) */
400         OP_IS_INVOKE = (1 << 0),
401         /* So we can detect if an operators exec() call is activated from an interactive repeat. */
402         OP_IS_REPEAT = (1 << 1),
403
404         /* When the cursor is grabbed */
405         OP_IS_MODAL_GRAB_CURSOR    = (1 << 2),
406
407         /* allow modal operators to have the region under the cursor for their context
408          * (the regiontype is maintained to prevent errors) */
409         OP_IS_MODAL_CURSOR_REGION = (1 << 3),
410 };
411
412 #endif /* __DNA_WINDOWMANAGER_TYPES_H__ */