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 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
62 #include "DEG_depsgraph.h"
63
64 #include "UI_view2d.h"
65
66 #ifdef WITH_PYTHON
67 #  include "BPY_extern.h"
68 #endif
69
70
71 static void rna_Screen_redraw_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
72 {
73         bScreen *screen = (bScreen *)ptr->data;
74
75         /* the settings for this are currently only available from a menu in the TimeLine, hence refresh=SPACE_TIME */
76         ED_screen_animation_timer_update(screen, screen->redraws_flag, SPACE_TIME);
77 }
78
79 static int rna_Screen_is_animation_playing_get(PointerRNA *UNUSED(ptr))
80 {
81         /* can be NULL on file load, T42619 */
82         wmWindowManager *wm = G.main->wm.first;
83         return wm ? (ED_screen_animation_playing(wm) != NULL) : 0;
84 }
85
86 static void rna_Screen_layout_name_get(PointerRNA *ptr, char *value)
87 {
88         const bScreen *screen = ptr->data;
89         const WorkSpaceLayout *layout = BKE_workspace_layout_find_global(G.main, screen, NULL);
90
91         if (layout) {
92                 const char *name = BKE_workspace_layout_name_get(layout);
93                 strcpy(value, name);
94         }
95         else {
96                 value[0] = '\0';
97         }
98 }
99
100 static int rna_Screen_layout_name_length(PointerRNA *ptr)
101 {
102         const bScreen *screen = ptr->data;
103         const WorkSpaceLayout *layout = BKE_workspace_layout_find_global(G.main, screen, NULL);
104
105         if (layout) {
106                 const char *name = BKE_workspace_layout_name_get(layout);
107                 return strlen(name);
108         }
109
110         return 0;
111 }
112
113 static void rna_Screen_layout_name_set(PointerRNA *ptr, const char *value)
114 {
115         bScreen *screen = ptr->data;
116         WorkSpace *workspace;
117         WorkSpaceLayout *layout = BKE_workspace_layout_find_global(G.main, screen, &workspace);
118
119         if (layout) {
120                 BKE_workspace_layout_name_set(workspace, layout, value);
121         }
122 }
123
124 static int rna_Screen_fullscreen_get(PointerRNA *ptr)
125 {
126         bScreen *sc = (bScreen *)ptr->data;
127         return (sc->state == SCREENMAXIMIZED);
128 }
129
130 /* UI compatible list: should not be needed, but for now we need to keep EMPTY
131  * at least in the static version of this enum for python scripts. */
132 static EnumPropertyItem *rna_Area_type_itemf(bContext *UNUSED(C), PointerRNA *UNUSED(ptr),
133                                              PropertyRNA *UNUSED(prop), bool *UNUSED(r_free))
134 {
135         /* +1 to skip SPACE_EMPTY */
136         return rna_enum_space_type_items + 1;
137 }
138
139 static int rna_Area_type_get(PointerRNA *ptr)
140 {
141         ScrArea *sa = (ScrArea *)ptr->data;
142         /* read from this instead of 'spacetype' for correct reporting: T41435 */
143         return sa->butspacetype;
144 }
145
146 static void rna_Area_type_set(PointerRNA *ptr, int value)
147 {
148         ScrArea *sa = (ScrArea *)ptr->data;
149         sa->butspacetype = value;
150 }
151
152 static void rna_Area_type_update(bContext *C, PointerRNA *ptr)
153 {
154         wmWindowManager *wm = CTX_wm_manager(C);
155         wmWindow *win;
156         bScreen *sc = (bScreen *)ptr->id.data;
157         ScrArea *sa = (ScrArea *)ptr->data;
158
159         /* XXX this call still use context, so we trick it to work in the right context */
160         for (win = wm->windows.first; win; win = win->next) {
161                 if (sc == WM_window_get_active_screen(win)) {
162                         wmWindow *prevwin = CTX_wm_window(C);
163                         ScrArea *prevsa = CTX_wm_area(C);
164                         ARegion *prevar = CTX_wm_region(C);
165
166                         CTX_wm_window_set(C, win);
167                         CTX_wm_area_set(C, sa);
168                         CTX_wm_region_set(C, NULL);
169
170                         ED_area_newspace(C, sa, sa->butspacetype, true);
171                         ED_area_tag_redraw(sa);
172
173                         /* It is possible that new layers becomes visible. */
174                         if (sa->spacetype == SPACE_VIEW3D) {
175                                 DEG_on_visible_update(CTX_data_main(C), false);
176                         }
177
178                         CTX_wm_window_set(C, prevwin);
179                         CTX_wm_area_set(C, prevsa);
180                         CTX_wm_region_set(C, prevar);
181                         break;
182                 }
183         }
184 }
185
186 static void rna_View2D_region_to_view(struct View2D *v2d, int x, int y, float result[2])
187 {
188         UI_view2d_region_to_view(v2d, x, y, &result[0], &result[1]);
189 }
190
191 static void rna_View2D_view_to_region(struct View2D *v2d, float x, float y, int clip, int result[2])
192 {
193         if (clip)
194                 UI_view2d_view_to_region_clip(v2d, x, y, &result[0], &result[1]);
195         else
196                 UI_view2d_view_to_region(v2d, x, y, &result[0], &result[1]);
197 }
198
199 #else
200
201 /* Area.spaces */
202 static void rna_def_area_spaces(BlenderRNA *brna, PropertyRNA *cprop)
203 {
204         StructRNA *srna;
205         PropertyRNA *prop;
206
207         RNA_def_property_srna(cprop, "AreaSpaces");
208         srna = RNA_def_struct(brna, "AreaSpaces", NULL);
209         RNA_def_struct_sdna(srna, "ScrArea");
210         RNA_def_struct_ui_text(srna, "Area Spaces", "Collection of spaces");
211
212         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
213         RNA_def_property_pointer_sdna(prop, NULL, "spacedata.first");
214         RNA_def_property_struct_type(prop, "Space");
215         RNA_def_property_ui_text(prop, "Active Space", "Space currently being displayed in this area");
216 }
217
218 static void rna_def_area(BlenderRNA *brna)
219 {
220         StructRNA *srna;
221         PropertyRNA *prop;
222         FunctionRNA *func;
223
224         srna = RNA_def_struct(brna, "Area", NULL);
225         RNA_def_struct_ui_text(srna, "Area", "Area in a subdivided screen, containing an editor");
226         RNA_def_struct_sdna(srna, "ScrArea");
227
228         prop = RNA_def_property(srna, "spaces", PROP_COLLECTION, PROP_NONE);
229         RNA_def_property_collection_sdna(prop, NULL, "spacedata", NULL);
230         RNA_def_property_struct_type(prop, "Space");
231         RNA_def_property_ui_text(prop, "Spaces",
232                                  "Spaces contained in this area, the first being the active space "
233                                  "(NOTE: Useful for example to restore a previously used 3D view space "
234                                  "in a certain area to get the old view orientation)");
235         rna_def_area_spaces(brna, prop);
236
237         prop = RNA_def_property(srna, "regions", PROP_COLLECTION, PROP_NONE);
238         RNA_def_property_collection_sdna(prop, NULL, "regionbase", NULL);
239         RNA_def_property_struct_type(prop, "Region");
240         RNA_def_property_ui_text(prop, "Regions", "Regions this area is subdivided in");
241
242         prop = RNA_def_property(srna, "show_menus", PROP_BOOLEAN, PROP_NONE);
243         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", HEADER_NO_PULLDOWN);
244         RNA_def_property_ui_text(prop, "Show Menus", "Show menus in the header");
245
246         prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
247         RNA_def_property_enum_sdna(prop, NULL, "spacetype");
248         RNA_def_property_enum_items(prop, rna_enum_space_type_items);
249         RNA_def_property_enum_default(prop, SPACE_VIEW3D);
250         RNA_def_property_enum_funcs(prop, "rna_Area_type_get", "rna_Area_type_set", "rna_Area_type_itemf");
251         RNA_def_property_ui_text(prop, "Editor Type", "Current editor type for this area");
252         RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
253         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
254         RNA_def_property_update(prop, 0, "rna_Area_type_update");
255
256         prop = RNA_def_property(srna, "x", PROP_INT, PROP_NONE);
257         RNA_def_property_int_sdna(prop, NULL, "totrct.xmin");
258         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
259         RNA_def_property_ui_text(prop, "X Position", "The window relative vertical location of the area");
260
261         prop = RNA_def_property(srna, "y", PROP_INT, PROP_NONE);
262         RNA_def_property_int_sdna(prop, NULL, "totrct.ymin");
263         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
264         RNA_def_property_ui_text(prop, "Y Position", "The window relative horizontal location of the area");
265
266         prop = RNA_def_property(srna, "width", PROP_INT, PROP_UNSIGNED);
267         RNA_def_property_int_sdna(prop, NULL, "winx");
268         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
269         RNA_def_property_ui_text(prop, "Width", "Area width");
270
271         prop = RNA_def_property(srna, "height", PROP_INT, PROP_UNSIGNED);
272         RNA_def_property_int_sdna(prop, NULL, "winy");
273         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
274         RNA_def_property_ui_text(prop, "Height", "Area height");
275
276         RNA_def_function(srna, "tag_redraw", "ED_area_tag_redraw");
277
278         func = RNA_def_function(srna, "header_text_set", "ED_area_headerprint");
279         RNA_def_function_ui_description(func, "Set the header text");
280         RNA_def_string(func, "text", NULL, 0, "Text", "New string for the header, no argument clears the text");
281 }
282
283 static void rna_def_view2d_api(StructRNA *srna)
284 {
285         FunctionRNA *func;
286         PropertyRNA *parm;
287         
288         static const float view_default[2] = {0.0f, 0.0f};
289         static const int region_default[2] = {0.0f, 0.0f};
290         
291         func = RNA_def_function(srna, "region_to_view", "rna_View2D_region_to_view");
292         RNA_def_function_ui_description(func, "Transform region coordinates to 2D view");
293         parm = RNA_def_int(func, "x", 0, INT_MIN, INT_MAX, "x", "Region x coordinate", -10000, 10000);
294         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
295         parm = RNA_def_int(func, "y", 0, INT_MIN, INT_MAX, "y", "Region y coordinate", -10000, 10000);
296         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
297         parm = RNA_def_float_array(func, "result", 2, view_default, -FLT_MAX, FLT_MAX, "Result", "View coordinates", -10000.0f, 10000.0f);
298         RNA_def_parameter_flags(parm, PROP_THICK_WRAP, 0);
299         RNA_def_function_output(func, parm);
300
301         func = RNA_def_function(srna, "view_to_region", "rna_View2D_view_to_region");
302         RNA_def_function_ui_description(func, "Transform 2D view coordinates to region");
303         parm = RNA_def_float(func, "x", 0.0f, -FLT_MAX, FLT_MAX, "x", "2D View x coordinate", -10000.0f, 10000.0f);
304         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
305         parm = RNA_def_float(func, "y", 0.0f, -FLT_MAX, FLT_MAX, "y", "2D View y coordinate", -10000.0f, 10000.0f);
306         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
307         RNA_def_boolean(func, "clip", 1, "Clip", "Clip coordinates to the visible region");
308         parm = RNA_def_int_array(func, "result", 2, region_default, INT_MIN, INT_MAX, "Result", "Region coordinates", -10000, 10000);
309         RNA_def_parameter_flags(parm, PROP_THICK_WRAP, 0);
310         RNA_def_function_output(func, parm);
311 }
312
313 static void rna_def_view2d(BlenderRNA *brna)
314 {
315         StructRNA *srna;
316         /* PropertyRNA *prop; */
317
318         srna = RNA_def_struct(brna, "View2D", NULL);
319         RNA_def_struct_ui_text(srna, "View2D", "Scroll and zoom for a 2D region");
320         RNA_def_struct_sdna(srna, "View2D");
321         
322         /* TODO more View2D properties could be exposed here (read-only) */
323         
324         rna_def_view2d_api(srna);
325 }
326
327 static void rna_def_region(BlenderRNA *brna)
328 {
329         StructRNA *srna;
330         PropertyRNA *prop;
331
332         srna = RNA_def_struct(brna, "Region", NULL);
333         RNA_def_struct_ui_text(srna, "Region", "Region in a subdivided screen area");
334         RNA_def_struct_sdna(srna, "ARegion");
335
336         prop = RNA_def_property(srna, "id", PROP_INT, PROP_NONE);
337         RNA_def_property_int_sdna(prop, NULL, "swinid");
338         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
339         RNA_def_property_ui_text(prop, "Region ID", "Unique ID for this region");
340
341         prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
342         RNA_def_property_enum_sdna(prop, NULL, "regiontype");
343         RNA_def_property_enum_items(prop, rna_enum_region_type_items);
344         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
345         RNA_def_property_ui_text(prop, "Region Type", "Type of this region");
346
347         prop = RNA_def_property(srna, "x", PROP_INT, PROP_NONE);
348         RNA_def_property_int_sdna(prop, NULL, "winrct.xmin");
349         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
350         RNA_def_property_ui_text(prop, "X Position", "The window relative vertical location of the region");
351
352         prop = RNA_def_property(srna, "y", PROP_INT, PROP_NONE);
353         RNA_def_property_int_sdna(prop, NULL, "winrct.ymin");
354         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
355         RNA_def_property_ui_text(prop, "Y Position", "The window relative horizontal location of the region");
356
357         prop = RNA_def_property(srna, "width", PROP_INT, PROP_UNSIGNED);
358         RNA_def_property_int_sdna(prop, NULL, "winx");
359         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
360         RNA_def_property_ui_text(prop, "Width", "Region width");
361
362         prop = RNA_def_property(srna, "height", PROP_INT, PROP_UNSIGNED);
363         RNA_def_property_int_sdna(prop, NULL, "winy");
364         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
365         RNA_def_property_ui_text(prop, "Height", "Region height");
366
367         prop = RNA_def_property(srna, "view2d", PROP_POINTER, PROP_NONE);
368         RNA_def_property_pointer_sdna(prop, NULL, "v2d");
369         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
370         RNA_def_property_flag(prop, PROP_NEVER_NULL);
371         RNA_def_property_ui_text(prop, "View2D", "2D view of the region");
372
373         RNA_def_function(srna, "tag_redraw", "ED_region_tag_redraw");
374 }
375
376 static void rna_def_screen(BlenderRNA *brna)
377 {
378         StructRNA *srna;
379         PropertyRNA *prop;
380
381         srna = RNA_def_struct(brna, "Screen", "ID");
382         RNA_def_struct_sdna(srna, "Screen"); /* it is actually bScreen but for 2.5 the dna is patched! */
383         RNA_def_struct_ui_text(srna, "Screen", "Screen data-block, defining the layout of areas in a window");
384         RNA_def_struct_ui_icon(srna, ICON_SPLITSCREEN);
385
386         prop = RNA_def_property(srna, "layout_name", PROP_STRING, PROP_NONE);
387         RNA_def_property_string_funcs(prop, "rna_Screen_layout_name_get", "rna_Screen_layout_name_length",
388                                       "rna_Screen_layout_name_set");
389         RNA_def_property_ui_text(prop, "Layout Name", "The name of the layout that refers to the screen");
390         RNA_def_struct_name_property(srna, prop);
391
392         /* collections */
393         prop = RNA_def_property(srna, "areas", PROP_COLLECTION, PROP_NONE);
394         RNA_def_property_collection_sdna(prop, NULL, "areabase", NULL);
395         RNA_def_property_struct_type(prop, "Area");
396         RNA_def_property_ui_text(prop, "Areas", "Areas the screen is subdivided into");
397
398         /* readonly status indicators */
399         prop = RNA_def_property(srna, "is_animation_playing", PROP_BOOLEAN, PROP_NONE);
400         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
401         RNA_def_property_boolean_funcs(prop, "rna_Screen_is_animation_playing_get", NULL);
402         RNA_def_property_ui_text(prop, "Animation Playing", "Animation playback is active");
403
404         prop = RNA_def_property(srna, "show_fullscreen", PROP_BOOLEAN, PROP_NONE);
405         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
406         RNA_def_property_boolean_funcs(prop, "rna_Screen_fullscreen_get", NULL);
407         RNA_def_property_ui_text(prop, "Maximize", "An area is maximized, filling this screen");
408
409         /* Define Anim Playback Areas */
410         prop = RNA_def_property(srna, "use_play_top_left_3d_editor", PROP_BOOLEAN, PROP_NONE);
411         RNA_def_property_boolean_sdna(prop, NULL, "redraws_flag", TIME_REGION);
412         RNA_def_property_ui_text(prop, "Top-Left 3D Editor", "");
413         RNA_def_property_update(prop, NC_SPACE | ND_SPACE_TIME, "rna_Screen_redraw_update");
414
415         prop = RNA_def_property(srna, "use_play_3d_editors", PROP_BOOLEAN, PROP_NONE);
416         RNA_def_property_boolean_sdna(prop, NULL, "redraws_flag", TIME_ALL_3D_WIN);
417         RNA_def_property_ui_text(prop, "All 3D View Editors", "");
418         RNA_def_property_update(prop, NC_SPACE | ND_SPACE_TIME, "rna_Screen_redraw_update");
419
420         prop = RNA_def_property(srna, "use_follow", PROP_BOOLEAN, PROP_NONE);
421         RNA_def_property_boolean_sdna(prop, NULL, "redraws_flag", TIME_FOLLOW);
422         RNA_def_property_ui_text(prop, "Follow", "Follow current frame in editors");
423         RNA_def_property_update(prop, NC_SPACE | ND_SPACE_TIME, "rna_Screen_redraw_update");
424
425         prop = RNA_def_property(srna, "use_play_animation_editors", PROP_BOOLEAN, PROP_NONE);
426         RNA_def_property_boolean_sdna(prop, NULL, "redraws_flag", TIME_ALL_ANIM_WIN);
427         RNA_def_property_ui_text(prop, "Animation Editors", "");
428         RNA_def_property_update(prop, NC_SPACE | ND_SPACE_TIME, "rna_Screen_redraw_update");
429
430         prop = RNA_def_property(srna, "use_play_properties_editors", PROP_BOOLEAN, PROP_NONE);
431         RNA_def_property_boolean_sdna(prop, NULL, "redraws_flag", TIME_ALL_BUTS_WIN);
432         RNA_def_property_ui_text(prop, "Property Editors", "");
433         RNA_def_property_update(prop, NC_SPACE | ND_SPACE_TIME, "rna_Screen_redraw_update");
434
435         prop = RNA_def_property(srna, "use_play_image_editors", PROP_BOOLEAN, PROP_NONE);
436         RNA_def_property_boolean_sdna(prop, NULL, "redraws_flag", TIME_ALL_IMAGE_WIN);
437         RNA_def_property_ui_text(prop, "Image Editors", "");
438         RNA_def_property_update(prop, NC_SPACE | ND_SPACE_TIME, "rna_Screen_redraw_update");
439
440         prop = RNA_def_property(srna, "use_play_sequence_editors", PROP_BOOLEAN, PROP_NONE);
441         RNA_def_property_boolean_sdna(prop, NULL, "redraws_flag", TIME_SEQ);
442         RNA_def_property_ui_text(prop, "Sequencer Editors", "");
443         RNA_def_property_update(prop, NC_SPACE | ND_SPACE_TIME, "rna_Screen_redraw_update");
444
445         prop = RNA_def_property(srna, "use_play_node_editors", PROP_BOOLEAN, PROP_NONE);
446         RNA_def_property_boolean_sdna(prop, NULL, "redraws_flag", TIME_NODES);
447         RNA_def_property_ui_text(prop, "Node Editors", "");
448         RNA_def_property_update(prop, NC_SPACE | ND_SPACE_TIME, "rna_Screen_redraw_update");
449
450         prop = RNA_def_property(srna, "use_play_clip_editors", PROP_BOOLEAN, PROP_NONE);
451         RNA_def_property_boolean_sdna(prop, NULL, "redraws_flag", TIME_CLIPS);
452         RNA_def_property_ui_text(prop, "Clip Editors", "");
453         RNA_def_property_update(prop, NC_SPACE | ND_SPACE_TIME, "rna_Screen_redraw_update");
454 }
455
456 void RNA_def_screen(BlenderRNA *brna)
457 {
458         rna_def_screen(brna);
459         rna_def_area(brna);
460         rna_def_region(brna);
461         rna_def_view2d(brna);
462 }
463
464 #endif
465