Merge branch 'master' into blender2.8
[blender.git] / source / blender / makesrna / intern / rna_screen.c
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  * Contributor(s): Blender Foundation (2008), Nathan Letwory
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22
23 /** \file blender/makesrna/intern/rna_screen.c
24  *  \ingroup RNA
25  */
26
27
28 #include <stdlib.h>
29 #include <stddef.h>
30
31 #include "RNA_define.h"
32 #include "RNA_enum_types.h"
33
34 #include "rna_internal.h"
35
36 #include "DNA_screen_types.h"
37 #include "DNA_scene_types.h"
38 #include "DNA_workspace_types.h"
39
40 const EnumPropertyItem rna_enum_region_type_items[] = {
41         {RGN_TYPE_WINDOW, "WINDOW", 0, "Window", ""},
42         {RGN_TYPE_HEADER, "HEADER", 0, "Header", ""},
43         {RGN_TYPE_CHANNELS, "CHANNELS", 0, "Channels", ""},
44         {RGN_TYPE_TEMPORARY, "TEMPORARY", 0, "Temporary", ""},
45         {RGN_TYPE_UI, "UI", 0, "UI", ""},
46         {RGN_TYPE_TOOLS, "TOOLS", 0, "Tools", ""},
47         {RGN_TYPE_TOOL_PROPS, "TOOL_PROPS", 0, "Tool Properties", ""},
48         {RGN_TYPE_PREVIEW, "PREVIEW", 0, "Preview", ""},
49         {0, NULL, 0, NULL, NULL}
50 };
51
52 #include "ED_screen.h"
53
54 #include "WM_api.h"
55 #include "WM_types.h"
56
57 #ifdef RNA_RUNTIME
58
59 #include "BKE_global.h"
60 #include "BKE_workspace.h"
61 #include "BKE_screen.h"
62
63 #include "DEG_depsgraph.h"
64
65 #include "UI_view2d.h"
66
67 #ifdef WITH_PYTHON
68 #  include "BPY_extern.h"
69 #endif
70
71 static void rna_Screen_bar_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
72 {
73         bScreen *screen = (bScreen *)ptr->data;
74         screen->do_draw = true;
75         screen->do_refresh = true;
76 }
77
78 static void rna_Screen_redraw_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
79 {
80         bScreen *screen = (bScreen *)ptr->data;
81
82         /* the settings for this are currently only available from a menu in the TimeLine,
83          * hence refresh=SPACE_ACTION, as timeline is now in there
84          */
85         ED_screen_animation_timer_update(screen, screen->redraws_flag, SPACE_ACTION);
86 }
87
88 static bool rna_Screen_is_animation_playing_get(PointerRNA *UNUSED(ptr))
89 {
90         /* can be NULL on file load, T42619 */
91         wmWindowManager *wm = G_MAIN->wm.first;
92         return wm ? (ED_screen_animation_playing(wm) != NULL) : 0;
93 }
94
95 static int rna_region_alignment_get(PointerRNA *ptr)
96 {
97         ARegion *region = ptr->data;
98         return (region->alignment & ~RGN_SPLIT_PREV);
99 }
100
101 static void rna_Screen_layout_name_get(PointerRNA *ptr, char *value)
102 {
103         const bScreen *screen = ptr->data;
104         const WorkSpaceLayout *layout = BKE_workspace_layout_find_global(G_MAIN, screen, NULL);
105
106         if (layout) {
107                 const char *name = BKE_workspace_layout_name_get(layout);
108                 strcpy(value, name);
109         }
110         else {
111                 value[0] = '\0';
112         }
113 }
114
115 static int rna_Screen_layout_name_length(PointerRNA *ptr)
116 {
117         const bScreen *screen = ptr->data;
118         const WorkSpaceLayout *layout = BKE_workspace_layout_find_global(G_MAIN, screen, NULL);
119
120         if (layout) {
121                 const char *name = BKE_workspace_layout_name_get(layout);
122                 return strlen(name);
123         }
124
125         return 0;
126 }
127
128 static void rna_Screen_layout_name_set(PointerRNA *ptr, const char *value)
129 {
130         bScreen *screen = ptr->data;
131         WorkSpace *workspace;
132         WorkSpaceLayout *layout = BKE_workspace_layout_find_global(G_MAIN, screen, &workspace);
133
134         if (layout) {
135                 BKE_workspace_layout_name_set(workspace, layout, value);
136         }
137 }
138
139 static bool rna_Screen_fullscreen_get(PointerRNA *ptr)
140 {
141         bScreen *sc = (bScreen *)ptr->data;
142         return (sc->state == SCREENMAXIMIZED);
143 }
144
145 /* UI compatible list: should not be needed, but for now we need to keep EMPTY
146  * at least in the static version of this enum for python scripts. */
147 static const EnumPropertyItem *rna_Area_type_itemf(bContext *UNUSED(C), PointerRNA *UNUSED(ptr),
148                                              PropertyRNA *UNUSED(prop), bool *r_free)
149 {
150         EnumPropertyItem *item = NULL;
151         int totitem = 0;
152
153         /* +1 to skip SPACE_EMPTY */
154         for (const EnumPropertyItem *item_from = rna_enum_space_type_items + 1; item_from->identifier; item_from++) {
155                 if (ELEM(item_from->value, SPACE_TOPBAR, SPACE_STATUSBAR, SPACE_USERPREF)) {
156                         continue;
157                 }
158                 RNA_enum_item_add(&item, &totitem, item_from);
159         }
160         RNA_enum_item_end(&item, &totitem);
161         *r_free = true;
162
163         return item;
164 }
165
166 static int rna_Area_type_get(PointerRNA *ptr)
167 {
168         ScrArea *sa = (ScrArea *)ptr->data;
169         /* Usually 'spacetype' is used. It lags behind a bit while switching area
170          * type though, then we use 'butspacetype' instead (T41435). */
171         return (sa->butspacetype == SPACE_EMPTY) ? sa->spacetype : sa->butspacetype;
172 }
173
174 static void rna_Area_type_set(PointerRNA *ptr, int value)
175 {
176         if (ELEM(value, SPACE_TOPBAR, SPACE_STATUSBAR, SPACE_USERPREF)) {
177                 /* Special case: An area can not be set to show the top-bar editor (or
178                  * other global areas). However it should still be possible to identify
179                  * its type from Python. */
180                 return;
181         }
182
183         ScrArea *sa = (ScrArea *)ptr->data;
184         sa->butspacetype = value;
185 }
186
187 static void rna_Area_type_update(bContext *C, PointerRNA *ptr)
188 {
189         wmWindowManager *wm = CTX_wm_manager(C);
190         wmWindow *win;
191         bScreen *sc = (bScreen *)ptr->id.data;
192         ScrArea *sa = (ScrArea *)ptr->data;
193
194         /* XXX this call still use context, so we trick it to work in the right context */
195         for (win = wm->windows.first; win; win = win->next) {
196                 if (sc == WM_window_get_active_screen(win)) {
197                         wmWindow *prevwin = CTX_wm_window(C);
198                         ScrArea *prevsa = CTX_wm_area(C);
199                         ARegion *prevar = CTX_wm_region(C);
200
201                         CTX_wm_window_set(C, win);
202                         CTX_wm_area_set(C, sa);
203                         CTX_wm_region_set(C, NULL);
204
205                         ED_area_newspace(C, sa, sa->butspacetype, true);
206                         ED_area_tag_redraw(sa);
207
208                         /* Unset so that rna_Area_type_get uses spacetype instead. */
209                         sa->butspacetype = SPACE_EMPTY;
210
211                         /* It is possible that new layers becomes visible. */
212                         if (sa->spacetype == SPACE_VIEW3D) {
213                                 DEG_on_visible_update(CTX_data_main(C), false);
214                         }
215
216                         CTX_wm_window_set(C, prevwin);
217                         CTX_wm_area_set(C, prevsa);
218                         CTX_wm_region_set(C, prevar);
219                         break;
220                 }
221         }
222 }
223
224
225 static const EnumPropertyItem *rna_Area_ui_type_itemf(
226         bContext *C, PointerRNA *UNUSED(ptr),
227         PropertyRNA *UNUSED(prop), bool *r_free)
228 {
229         EnumPropertyItem *item = NULL;
230         int totitem = 0;
231
232         /* +1 to skip SPACE_EMPTY */
233         for (const EnumPropertyItem *item_from = rna_enum_space_type_items + 1; item_from->identifier; item_from++) {
234                 if (ELEM(item_from->value, SPACE_TOPBAR, SPACE_STATUSBAR, SPACE_USERPREF)) {
235                         continue;
236                 }
237
238                 SpaceType *st = item_from->identifier[0] ? BKE_spacetype_from_id(item_from->value) : NULL;
239                 int totitem_prev = totitem;
240                 if (st && st->space_subtype_item_extend != NULL) {
241                         st->space_subtype_item_extend(C, &item, &totitem);
242                         while (totitem_prev < totitem) {
243                                 item[totitem_prev++].value |= item_from->value << 16;
244                         }
245                 }
246                 else {
247                         RNA_enum_item_add(&item, &totitem, item_from);
248                         item[totitem_prev++].value = item_from->value << 16;
249                 }
250         }
251         RNA_enum_item_end(&item, &totitem);
252         *r_free = true;
253
254         return item;
255 }
256
257 static int rna_Area_ui_type_get(PointerRNA *ptr)
258 {
259         int value = rna_Area_type_get(ptr) << 16;
260         ScrArea *sa = ptr->data;
261         if (sa->type->space_subtype_item_extend != NULL) {
262                 value |= sa->type->space_subtype_get(sa);
263         }
264         return value;
265 }
266
267 static void rna_Area_ui_type_set(PointerRNA *ptr, int value)
268 {
269         ScrArea *sa = ptr->data;
270         const int space_type = value >> 16;
271         SpaceType *st = BKE_spacetype_from_id(space_type);
272
273         rna_Area_type_set(ptr, space_type);
274
275         if (st && st->space_subtype_item_extend != NULL) {
276                 sa->butspacetype_subtype = value & 0xffff;
277         }
278 }
279
280 static void rna_Area_ui_type_update(bContext *C, PointerRNA *ptr)
281 {
282         ScrArea *sa = ptr->data;
283         SpaceType *st = BKE_spacetype_from_id(sa->butspacetype);
284
285         rna_Area_type_update(C, ptr);
286
287         if ((sa->type == st) && (st->space_subtype_item_extend != NULL)) {
288                 st->space_subtype_set(sa, sa->butspacetype_subtype);
289         }
290         sa->butspacetype_subtype = 0;
291 }
292
293 static void rna_View2D_region_to_view(struct View2D *v2d, int x, int y, float result[2])
294 {
295         UI_view2d_region_to_view(v2d, x, y, &result[0], &result[1]);
296 }
297
298 static void rna_View2D_view_to_region(struct View2D *v2d, float x, float y, bool clip, int result[2])
299 {
300         if (clip)
301                 UI_view2d_view_to_region_clip(v2d, x, y, &result[0], &result[1]);
302         else
303                 UI_view2d_view_to_region(v2d, x, y, &result[0], &result[1]);
304 }
305
306 #else
307
308 /* Area.spaces */
309 static void rna_def_area_spaces(BlenderRNA *brna, PropertyRNA *cprop)
310 {
311         StructRNA *srna;
312         PropertyRNA *prop;
313
314         RNA_def_property_srna(cprop, "AreaSpaces");
315         srna = RNA_def_struct(brna, "AreaSpaces", NULL);
316         RNA_def_struct_sdna(srna, "ScrArea");
317         RNA_def_struct_ui_text(srna, "Area Spaces", "Collection of spaces");
318
319         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
320         RNA_def_property_pointer_sdna(prop, NULL, "spacedata.first");
321         RNA_def_property_struct_type(prop, "Space");
322         RNA_def_property_ui_text(prop, "Active Space", "Space currently being displayed in this area");
323 }
324
325 static void rna_def_area_api(StructRNA *srna)
326 {
327         FunctionRNA *func;
328
329         RNA_def_function(srna, "tag_redraw", "ED_area_tag_redraw");
330
331         func = RNA_def_function(srna, "header_text_set", "ED_area_status_text");
332         RNA_def_function_ui_description(func, "Set the header status text");
333         RNA_def_string(func, "text", NULL, 0, "Text", "New string for the header, no argument clears the text");
334 }
335
336 static void rna_def_area(BlenderRNA *brna)
337 {
338         StructRNA *srna;
339         PropertyRNA *prop;
340
341         srna = RNA_def_struct(brna, "Area", NULL);
342         RNA_def_struct_ui_text(srna, "Area", "Area in a subdivided screen, containing an editor");
343         RNA_def_struct_sdna(srna, "ScrArea");
344
345         prop = RNA_def_property(srna, "spaces", PROP_COLLECTION, PROP_NONE);
346         RNA_def_property_collection_sdna(prop, NULL, "spacedata", NULL);
347         RNA_def_property_struct_type(prop, "Space");
348         RNA_def_property_ui_text(prop, "Spaces",
349                                  "Spaces contained in this area, the first being the active space "
350                                  "(NOTE: Useful for example to restore a previously used 3D view space "
351                                  "in a certain area to get the old view orientation)");
352         rna_def_area_spaces(brna, prop);
353
354         prop = RNA_def_property(srna, "regions", PROP_COLLECTION, PROP_NONE);
355         RNA_def_property_collection_sdna(prop, NULL, "regionbase", NULL);
356         RNA_def_property_struct_type(prop, "Region");
357         RNA_def_property_ui_text(prop, "Regions", "Regions this area is subdivided in");
358
359         prop = RNA_def_property(srna, "show_menus", PROP_BOOLEAN, PROP_NONE);
360         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", HEADER_NO_PULLDOWN);
361         RNA_def_property_ui_text(prop, "Show Menus", "Show menus in the header");
362
363         prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
364         RNA_def_property_enum_sdna(prop, NULL, "spacetype");
365         RNA_def_property_enum_items(prop, rna_enum_space_type_items);
366         RNA_def_property_enum_default(prop, SPACE_VIEW3D);
367         RNA_def_property_enum_funcs(prop, "rna_Area_type_get", "rna_Area_type_set", "rna_Area_type_itemf");
368         RNA_def_property_ui_text(prop, "Editor Type", "Current editor type for this area");
369         RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
370         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
371         RNA_def_property_update(prop, 0, "rna_Area_type_update");
372
373         prop = RNA_def_property(srna, "ui_type", PROP_ENUM, PROP_NONE);
374         RNA_def_property_enum_items(prop, DummyRNA_DEFAULT_items);  /* infact dummy */
375         RNA_def_property_enum_default(prop, 0);
376         RNA_def_property_enum_funcs(prop, "rna_Area_ui_type_get", "rna_Area_ui_type_set", "rna_Area_ui_type_itemf");
377         RNA_def_property_ui_text(prop, "Editor Type", "Current editor type for this area");
378         RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
379         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
380         RNA_def_property_update(prop, 0, "rna_Area_ui_type_update");
381
382         prop = RNA_def_property(srna, "x", PROP_INT, PROP_NONE);
383         RNA_def_property_int_sdna(prop, NULL, "totrct.xmin");
384         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
385         RNA_def_property_ui_text(prop, "X Position", "The window relative vertical location of the area");
386
387         prop = RNA_def_property(srna, "y", PROP_INT, PROP_NONE);
388         RNA_def_property_int_sdna(prop, NULL, "totrct.ymin");
389         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
390         RNA_def_property_ui_text(prop, "Y Position", "The window relative horizontal location of the area");
391
392         prop = RNA_def_property(srna, "width", PROP_INT, PROP_UNSIGNED);
393         RNA_def_property_int_sdna(prop, NULL, "winx");
394         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
395         RNA_def_property_ui_text(prop, "Width", "Area width");
396
397         prop = RNA_def_property(srna, "height", PROP_INT, PROP_UNSIGNED);
398         RNA_def_property_int_sdna(prop, NULL, "winy");
399         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
400         RNA_def_property_ui_text(prop, "Height", "Area height");
401
402         rna_def_area_api(srna);
403 }
404
405 static void rna_def_view2d_api(StructRNA *srna)
406 {
407         FunctionRNA *func;
408         PropertyRNA *parm;
409
410         static const float view_default[2] = {0.0f, 0.0f};
411         static const int region_default[2] = {0.0f, 0.0f};
412
413         func = RNA_def_function(srna, "region_to_view", "rna_View2D_region_to_view");
414         RNA_def_function_ui_description(func, "Transform region coordinates to 2D view");
415         parm = RNA_def_int(func, "x", 0, INT_MIN, INT_MAX, "x", "Region x coordinate", -10000, 10000);
416         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
417         parm = RNA_def_int(func, "y", 0, INT_MIN, INT_MAX, "y", "Region y coordinate", -10000, 10000);
418         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
419         parm = RNA_def_float_array(func, "result", 2, view_default, -FLT_MAX, FLT_MAX, "Result", "View coordinates", -10000.0f, 10000.0f);
420         RNA_def_parameter_flags(parm, PROP_THICK_WRAP, 0);
421         RNA_def_function_output(func, parm);
422
423         func = RNA_def_function(srna, "view_to_region", "rna_View2D_view_to_region");
424         RNA_def_function_ui_description(func, "Transform 2D view coordinates to region");
425         parm = RNA_def_float(func, "x", 0.0f, -FLT_MAX, FLT_MAX, "x", "2D View x coordinate", -10000.0f, 10000.0f);
426         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
427         parm = RNA_def_float(func, "y", 0.0f, -FLT_MAX, FLT_MAX, "y", "2D View y coordinate", -10000.0f, 10000.0f);
428         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
429         RNA_def_boolean(func, "clip", 1, "Clip", "Clip coordinates to the visible region");
430         parm = RNA_def_int_array(func, "result", 2, region_default, INT_MIN, INT_MAX, "Result", "Region coordinates", -10000, 10000);
431         RNA_def_parameter_flags(parm, PROP_THICK_WRAP, 0);
432         RNA_def_function_output(func, parm);
433 }
434
435 static void rna_def_view2d(BlenderRNA *brna)
436 {
437         StructRNA *srna;
438         /* PropertyRNA *prop; */
439
440         srna = RNA_def_struct(brna, "View2D", NULL);
441         RNA_def_struct_ui_text(srna, "View2D", "Scroll and zoom for a 2D region");
442         RNA_def_struct_sdna(srna, "View2D");
443
444         /* TODO more View2D properties could be exposed here (read-only) */
445
446         rna_def_view2d_api(srna);
447 }
448
449 static void rna_def_region(BlenderRNA *brna)
450 {
451         StructRNA *srna;
452         PropertyRNA *prop;
453
454         static const EnumPropertyItem alignment_types[] = {
455                 {RGN_ALIGN_NONE, "NONE", 0, "None", "Don't use any fixed alignment, fill available space"},
456                 {RGN_ALIGN_TOP, "TOP", 0, "Top", ""},
457                 {RGN_ALIGN_BOTTOM, "BOTTOM", 0, "Bottom", ""},
458                 {RGN_ALIGN_LEFT, "LEFT", 0, "Left", ""},
459                 {RGN_ALIGN_RIGHT, "RIGHT", 0, "Right", ""},
460                 {RGN_ALIGN_HSPLIT, "HORIZONTAL_SPLIT", 0, "Horizontal Split", ""},
461                 {RGN_ALIGN_VSPLIT, "VERTICAL_SPLIT", 0, "Vertical Split", ""},
462                 {RGN_ALIGN_FLOAT, "FLOAT", 0, "Float", "Region floats on screen, doesn't use any fixed alignment"},
463                 {RGN_ALIGN_QSPLIT, "QUAD_SPLIT", 0, "Quad Split", "Region is split horizontally and vertically"},
464                 {0, NULL, 0, NULL, NULL}
465         };
466
467         srna = RNA_def_struct(brna, "Region", NULL);
468         RNA_def_struct_ui_text(srna, "Region", "Region in a subdivided screen area");
469         RNA_def_struct_sdna(srna, "ARegion");
470
471         prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
472         RNA_def_property_enum_sdna(prop, NULL, "regiontype");
473         RNA_def_property_enum_items(prop, rna_enum_region_type_items);
474         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
475         RNA_def_property_ui_text(prop, "Region Type", "Type of this region");
476
477         prop = RNA_def_property(srna, "x", PROP_INT, PROP_NONE);
478         RNA_def_property_int_sdna(prop, NULL, "winrct.xmin");
479         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
480         RNA_def_property_ui_text(prop, "X Position", "The window relative vertical location of the region");
481
482         prop = RNA_def_property(srna, "y", PROP_INT, PROP_NONE);
483         RNA_def_property_int_sdna(prop, NULL, "winrct.ymin");
484         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
485         RNA_def_property_ui_text(prop, "Y Position", "The window relative horizontal location of the region");
486
487         prop = RNA_def_property(srna, "width", PROP_INT, PROP_UNSIGNED);
488         RNA_def_property_int_sdna(prop, NULL, "winx");
489         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
490         RNA_def_property_ui_text(prop, "Width", "Region width");
491
492         prop = RNA_def_property(srna, "height", PROP_INT, PROP_UNSIGNED);
493         RNA_def_property_int_sdna(prop, NULL, "winy");
494         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
495         RNA_def_property_ui_text(prop, "Height", "Region height");
496
497         prop = RNA_def_property(srna, "view2d", PROP_POINTER, PROP_NONE);
498         RNA_def_property_pointer_sdna(prop, NULL, "v2d");
499         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
500         RNA_def_property_flag(prop, PROP_NEVER_NULL);
501         RNA_def_property_ui_text(prop, "View2D", "2D view of the region");
502
503         prop = RNA_def_property(srna, "alignment", PROP_ENUM, PROP_NONE);
504         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
505         RNA_def_property_enum_items(prop, alignment_types);
506         RNA_def_property_enum_funcs(prop, "rna_region_alignment_get", NULL, NULL);
507         RNA_def_property_ui_text(prop, "Alignment", "Alignment of the region within the area");
508
509         RNA_def_function(srna, "tag_redraw", "ED_region_tag_redraw");
510 }
511
512 static void rna_def_screen(BlenderRNA *brna)
513 {
514         StructRNA *srna;
515         PropertyRNA *prop;
516
517         srna = RNA_def_struct(brna, "Screen", "ID");
518         RNA_def_struct_sdna(srna, "Screen"); /* it is actually bScreen but for 2.5 the dna is patched! */
519         RNA_def_struct_ui_text(srna, "Screen", "Screen data-block, defining the layout of areas in a window");
520         RNA_def_struct_ui_icon(srna, ICON_SPLITSCREEN);
521
522         prop = RNA_def_property(srna, "layout_name", PROP_STRING, PROP_NONE);
523         RNA_def_property_string_funcs(prop, "rna_Screen_layout_name_get", "rna_Screen_layout_name_length",
524                                       "rna_Screen_layout_name_set");
525         RNA_def_property_ui_text(prop, "Layout Name", "The name of the layout that refers to the screen");
526         RNA_def_struct_name_property(srna, prop);
527
528         /* collections */
529         prop = RNA_def_property(srna, "areas", PROP_COLLECTION, PROP_NONE);
530         RNA_def_property_collection_sdna(prop, NULL, "areabase", NULL);
531         RNA_def_property_struct_type(prop, "Area");
532         RNA_def_property_ui_text(prop, "Areas", "Areas the screen is subdivided into");
533
534         /* readonly status indicators */
535         prop = RNA_def_property(srna, "is_animation_playing", PROP_BOOLEAN, PROP_NONE);
536         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
537         RNA_def_property_boolean_funcs(prop, "rna_Screen_is_animation_playing_get", NULL);
538         RNA_def_property_ui_text(prop, "Animation Playing", "Animation playback is active");
539
540         prop = RNA_def_property(srna, "show_fullscreen", PROP_BOOLEAN, PROP_NONE);
541         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
542         RNA_def_property_boolean_funcs(prop, "rna_Screen_fullscreen_get", NULL);
543         RNA_def_property_ui_text(prop, "Maximize", "An area is maximized, filling this screen");
544
545         prop = RNA_def_property(srna, "show_topbar", PROP_BOOLEAN, PROP_NONE);
546         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", SCREEN_COLLAPSE_TOPBAR);
547         RNA_def_property_ui_text(prop, "Show Top Bar", "Show top bar with tool settings");
548         RNA_def_property_update(prop, 0, "rna_Screen_bar_update");
549
550         prop = RNA_def_property(srna, "show_statusbar", PROP_BOOLEAN, PROP_NONE);
551         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", SCREEN_COLLAPSE_STATUSBAR);
552         RNA_def_property_ui_text(prop, "Show Status Bar", "Show status bar");
553         RNA_def_property_update(prop, 0, "rna_Screen_bar_update");
554
555         /* Define Anim Playback Areas */
556         prop = RNA_def_property(srna, "use_play_top_left_3d_editor", PROP_BOOLEAN, PROP_NONE);
557         RNA_def_property_boolean_sdna(prop, NULL, "redraws_flag", TIME_REGION);
558         RNA_def_property_ui_text(prop, "Top-Left 3D Editor", "");
559         RNA_def_property_update(prop, NC_SPACE | ND_SPACE_TIME, "rna_Screen_redraw_update");
560
561         prop = RNA_def_property(srna, "use_play_3d_editors", PROP_BOOLEAN, PROP_NONE);
562         RNA_def_property_boolean_sdna(prop, NULL, "redraws_flag", TIME_ALL_3D_WIN);
563         RNA_def_property_ui_text(prop, "All 3D View Editors", "");
564         RNA_def_property_update(prop, NC_SPACE | ND_SPACE_TIME, "rna_Screen_redraw_update");
565
566         prop = RNA_def_property(srna, "use_follow", PROP_BOOLEAN, PROP_NONE);
567         RNA_def_property_boolean_sdna(prop, NULL, "redraws_flag", TIME_FOLLOW);
568         RNA_def_property_ui_text(prop, "Follow", "Follow current frame in editors");
569         RNA_def_property_update(prop, NC_SPACE | ND_SPACE_TIME, "rna_Screen_redraw_update");
570
571         prop = RNA_def_property(srna, "use_play_animation_editors", PROP_BOOLEAN, PROP_NONE);
572         RNA_def_property_boolean_sdna(prop, NULL, "redraws_flag", TIME_ALL_ANIM_WIN);
573         RNA_def_property_ui_text(prop, "Animation Editors", "");
574         RNA_def_property_update(prop, NC_SPACE | ND_SPACE_TIME, "rna_Screen_redraw_update");
575
576         prop = RNA_def_property(srna, "use_play_properties_editors", PROP_BOOLEAN, PROP_NONE);
577         RNA_def_property_boolean_sdna(prop, NULL, "redraws_flag", TIME_ALL_BUTS_WIN);
578         RNA_def_property_ui_text(prop, "Property Editors", "");
579         RNA_def_property_update(prop, NC_SPACE | ND_SPACE_TIME, "rna_Screen_redraw_update");
580
581         prop = RNA_def_property(srna, "use_play_image_editors", PROP_BOOLEAN, PROP_NONE);
582         RNA_def_property_boolean_sdna(prop, NULL, "redraws_flag", TIME_ALL_IMAGE_WIN);
583         RNA_def_property_ui_text(prop, "Image Editors", "");
584         RNA_def_property_update(prop, NC_SPACE | ND_SPACE_TIME, "rna_Screen_redraw_update");
585
586         prop = RNA_def_property(srna, "use_play_sequence_editors", PROP_BOOLEAN, PROP_NONE);
587         RNA_def_property_boolean_sdna(prop, NULL, "redraws_flag", TIME_SEQ);
588         RNA_def_property_ui_text(prop, "Sequencer Editors", "");
589         RNA_def_property_update(prop, NC_SPACE | ND_SPACE_TIME, "rna_Screen_redraw_update");
590
591         prop = RNA_def_property(srna, "use_play_node_editors", PROP_BOOLEAN, PROP_NONE);
592         RNA_def_property_boolean_sdna(prop, NULL, "redraws_flag", TIME_NODES);
593         RNA_def_property_ui_text(prop, "Node Editors", "");
594         RNA_def_property_update(prop, NC_SPACE | ND_SPACE_TIME, "rna_Screen_redraw_update");
595
596         prop = RNA_def_property(srna, "use_play_clip_editors", PROP_BOOLEAN, PROP_NONE);
597         RNA_def_property_boolean_sdna(prop, NULL, "redraws_flag", TIME_CLIPS);
598         RNA_def_property_ui_text(prop, "Clip Editors", "");
599         RNA_def_property_update(prop, NC_SPACE | ND_SPACE_TIME, "rna_Screen_redraw_update");
600 }
601
602 void RNA_def_screen(BlenderRNA *brna)
603 {
604         rna_def_screen(brna);
605         rna_def_area(brna);
606         rna_def_region(brna);
607         rna_def_view2d(brna);
608 }
609
610 #endif