5e5c98566695c65bc992c11ac7b166b65f002f96
[blender-staging.git] / source / blender / makesdna / DNA_windowmanager_types.h
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version. 
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * The Original Code is Copyright (C) 2007 Blender Foundation.
21  * All rights reserved.
22  *
23  * 
24  * Contributor(s): Blender Foundation
25  *
26  * ***** END GPL LICENSE BLOCK *****
27  */
28 #ifndef DNA_WINDOWMANAGER_TYPES_H
29 #define DNA_WINDOWMANAGER_TYPES_H
30
31 #include "DNA_listBase.h"
32 #include "DNA_vec_types.h"
33
34 #include "DNA_ID.h"
35
36 /* defined here: */
37 struct wmWindowManager;
38 struct wmWindow;
39
40 struct wmEvent;
41 struct wmGesture;
42 struct wmOperatorType;
43 struct wmOperator;
44 struct wmKeyMap;
45 struct wmKeyConfig;
46
47 /* forwards */
48 struct bContext;
49 struct wmLocal;
50 struct bScreen;
51 struct uiBlock;
52 struct wmSubWindow;
53 struct wmTimer;
54 struct StructRNA;
55 struct PointerRNA;
56 struct ReportList;
57 struct Report;
58 struct uiLayout;
59
60 #define OP_MAX_TYPENAME 64
61 #define KMAP_MAX_NAME   64
62
63
64 typedef enum ReportType {
65         RPT_DEBUG                                       = 1<<0,
66         RPT_INFO                                        = 1<<1,
67         RPT_OPERATOR                            = 1<<2,
68         RPT_WARNING                                     = 1<<3,
69         RPT_ERROR                                       = 1<<4,
70         RPT_ERROR_INVALID_INPUT         = 1<<5,
71         RPT_ERROR_INVALID_CONTEXT       = 1<<6,
72         RPT_ERROR_OUT_OF_MEMORY         = 1<<7
73 } ReportType;
74
75 #define RPT_DEBUG_ALL           (RPT_DEBUG)
76 #define RPT_INFO_ALL            (RPT_INFO)
77 #define RPT_OPERATOR_ALL        (RPT_OPERATOR)
78 #define RPT_WARNING_ALL         (RPT_WARNING)
79 #define RPT_ERROR_ALL           (RPT_ERROR|RPT_ERROR_INVALID_INPUT|RPT_ERROR_INVALID_CONTEXT|RPT_ERROR_OUT_OF_MEMORY)
80
81 enum ReportListFlags {
82         RPT_PRINT = 1,
83         RPT_STORE = 2,
84         RPT_FREE = 4,
85 };
86 typedef struct Report {
87         struct Report *next, *prev;
88         short type; /* ReportType */
89         short flag;
90         int len; /* strlen(message), saves some time calculating the word wrap  */
91         char *typestr;
92         char *message;
93 } Report;
94 typedef struct ReportList {
95         ListBase list;
96         int printlevel; /* ReportType */
97         int storelevel; /* ReportType */
98         int flag, pad;
99 } ReportList;
100 /* reports need to be before wmWindowManager */
101
102
103 /* windowmanager is saved, tag WMAN */
104 typedef struct wmWindowManager {
105         ID id;
106         
107         struct wmWindow *windrawable, *winactive;               /* separate active from drawable */
108         ListBase windows;
109         
110         int initialized;                /* set on file read */
111         short file_saved;               /* indicator whether data was saved */
112         short pad;
113         
114         ListBase operators;             /* operator registry */
115         
116         ListBase queue;                 /* refresh/redraw wmNotifier structs */
117         
118         struct ReportList reports;      /* information and error reports */
119         
120         ListBase jobs;                  /* threaded jobs manager */
121         
122         ListBase paintcursors;  /* extra overlay cursors to draw, like circles */
123         
124         ListBase keyconfigs;                            /* known key configurations */
125         struct wmKeyConfig *defaultconf;        /* default configuration, not saved */
126         int defaultactmap, pad2;                        /* active keymap from default for editing */
127
128         ListBase timers;                                        /* active timers */
129         struct wmTimer *autosavetimer;          /* timer for auto save */
130 } wmWindowManager;
131
132 /* wmWindowManager.initialized */
133 #define WM_INIT_WINDOW          1<<0
134 #define WM_INIT_KEYMAP          1<<1
135
136 /* the savable part, rest of data is local in ghostwinlay */
137 typedef struct wmWindow {
138         struct wmWindow *next, *prev;
139         
140         void *ghostwin;         /* dont want to include ghost.h stuff */
141         
142         int winid, pad;         /* winid also in screens, is for retrieving this window after read */
143         
144         struct bScreen *screen;         /* active screen */
145         struct bScreen *newscreen;      /* temporary when switching */
146         char screenname[32];    /* MAX_ID_NAME for matching window with active screen after file read */
147         
148         short posx, posy, sizex, sizey; /* window coords */
149         short windowstate;      /* borderless, full */
150         short monitor;          /* multiscreen... no idea how to store yet */
151         short active;           /* set to 1 if an active window, for quick rejects */
152         short cursor;           /* current mouse cursor type */
153         short lastcursor;       /* for temp waitcursor */
154         short addmousemove;     /* internal: tag this for extra mousemove event, makes cursors/buttons active on UI switching */
155         
156         short last_type; /* last event information, used for click */
157         short last_val;
158
159         struct wmEvent *eventstate;     /* storage for event system */
160         
161         struct wmSubWindow *curswin;    /* internal for wm_subwindow.c only */
162
163         struct wmGesture *tweak;        /* internal for wm_operators.c */
164         
165         int drawmethod, drawfail;       /* internal for wm_draw.c only */
166         void *drawdata;                         /* internal for wm_draw.c only */
167         
168         ListBase queue;                         /* all events (ghost level events were handled) */
169         ListBase handlers;                      /* window+screen handlers, handled last */
170         ListBase modalhandlers;         /* priority handlers, handled first */
171         
172         ListBase subwindows;    /* opengl stuff for sub windows, see notes in wm_subwindow.c */
173         ListBase gesture;               /* gesture stuff */
174 } wmWindow;
175
176 /* should be somthing like DNA_EXCLUDE 
177  * but the preprocessor first removes all comments, spaces etc */
178
179 #
180 #
181 typedef struct wmOperatorTypeMacro {
182         struct wmOperatorTypeMacro *next, *prev;
183         
184         /* operator id */
185         char idname[MAX_ID_NAME];
186         /* rna pointer to access properties, like keymap */
187         struct IDProperty *properties;  /* operator properties, assigned to ptr->data and can be written to a file */
188         struct PointerRNA *ptr; 
189
190 } wmOperatorTypeMacro;
191
192 #
193 #
194 typedef struct wmOperatorType {
195         struct wmOperatorType *next, *prev;
196         
197         char *name;             /* text for ui, undo */
198         char *idname;           /* unique identifier */
199         char *description;      /* tooltips and python docs */
200         
201         /* this callback executes the operator without any interactive input,
202          * parameters may be provided through operator properties. cannot use
203          * any interface code or input device state.
204          * - see defines below for return values */
205         int (*exec)(struct bContext *, struct wmOperator *);
206
207         /* for modal temporary operators, initially invoke is called. then
208          * any further events are handled in modal. if the operation is
209          * cancelled due to some external reason, cancel is called
210          * - see defines below for return values */
211         int (*invoke)(struct bContext *, struct wmOperator *, struct wmEvent *);
212         int (*cancel)(struct bContext *, struct wmOperator *);
213         int (*modal)(struct bContext *, struct wmOperator *, struct wmEvent *);
214
215         /* verify if the operator can be executed in the current context, note
216          * that the operator might still fail to execute even if this return true */
217         int (*poll)(struct bContext *);
218         
219         /* optional panel for redo and repeat, autogenerated if not set */
220         void (*ui)(struct bContext *, struct PointerRNA *, struct uiLayout *);
221         
222         /* rna for properties */
223         struct StructRNA *srna;
224         
225         /* struct wmOperatorTypeMacro */
226         ListBase macro;
227         
228         short flag;
229         
230         /* pointer to modal keymap, do not free! */
231         struct wmKeyMap *modalkeymap;
232         
233         /* only used for operators defined with python
234          * use to store pointers to python functions */
235         void *pyop_data;
236         int (*pyop_poll)(struct bContext *, struct wmOperatorType *ot);
237
238 } wmOperatorType;
239
240
241 /* partial copy of the event, for matching by eventhandler */
242 typedef struct wmKeyMapItem {
243         struct wmKeyMapItem *next, *prev;
244         
245         /* operator */
246         char idname[64];                                /* used to retrieve operator type pointer */
247         IDProperty *properties;                 /* operator properties, assigned to ptr->data and can be written to a file */
248         
249         /* modal */
250         short propvalue;                                /* if used, the item is from modal map */
251
252         /* event */
253         short type;                                             /* event code itself */
254         short val;                                              /* KM_ANY, KM_PRESS, KM_NOTHING etc */
255         short shift, ctrl, alt, oskey;  /* oskey is apple or windowskey, value denotes order of pressed */
256         short keymodifier;                              /* rawkey modifier */
257         
258         /* flag: inactive, expanded */
259         short flag;
260
261         /* runtime */
262         short maptype, pad[2];                  /* keymap editor */
263         struct PointerRNA *ptr;                 /* rna pointer to access properties */
264 } wmKeyMapItem;
265
266 /* wmKeyMapItem.flag */
267 #define KMI_INACTIVE    1
268 #define KMI_EXPANDED    2
269
270 /* stored in WM, the actively used keymaps */
271 typedef struct wmKeyMap {
272         struct wmKeyMap *next, *prev;
273         
274         ListBase items;
275         
276         char idname[64];        /* global editor keymaps, or for more per space/region */
277         short spaceid;          /* same IDs as in DNA_space_types.h */
278         short regionid;         /* see above */
279         
280         short flag;                     /* general flags */
281         short pad;
282         
283         /* runtime */
284         int (*poll)(struct bContext *); /* verify if enabled in the current context */
285         void *modal_items;                              /* for modal, EnumPropertyItem for now */
286 } wmKeyMap;
287
288 /* wmKeyMap.flag */
289 #define KEYMAP_MODAL            1       /* modal map, not using operatornames */
290 #define KEYMAP_USER                     2       /* user created keymap */
291
292 typedef struct wmKeyConfig {
293         struct wmKeyConfig *next, *prev;
294
295         char idname[64];                /* unique name */
296         char basename[64];              /* idname of configuration this is derives from, "" if none */
297
298         ListBase keymaps;
299         int actkeymap, flag;
300 } wmKeyConfig;
301
302 /* wmKeyConfig.flag */
303 #define KEYCONF_TWOBUTTONMOUSE  (1 << 1)
304 #define KEYCONF_LMOUSESELECT    (1 << 2)
305 #define KEYCONF_NONUMPAD                (1 << 3)
306
307 /* this one is the operator itself, stored in files for macros etc */
308 /* operator + operatortype should be able to redo entirely, but for different contextes */
309 typedef struct wmOperator {
310         struct wmOperator *next, *prev;
311
312         /* saved */
313         char idname[64];                        /* used to retrieve type pointer */
314         IDProperty *properties;         /* saved, user-settable properties */
315         
316         /* runtime */
317         wmOperatorType *type;           /* operator type definition from idname */
318         void *customdata;                       /* custom storage, only while operator runs */
319         
320         struct PointerRNA *ptr;         /* rna pointer to access properties */
321         struct ReportList *reports;     /* errors and warnings storage */
322         
323         ListBase macro;                         /* list of operators, can be a tree */
324         struct wmOperator *opm;         /* current running macro, not saved */
325         short flag, pad[3];
326         
327 } wmOperator;
328
329 /* operator type exec(), invoke() modal(), return values */
330 #define OPERATOR_RUNNING_MODAL  1
331 #define OPERATOR_CANCELLED              2
332 #define OPERATOR_FINISHED               4
333 /* add this flag if the event should pass through */
334 #define OPERATOR_PASS_THROUGH   8
335
336 /* wmOperator flag */
337 #define OP_GRAB_POINTER                 1
338
339 /* ************** wmEvent ************************ */
340 /* for read-only rna access, dont save this */
341
342 /* each event should have full modifier state */
343 /* event comes from eventmanager and from keymap */
344 typedef struct wmEvent {
345         struct wmEvent *next, *prev;
346         
347         short type;                     /* event code itself (short, is also in keymap) */
348         short val;                      /* press, release, scrollvalue */
349         short x, y;                     /* mouse pointer position, screen coord */
350         short mval[2];          /* region mouse position, name convention pre 2.5 :) */
351         short prevx, prevy;     /* previous mouse pointer position */
352         short unicode;          /* future, ghost? */
353         char ascii;                     /* from ghost */
354         char pad;
355         
356         /* modifier states */
357         short shift, ctrl, alt, oskey;  /* oskey is apple or windowskey, value denotes order of pressed */
358         short keymodifier;                              /* rawkey modifier */
359         
360         short pad1;
361         
362         /* keymap item, set by handler (weak?) */
363         const char *keymap_idname;
364         
365         /* custom data */
366         short custom;           /* custom data type, stylus, 6dof, see wm_event_types.h */
367         short customdatafree;
368         int pad2;
369         void *customdata;       /* ascii, unicode, mouse coords, angles, vectors, dragdrop info */
370         
371 } wmEvent;
372
373 typedef enum wmRadialControlMode {
374         WM_RADIALCONTROL_SIZE,
375         WM_RADIALCONTROL_STRENGTH,
376         WM_RADIALCONTROL_ANGLE
377 } wmRadialControlMode;
378
379 #endif /* DNA_WINDOWMANAGER_TYPES_H */
380