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