utility function to find the biggest area: BKE_screen_find_big_area(...), was being...
[blender.git] / source / blender / blenkernel / BKE_screen.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) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): none yet.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27 #ifndef BKE_SCREEN_H
28 #define BKE_SCREEN_H
29
30 /** \file BKE_screen.h
31  *  \ingroup bke
32  *  \since March 2001
33  *  \author nzc
34  */
35
36 struct ARegion;
37 struct Header;
38 struct ListBase;
39 struct Menu;
40 struct Panel;
41 struct Scene;
42 struct ScrArea;
43 struct SpaceType;
44 struct View3D;
45 struct bContext;
46 struct bContextDataResult;
47 struct bScreen;
48 struct uiLayout;
49 struct uiMenuItem;
50 struct wmKeyConfig;
51 struct wmNotifier;
52 struct wmWindow;
53 struct wmWindowManager;
54
55 #include "RNA_types.h"
56
57 /* spacetype has everything stored to get an editor working, it gets initialized via 
58    ED_spacetypes_init() in editors/area/spacetypes.c   */
59 /* an editor in Blender is a combined ScrArea + SpaceType + SpaceData */
60
61 #define BKE_ST_MAXNAME  64
62
63 typedef struct SpaceType {
64         struct SpaceType *next, *prev;
65         
66         char                    name[BKE_ST_MAXNAME];           /* for menus */
67         int                             spaceid;                                        /* unique space identifier */
68         int                             iconid;                                         /* icon lookup for menus */
69         
70         /* initial allocation, after this WM will call init() too */
71         struct SpaceLink        *(*new)(const struct bContext *C);
72         /* not free spacelink itself */
73         void            (*free)(struct SpaceLink *);
74         
75         /* init is to cope with file load, screen (size) changes, check handlers */
76         void            (*init)(struct wmWindowManager *, struct ScrArea *);
77         /* Listeners can react to bContext changes */
78         void            (*listener)(struct ScrArea *, struct wmNotifier *);
79         
80         /* refresh context, called after filereads, ED_area_tag_refresh() */
81         void            (*refresh)(const struct bContext *, struct ScrArea *);
82         
83         /* after a spacedata copy, an init should result in exact same situation */
84         struct SpaceLink        *(*duplicate)(struct SpaceLink *);
85
86         /* register operator types on startup */
87         void            (*operatortypes)(void);
88         /* add default items to WM keymap */
89         void            (*keymap)(struct wmKeyConfig *);
90         /* on startup, define dropboxes for spacetype+regions */
91         void            (*dropboxes)(void);
92
93         /* return context data */
94         int                     (*context)(const struct bContext *, const char*, struct bContextDataResult *);
95
96         /* region type definitions */
97         ListBase        regiontypes;
98         
99         /* tool shelf definitions */
100         ListBase toolshelf;
101                 
102         /* read and write... */
103         
104         /* default keymaps to add */
105         int                     keymapflag;
106         
107 } SpaceType;
108
109 /* region types are also defined using spacetypes_init, via a callback */
110
111 typedef struct ARegionType {
112         struct ARegionType *next, *prev;
113         
114         int                     regionid;       /* unique identifier within this space, defines RGN_TYPE_xxxx */
115         
116         /* add handlers, stuff you only do once or on area/region type/size changes */
117         void            (*init)(struct wmWindowManager *, struct ARegion *);
118         /* draw entirely, view changes should be handled here */
119         void            (*draw)(const struct bContext *, struct ARegion *);     
120         /* contextual changes should be handled here */
121         void            (*listener)(struct ARegion *, struct wmNotifier *);
122         
123         void            (*free)(struct ARegion *);
124
125         /* split region, copy data optionally */
126         void            *(*duplicate)(void *);
127
128         
129         /* register operator types on startup */
130         void            (*operatortypes)(void);
131         /* add own items to keymap */
132         void            (*keymap)(struct wmKeyConfig *);
133         /* allows default cursor per region */
134         void            (*cursor)(struct wmWindow *, struct ScrArea *, struct ARegion *ar);
135
136         /* return context data */
137         int                     (*context)(const struct bContext *, const char *, struct bContextDataResult *);
138
139         /* custom drawing callbacks */
140         ListBase        drawcalls;
141
142         /* panels type definitions */
143         ListBase paneltypes;
144
145         /* header type definitions */
146         ListBase headertypes;
147         
148         /* hardcoded constraints, smaller than these values region is not visible */
149         int                     minsizex, minsizey;
150         /* when new region opens (region prefsizex/y are zero then */
151         int                     prefsizex, prefsizey;
152         /* default keymaps to add */
153         int                     keymapflag;
154         /* return without drawing. lock is set by region definition, and copied to do_lock by render. can become flag */
155         short           do_lock, lock;
156 } ARegionType;
157
158 /* panel types */
159
160 typedef struct PanelType {
161         struct PanelType *next, *prev;
162         
163         char            idname[BKE_ST_MAXNAME];         /* unique name */
164         char            label[BKE_ST_MAXNAME];          /* for panel header */
165         char            context[BKE_ST_MAXNAME];        /* for buttons window */
166         int                     space_type;
167         int                     region_type;
168
169         int             flag;
170
171         /* verify if the panel should draw or not */
172         int                     (*poll)(const struct bContext *, struct PanelType *);
173         /* draw header (optional) */
174         void            (*draw_header)(const struct bContext *, struct Panel *);        
175         /* draw entirely, view changes should be handled here */
176         void            (*draw)(const struct bContext *, struct Panel *);       
177
178         /* RNA integration */
179         ExtensionRNA ext;
180 } PanelType;
181
182 /* header types */
183
184 typedef struct HeaderType {
185         struct HeaderType *next, *prev;
186
187         char            idname[BKE_ST_MAXNAME]; /* unique name */
188         int             space_type;
189
190         /* draw entirely, view changes should be handled here */
191         void            (*draw)(const struct bContext *, struct Header *);      
192
193         /* RNA integration */
194         ExtensionRNA ext;
195 } HeaderType;
196
197 typedef struct Header {
198         struct HeaderType *type;        /* runtime */
199         struct uiLayout *layout;        /* runtime for drawing */
200 } Header;
201
202
203 /* menu types */
204
205 typedef struct MenuType {
206         struct MenuType *next, *prev;
207
208         char            idname[BKE_ST_MAXNAME]; /* unique name */
209         char            label[BKE_ST_MAXNAME];  /* for button text */
210
211         /* verify if the menu should draw or not */
212         int                     (*poll)(const struct bContext *, struct MenuType *);
213         /* draw entirely, view changes should be handled here */
214         void            (*draw)(const struct bContext *, struct Menu *);        
215
216         /* RNA integration */
217         ExtensionRNA ext;
218 } MenuType;
219
220 typedef struct Menu {
221         struct MenuType *type;          /* runtime */
222         struct uiLayout *layout;        /* runtime for drawing */
223 } Menu;
224
225 /* spacetypes */
226 struct SpaceType *BKE_spacetype_from_id(int spaceid);
227 struct ARegionType *BKE_regiontype_from_id(struct SpaceType *st, int regionid);
228 const struct ListBase *BKE_spacetypes_list(void);
229 void BKE_spacetype_register(struct SpaceType *st);
230 void BKE_spacetypes_free(void); /* only for quitting blender */
231
232 /* spacedata */
233 void BKE_spacedata_freelist(ListBase *lb);
234 void BKE_spacedata_copylist(ListBase *lb1, ListBase *lb2);
235 void BKE_spacedata_draw_locks(int set);
236
237 /* area/regions */
238 struct ARegion *BKE_area_region_copy(struct SpaceType *st, struct ARegion *ar);
239 void    BKE_area_region_free(struct SpaceType *st, struct ARegion *ar);
240 void    BKE_screen_area_free(struct ScrArea *sa);
241
242 struct ARegion *BKE_area_find_region_type(struct ScrArea *sa, int type);
243 struct ScrArea *BKE_screen_find_big_area(struct bScreen *sc, const int spacetype, const short min);
244
245 void BKE_screen_view3d_sync(struct View3D *v3d, struct Scene *scene);
246 void BKE_screen_view3d_scene_sync(struct bScreen *sc);
247 void BKE_screen_view3d_main_sync(ListBase *screen_lb, struct Scene *scene);
248
249 /* zoom factor conversion */
250 float BKE_screen_view3d_zoom_to_fac(float camzoom);
251 float BKE_screen_view3d_zoom_from_fac(float zoomfac);
252
253 /* screen */
254 void free_screen(struct bScreen *sc); 
255 unsigned int BKE_screen_visible_layers(struct bScreen *screen, struct Scene *scene);
256
257 #endif
258