1 files changed, 158 insertions, 269 deletions

diff --git a/source/blender/editors/screen/screen_edit.c b/source/blender/editors/screen/screen_edit.c
index d59109a5baa..65b783463a9 100644
--- a/source/blender/editors/screen/screen_edit.c
+++ b/source/blender/editors/screen/screen_edit.c
@@ -51,6 +51,7 @@
 #include "BKE_node.h"
 #include "BKE_screen.h"
 #include "BKE_scene.h"
+#include "BKE_workspace.h"
 
 #include "WM_api.h"
 #include "WM_types.h"
@@ -264,7 +265,7 @@ bool scredge_is_horizontal(ScrEdge *se)
 }
 
 /* need win size to make sure not to include edges along screen edge */
-ScrEdge *screen_find_active_scredge(bScreen *sc,
+ScrEdge *screen_find_active_scredge(const bScreen *sc,
                                     const int winsize_x, const int winsize_y,
                                     const int mx, const int my)
 {
@@ -455,39 +456,35 @@ ScrArea *area_split(bScreen *sc, ScrArea *sa, char dir, float fac, int merge)
 	return newa;
 }
 
-/* empty screen, with 1 dummy area without spacedata */
-/* uses window size */
-bScreen *ED_screen_add(wmWindow *win, Scene *scene, const char *name)
+/**
+ * Empty screen, with 1 dummy area without spacedata. Uses window size.
+ */
+bScreen *screen_add(const char *name, const int winsize_x, const int winsize_y)
 {
-	const int winsize_x = WM_window_pixels_x(win);
-	const int winsize_y = WM_window_pixels_y(win);
-
 	bScreen *sc;
 	ScrVert *sv1, *sv2, *sv3, *sv4;
-	
+
 	sc = BKE_libblock_alloc(G.main, ID_SCR, name);
-	sc->scene = scene;
 	sc->do_refresh = true;
 	sc->redraws_flag = TIME_ALL_3D_WIN | TIME_ALL_ANIM_WIN;
-	sc->winid = win->winid;
 
 	sv1 = screen_addvert(sc, 0, 0);
 	sv2 = screen_addvert(sc, 0, winsize_y - 1);
 	sv3 = screen_addvert(sc, winsize_x - 1, winsize_y - 1);
 	sv4 = screen_addvert(sc, winsize_x - 1, 0);
-	
+
 	screen_addedge(sc, sv1, sv2);
 	screen_addedge(sc, sv2, sv3);
 	screen_addedge(sc, sv3, sv4);
 	screen_addedge(sc, sv4, sv1);
-	
+
 	/* dummy type, no spacedata */
 	screen_addarea(sc, sv1, sv2, sv3, sv4, HEADERDOWN, SPACE_EMPTY);
-		
+
 	return sc;
 }
 
-static void screen_copy(bScreen *to, bScreen *from)
+void screen_data_copy(bScreen *to, bScreen *from)
 {
 	ScrVert *s1, *s2;
 	ScrEdge *se;
@@ -530,7 +527,16 @@ static void screen_copy(bScreen *to, bScreen *from)
 	/* put at zero (needed?) */
 	for (s1 = from->vertbase.first; s1; s1 = s1->next)
 		s1->newv = NULL;
+}
 
+/**
+ * Prepare a newly created screen for initializing it as active screen.
+ */
+void screen_new_activate_prepare(const wmWindow *win, bScreen *screen_new)
+{
+	screen_new->winid = win->winid;
+	screen_new->do_refresh = true;
+	screen_new->do_draw = true;
 }
 
 
@@ -841,24 +847,12 @@ static void screen_test_scale(bScreen *sc, int winsize_x, int winsize_y)
 
 /* ****************** EXPORTED API TO OTHER MODULES *************************** */
 
-bScreen *ED_screen_duplicate(wmWindow *win, bScreen *sc)
-{
-	bScreen *newsc;
-	
-	if (sc->state != SCREENNORMAL) return NULL;  /* XXX handle this case! */
-	
-	/* make new empty screen: */
-	newsc = ED_screen_add(win, sc->scene, sc->id.name + 2);
-	/* copy all data */
-	screen_copy(newsc, sc);
-
-	return newsc;
-}
-
 /* screen sets cursor based on swinid */
 static void region_cursor_set(wmWindow *win, int swinid, int swin_changed)
 {
-	for (ScrArea *sa = win->screen->areabase.first; sa; sa = sa->next) {
+	bScreen *screen = WM_window_get_active_screen(win);
+
+	for (ScrArea *sa = screen->areabase.first; sa; sa = sa->next) {
 		for (ARegion *ar = sa->regionbase.first; ar; ar = ar->next) {
 			if (ar->swinid == swinid) {
 				if (swin_changed || (ar->type && ar->type->event_cursor)) {
@@ -876,19 +870,20 @@ static void region_cursor_set(wmWindow *win, int swinid, int swin_changed)
 void ED_screen_do_listen(bContext *C, wmNotifier *note)
 {
 	wmWindow *win = CTX_wm_window(C);
-	
+	bScreen *screen = CTX_wm_screen(C);
+
 	/* generic notes */
 	switch (note->category) {
 		case NC_WM:
 			if (note->data == ND_FILEREAD)
-				win->screen->do_draw = true;
+				screen->do_draw = true;
 			break;
 		case NC_WINDOW:
-			win->screen->do_draw = true;
+			screen->do_draw = true;
 			break;
 		case NC_SCREEN:
 			if (note->action == NA_EDITED)
-				win->screen->do_draw = win->screen->do_refresh = true;
+				screen->do_draw = screen->do_refresh = true;
 			break;
 		case NC_SCENE:
 			if (note->data == ND_MODE)
@@ -912,7 +907,9 @@ static void screen_refresh_headersizes(void)
 /* make this screen usable */
 /* for file read and first use, for scaling window, area moves */
 void ED_screen_refresh(wmWindowManager *wm, wmWindow *win)
-{	
+{
+	bScreen *screen = WM_window_get_active_screen(win);
+
 	/* exception for bg mode, we only need the screen context */
 	if (!G.background) {
 		const int winsize_x = WM_window_pixels_x(win);
@@ -928,32 +925,34 @@ void ED_screen_refresh(wmWindowManager *wm, wmWindow *win)
 		/* header size depends on DPI, let's verify */
 		screen_refresh_headersizes();
 		
-		screen_test_scale(win->screen, winsize_x, winsize_y);
+		screen_test_scale(screen, winsize_x, winsize_y);
 		
-		if (win->screen->mainwin == 0) {
-			win->screen->mainwin = wm_subwindow_open(win, &winrct, false);
+		if (screen->mainwin == 0) {
+			screen->mainwin = wm_subwindow_open(win, &winrct, false);
 		}
 		else {
-			wm_subwindow_position(win, win->screen->mainwin, &winrct, false);
+			wm_subwindow_position(win, screen->mainwin, &winrct, false);
 		}
 		
-		for (sa = win->screen->areabase.first; sa; sa = sa->next) {
+		for (sa = screen->areabase.first; sa; sa = sa->next) {
 			/* set spacetype and region callbacks, calls init() */
 			/* sets subwindows for regions, adds handlers */
 			ED_area_initialize(wm, win, sa);
 		}
 	
 		/* wake up animtimer */
-		if (win->screen->animtimer)
-			WM_event_timer_sleep(wm, win, win->screen->animtimer, false);
+		if (screen->animtimer)
+			WM_event_timer_sleep(wm, win, screen->animtimer, false);
 	}
 
 	if (G.debug & G_DEBUG_EVENTS) {
 		printf("%s: set screen\n", __func__);
 	}
-	win->screen->do_refresh = false;
+	screen->do_refresh = false;
+	/* prevent multiwin errors */
+	screen->winid = win->winid;
 
-	win->screen->context = ed_screen_context;
+	screen->context = ed_screen_context;
 }
 
 /* file read, set all screens, ... */
@@ -962,10 +961,10 @@ void ED_screens_initialize(wmWindowManager *wm)
 	wmWindow *win;
 	
 	for (win = wm->windows.first; win; win = win->next) {
-		
-		if (win->screen == NULL)
-			win->screen = G.main->screen.first;
-		
+		if (WM_window_get_active_workspace(win) == NULL) {
+			WM_window_set_active_workspace(win, G.main->workspaces.first);
+		}
+
 		ED_screen_refresh(wm, win);
 	}
 }
@@ -1053,7 +1052,7 @@ void ED_screen_exit(bContext *C, wmWindow *window, bScreen *screen)
 	/* mark it available for use for other windows */
 	screen->winid = 0;
 	
-	if (prevwin->screen->temp == 0) {
+	if (!WM_window_is_temp_screen(prevwin)) {
 		/* use previous window if possible */
 		CTX_wm_window_set(C, prevwin);
 	}
@@ -1069,13 +1068,14 @@ void ED_screen_exit(bContext *C, wmWindow *window, bScreen *screen)
 /* case when on area-edge or in azones, or outside window */
 static void screen_cursor_set(wmWindow *win, wmEvent *event)
 {
+	const bScreen *screen = WM_window_get_active_screen(win);
 	const int winsize_x = WM_window_pixels_x(win);
 	const int winsize_y = WM_window_pixels_y(win);
 
 	AZone *az = NULL;
 	ScrArea *sa;
 	
-	for (sa = win->screen->areabase.first; sa; sa = sa->next)
+	for (sa = screen->areabase.first; sa; sa = sa->next)
 		if ((az = is_in_area_actionzone(sa, &event->x)))
 			break;
 	
@@ -1090,7 +1090,7 @@ static void screen_cursor_set(wmWindow *win, wmEvent *event)
 		}
 	}
 	else {
-		ScrEdge *actedge = screen_find_active_scredge(win->screen, winsize_x, winsize_y, event->x, event->y);
+		ScrEdge *actedge = screen_find_active_scredge(screen, winsize_x, winsize_y, event->x, event->y);
 		
 		if (actedge) {
 			if (scredge_is_horizontal(actedge))
@@ -1109,9 +1109,9 @@ static void screen_cursor_set(wmWindow *win, wmEvent *event)
 void ED_screen_set_subwinactive(bContext *C, wmEvent *event)
 {
 	wmWindow *win = CTX_wm_window(C);
-	
-	if (win->screen) {
-		bScreen *scr = win->screen;
+	bScreen *scr = WM_window_get_active_screen(win);
+
+	if (scr) {
 		ScrArea *sa;
 		ARegion *ar;
 		int oldswin = scr->subwinactive;
@@ -1164,7 +1164,7 @@ void ED_screen_set_subwinactive(bContext *C, wmEvent *event)
 				/* this used to be a notifier, but needs to be done immediate
 				 * because it can undo setting the right button as active due
 				 * to delayed notifier handling */
-				UI_screen_free_active_but(C, win->screen);
+				UI_screen_free_active_but(C, scr);
 			}
 			else
 				region_cursor_set(win, scr->subwinactive, false);
@@ -1192,177 +1192,120 @@ int ED_screen_area_active(const bContext *C)
 	return 0;
 }
 
+
+/* -------------------------------------------------------------------- */
+/* Screen changing */
+
+static bScreen *screen_fullscreen_find_associated_normal_screen(const Main *bmain, bScreen *screen)
+{
+	for (bScreen *screen_iter = bmain->screen.first; screen_iter; screen_iter = screen_iter->id.next) {
+		ScrArea *sa = screen_iter->areabase.first;
+		if (sa->full == screen) {
+			return screen_iter;
+		}
+	}
+
+	return screen;
+}
+
 /**
- * operator call, WM + Window + screen already existed before
- *
- * \warning Do NOT call in area/region queues!
- * \returns success.
+ * \return the screen to activate.
+ * \warning The returned screen may not always equal \a screen_new!
  */
-bool ED_screen_set(bContext *C, bScreen *sc)
+bScreen *screen_change_prepare(bScreen *screen_old, bScreen *screen_new, Main *bmain, bContext *C, wmWindow *win)
 {
-	Main *bmain = CTX_data_main(C);
-	wmWindowManager *wm = CTX_wm_manager(C);
-	wmWindow *win = CTX_wm_window(C);
-	bScreen *oldscreen = CTX_wm_screen(C);
-	
 	/* validate screen, it's called with notifier reference */
-	if (BLI_findindex(&bmain->screen, sc) == -1) {
-		return true;
+	if (BLI_findindex(&bmain->screen, screen_new) == -1) {
+		return NULL;
 	}
 
-	if (ELEM(sc->state, SCREENMAXIMIZED, SCREENFULL)) {
-		/* find associated full */
-		bScreen *sc1;
-		for (sc1 = bmain->screen.first; sc1; sc1 = sc1->id.next) {
-			ScrArea *sa = sc1->areabase.first;
-			if (sa->full == sc) {
-				sc = sc1;
-				break;
-			}
-		}
+	if (ELEM(screen_new->state, SCREENMAXIMIZED, SCREENFULL)) {
+		screen_new = screen_fullscreen_find_associated_normal_screen(bmain, screen_new);
 	}
 
 	/* check for valid winid */
-	if (sc->winid != 0 && sc->winid != win->winid) {
-		return false;
+	if (!(screen_new->winid == 0 || screen_new->winid == win->winid)) {
+		return NULL;
 	}
-	
-	if (oldscreen != sc) {
-		wmTimer *wt = oldscreen->animtimer;
-		ScrArea *sa;
-		Scene *oldscene = oldscreen->scene;
+
+	if (screen_old != screen_new) {
+		wmTimer *wt = screen_old->animtimer;
 
 		/* remove handlers referencing areas in old screen */
-		for (sa = oldscreen->areabase.first; sa; sa = sa->next) {
+		for (ScrArea *sa = screen_old->areabase.first; sa; sa = sa->next) {
 			WM_event_remove_area_handler(&win->modalhandlers, sa);
 		}
 
 		/* we put timer to sleep, so screen_exit has to think there's no timer */
-		oldscreen->animtimer = NULL;
+		screen_old->animtimer = NULL;
 		if (wt) {
-			WM_event_timer_sleep(wm, win, wt, true);
+			WM_event_timer_sleep(CTX_wm_manager(C), win, wt, true);
 		}
-
-		ED_screen_exit(C, win, oldscreen);
+		ED_screen_exit(C, win, screen_old);
 
 		/* Same scene, "transfer" playback to new screen. */
 		if (wt) {
-			if (oldscene == sc->scene) {
-				sc->animtimer = wt;
-			}
-			/* Else, stop playback. */
-			else {
-				oldscreen->animtimer = wt;
-				ED_screen_animation_play(C, 0, 0);
-			}
+			screen_new->animtimer = wt;
 		}
 
-		win->screen = sc;
-		CTX_wm_window_set(C, win);  // stores C->wm.screen... hrmf
-		
-		/* prevent multiwin errors */
-		sc->winid = win->winid;
-		
-		ED_screen_refresh(CTX_wm_manager(C), CTX_wm_window(C));
-		WM_event_add_notifier(C, NC_WINDOW, NULL);
-		WM_event_add_notifier(C, NC_SCREEN | ND_SCREENSET, sc);
-		
-		/* makes button hilites work */
-		WM_event_add_mousemove(C);
-
-		/* Needed to make sure all the derivedMeshes are
-		 * up-to-date before viewport starts acquiring this.
-		 *
-		 * This is needed in cases when, for example, boolean
-		 * modifier uses operant from invisible layer.
-		 * Without this trick boolean wouldn't apply correct.
-		 *
-		 * Quite the same happens when setting screen's scene,
-		 * so perhaps this is in fact correct thing to do.
-		 */
-		if (oldscene != sc->scene) {
-			BKE_scene_set_background(bmain, sc->scene);
-		}
-
-		/* Always do visible update since it's possible new screen will
-		 * have different layers visible in 3D view-ports.
-		 * This is possible because of view3d.lock_camera_and_layers option.
-		 */
-		DAG_on_visible_update(bmain, false);
+		return screen_new;
 	}
 
-	return true;
+	return NULL;
 }
 
-static bool ed_screen_used(wmWindowManager *wm, bScreen *sc)
+void screen_changed_update(bContext *C, wmWindow *win, bScreen *sc)
 {
-	wmWindow *win;
+	Scene *scene = WM_window_get_active_scene(win);
+	WorkSpace *workspace = BKE_workspace_active_get(win->workspace_hook);
+	WorkSpaceLayout *layout = BKE_workspace_layout_find(workspace, sc);
 
-	for (win = wm->windows.first; win; win = win->next) {
-		if (win->screen == sc) {
-			return true;
-		}
+	CTX_wm_window_set(C, win);  /* stores C->wm.screen... hrmf */
 
-		if (ELEM(win->screen->state, SCREENMAXIMIZED, SCREENFULL)) {
-			ScrArea *sa = win->screen->areabase.first;
-			if (sa->full == sc) {
-				return true;
-			}
-		}
-	}
+	ED_screen_refresh(CTX_wm_manager(C), win);
 
-	return false;
+	BKE_screen_view3d_scene_sync(sc, scene); /* sync new screen with scene data */
+	WM_event_add_notifier(C, NC_WINDOW, NULL);
+	WM_event_add_notifier(C, NC_SCREEN | ND_LAYOUTSET, layout);
+
+	/* makes button hilites work */
+	WM_event_add_mousemove(C);
 }
 
-/* only call outside of area/region loops */
-bool ED_screen_delete(bContext *C, bScreen *sc)
+
+/**
+ * \brief Change the active screen.
+ *
+ * Operator call, WM + Window + screen already existed before
+ *
+ * \warning Do NOT call in area/region queues!
+ * \returns if screen changing was successful.
+ */
+bool ED_screen_change(bContext *C, bScreen *sc)
 {
 	Main *bmain = CTX_data_main(C);
-	wmWindowManager *wm = CTX_wm_manager(C);
 	wmWindow *win = CTX_wm_window(C);
-	bScreen *newsc;
-	
-	/* don't allow deleting temp fullscreens for now */
-	if (ELEM(sc->state, SCREENMAXIMIZED, SCREENFULL)) {
-		return false;
-	}
+	bScreen *screen_old = CTX_wm_screen(C);
+	bScreen *screen_new = screen_change_prepare(screen_old, sc, bmain, C, win);
 
-	/* screen can only be in use by one window at a time, so as
-	 * long as we are able to find a screen that is unused, we
-	 * can safely assume ours is not in use anywhere an delete it */
+	if (screen_new) {
+		WorkSpace *workspace = BKE_workspace_active_get(win->workspace_hook);
+		WM_window_set_active_screen(win, workspace, sc);
+		screen_changed_update(C, win, screen_new);
 
-	for (newsc = sc->id.prev; newsc; newsc = newsc->id.prev)
-		if (!ed_screen_used(wm, newsc) && !newsc->temp)
-			break;
-	
-	if (!newsc) {
-		for (newsc = sc->id.next; newsc; newsc = newsc->id.next)
-			if (!ed_screen_used(wm, newsc) && !newsc->temp)
-				break;
-	}
-
-	if (!newsc) {
-		return false;
-	}
-
-	ED_screen_set(C, newsc);
-
-	if (win->screen != sc) {
-		BKE_libblock_free(bmain, sc);
 		return true;
 	}
-	else {
-		return false;
-	}
+
+	return false;
 }
 
-static void ed_screen_set_3dview_camera(Scene *scene, bScreen *sc, ScrArea *sa, View3D *v3d)
+static void screen_set_3dview_camera(Scene *scene, ScrArea *sa, View3D *v3d)
 {
 	/* fix any cameras that are used in the 3d view but not in the scene */
 	BKE_screen_view3d_sync(v3d, scene);
 
 	if (!v3d->camera || !BKE_scene_base_find(scene, v3d->camera)) {
-		v3d->camera = BKE_scene_camera_find(sc->scene);
+		v3d->camera = BKE_scene_camera_find(scene);
 		// XXX if (sc == curscreen) handle_view3d_lock();
 		if (!v3d->camera) {
 			ARegion *ar;
@@ -1386,90 +1329,16 @@ static void ed_screen_set_3dview_camera(Scene *scene, bScreen *sc, ScrArea *sa,
 	}
 }
 
-/* only call outside of area/region loops */
-void ED_screen_set_scene(bContext *C, bScreen *screen, Scene *scene)
+void ED_screen_update_after_scene_change(const bScreen *screen, Scene *scene_new)
 {
-	Main *bmain = CTX_data_main(C);
-	bScreen *sc;
-
-	if (screen == NULL)
-		return;
-	
-	if (ed_screen_used(CTX_wm_manager(C), screen))
-		ED_object_editmode_exit(C, EM_FREEDATA | EM_DO_UNDO);
-
-	for (sc = bmain->screen.first; sc; sc = sc->id.next) {
-		if ((U.flag & USER_SCENEGLOBAL) || sc == screen) {
-			
-			if (scene != sc->scene) {
-				/* all areas endlocalview */
-				// XXX	ScrArea *sa = sc->areabase.first;
-				//	while (sa) {
-				//		endlocalview(sa);
-				//		sa = sa->next;
-				//	}
-				sc->scene = scene;
-			}
-			
-		}
-	}
-	
-	//  copy_view3d_lock(0);	/* space.c */
-	
-	/* are there cameras in the views that are not in the scene? */
-	for (sc = bmain->screen.first; sc; sc = sc->id.next) {
-		if ((U.flag & USER_SCENEGLOBAL) || sc == screen) {
-			ScrArea *sa = sc->areabase.first;
-			while (sa) {
-				SpaceLink *sl = sa->spacedata.first;
-				while (sl) {
-					if (sl->spacetype == SPACE_VIEW3D) {
-						View3D *v3d = (View3D *) sl;
-						ed_screen_set_3dview_camera(scene, sc, sa, v3d);
-
-					}
-					sl = sl->next;
-				}
-				sa = sa->next;
+	for (ScrArea *sa = screen->areabase.first; sa; sa = sa->next) {
+		for (SpaceLink *sl = sa->spacedata.first; sl; sl = sl->next) {
+			if (sl->spacetype == SPACE_VIEW3D) {
+				View3D *v3d = (View3D *)sl;
+				screen_set_3dview_camera(scene_new, sa, v3d);
 			}
 		}
 	}
-	
-	CTX_data_scene_set(C, scene);
-	BKE_scene_set_background(bmain, scene);
-	DAG_on_visible_update(bmain, false);
-	
-	ED_render_engine_changed(bmain);
-	ED_update_for_newframe(bmain, scene, 1);
-	
-	/* complete redraw */
-	WM_event_add_notifier(C, NC_WINDOW, NULL);
-	
-}
-
-/**
- * \note Only call outside of area/region loops
- * \return true if successful
- */
-bool ED_screen_delete_scene(bContext *C, Scene *scene)
-{
-	Main *bmain = CTX_data_main(C);
-	Scene *newscene;
-
-	if (scene->id.prev)
-		newscene = scene->id.prev;
-	else if (scene->id.next)
-		newscene = scene->id.next;
-	else
-		return false;
-
-	ED_screen_set_scene(C, CTX_wm_screen(C), newscene);
-
-	BKE_libblock_remap(bmain, scene, newscene, ID_REMAP_SKIP_INDIRECT_USAGE | ID_REMAP_SKIP_NEVER_NULL_USAGE);
-
-	BKE_libblock_free(bmain, scene);
-
-	return true;
 }
 
 ScrArea *ED_screen_full_newspace(bContext *C, ScrArea *sa, int type)
@@ -1576,6 +1445,7 @@ void ED_screen_full_restore(bContext *C, ScrArea *sa)
 ScrArea *ED_screen_state_toggle(bContext *C, wmWindow *win, ScrArea *sa, const short state)
 {
 	wmWindowManager *wm = CTX_wm_manager(C);
+	WorkSpace *workspace = WM_window_get_active_workspace(win);
 	bScreen *sc, *oldscreen;
 	ARegion *ar;
 
@@ -1597,11 +1467,12 @@ ScrArea *ED_screen_state_toggle(bContext *C, wmWindow *win, ScrArea *sa, const s
 	}
 
 	if (sa && sa->full) {
+		WorkSpaceLayout *layout_old = WM_window_get_active_layout(win);
 		/* restoring back to SCREENNORMAL */
 		ScrArea *old;
 
 		sc = sa->full;       /* the old screen to restore */
-		oldscreen = win->screen; /* the one disappearing */
+		oldscreen = WM_window_get_active_screen(win); /* the one disappearing */
 
 		sc->state = SCREENNORMAL;
 
@@ -1629,10 +1500,9 @@ ScrArea *ED_screen_state_toggle(bContext *C, wmWindow *win, ScrArea *sa, const s
 		sc->animtimer = oldscreen->animtimer;
 		oldscreen->animtimer = NULL;
 
-		ED_screen_set(C, sc);
+		ED_screen_change(C, sc);
 
-		BKE_screen_free(oldscreen);
-		BKE_libblock_free(CTX_data_main(C), oldscreen);
+		BKE_workspace_layout_remove(CTX_data_main(C), workspace, layout_old);
 
 		/* After we've restored back to SCREENNORMAL, we have to wait with
 		 * screen handling as it uses the area coords which aren't updated yet.
@@ -1642,14 +1512,18 @@ ScrArea *ED_screen_state_toggle(bContext *C, wmWindow *win, ScrArea *sa, const s
 	}
 	else {
 		/* change from SCREENNORMAL to new state */
+		WorkSpaceLayout *layout_new;
 		ScrArea *newa;
 		char newname[MAX_ID_NAME - 2];
 
-		oldscreen = win->screen;
+		oldscreen = WM_window_get_active_screen(win);
 
 		oldscreen->state = state;
 		BLI_snprintf(newname, sizeof(newname), "%s-%s", oldscreen->id.name + 2, "nonnormal");
-		sc = ED_screen_add(win, oldscreen->scene, newname);
+
+		layout_new = ED_workspace_layout_add(workspace, win, newname);
+
+		sc = BKE_workspace_layout_screen_get(layout_new);
 		sc->state = state;
 		sc->redraws_flag = oldscreen->redraws_flag;
 		sc->temp = oldscreen->temp;
@@ -1704,7 +1578,7 @@ ScrArea *ED_screen_state_toggle(bContext *C, wmWindow *win, ScrArea *sa, const s
 			BLI_assert(false);
 		}
 
-		ED_screen_set(C, sc);
+		ED_screen_change(C, sc);
 	}
 
 	/* XXX bad code: setscreen() ends with first area active. fullscreen render assumes this too */
@@ -1850,7 +1724,7 @@ void ED_update_for_newframe(Main *bmain, Scene *scene, int UNUSED(mute))
 		scene->camera = camera;
 		/* are there cameras in the views that are not in the scene? */
 		for (sc = bmain->screen.first; sc; sc = sc->id.next) {
-			BKE_screen_view3d_scene_sync(sc);
+			BKE_screen_view3d_scene_sync(sc, scene);
 		}
 	}
 #endif
@@ -1879,11 +1753,10 @@ void ED_update_for_newframe(Main *bmain, Scene *scene, int UNUSED(mute))
 /*
  * return true if any active area requires to see in 3D
  */
-bool ED_screen_stereo3d_required(bScreen *screen)
+bool ED_screen_stereo3d_required(const bScreen *screen, const Scene *scene)
 {
 	ScrArea *sa;
-	Scene *sce = screen->scene;
-	const bool is_multiview = (sce->r.scemode & R_MULTIVIEW) != 0;
+	const bool is_multiview = (scene->r.scemode & R_MULTIVIEW) != 0;
 
 	for (sa = screen->areabase.first; sa; sa = sa->next) {
 		switch (sa->spacetype) {
@@ -1958,3 +1831,19 @@ bool ED_screen_stereo3d_required(bScreen *screen)
 
 	return false;
 }
+
+/**
+ * Find the scene displayed in \a screen.
+ * \note Assumes \a screen to be visible/active!
+ */
+Scene *ED_screen_scene_find(const bScreen *screen, const wmWindowManager *wm)
+{
+	for (wmWindow *win = wm->windows.first; win; win = win->next) {
+		if (WM_window_get_active_screen(win) == screen) {
+			return WM_window_get_active_scene(win);
+		}
+	}
+
+	BLI_assert(0);
+	return NULL;
+}