private static void CheckForFinishExitingFullscreen() { numChecksForFinishExiting++; if (windowController == IntPtr.Zero || numChecksForFinishExiting > 500) { EditorApplication.update -= CheckForFinishExitingFullscreen; } else { try { var isStillExitingFullscreen = SystemDisplay.MainWindowIsExitingFullscreen(); if (!isStillExitingFullscreen) { EditorApplication.update -= CheckForFinishExitingFullscreen; //Finished exiting fullscreen, so reset the window position. var fullscreenState = GetWindowFullscreenState(); var fullscreenOnDisplay = EditorDisplay.ClosestToPoint(fullscreenState.FullscreenAtPosition); fullscreenOnDisplay.Locked = false; var prePos = fullscreenState.PreFullscreenPosition; prePos.width = Mathf.Max(300, prePos.width); prePos.height = Mathf.Max(300, prePos.height); position = prePos; fullscreenState.currentlyRestoringFromState = false; FS.SaveFullscreenState(); } } catch (Exception e) { Debug.LogError(e); EditorApplication.update -= CheckForFinishExitingFullscreen; } } }
public static bool IsFullscreenAtPosition(Vector2 checkPosition) { var currentScreenBounds = EditorDisplay.ClosestToPoint(position.center).Bounds; var fullscreenBoundsAtCheckPosition = EditorDisplay.ClosestToPoint(checkPosition).Bounds; var fullscreenState = GetWindowFullscreenState(); return(fullscreenState.IsFullscreen && currentScreenBounds == fullscreenBoundsAtCheckPosition); }
/// <summary> Get the EditorDisplay which currently contains the fullscreen editorWindow </summary> internal static EditorDisplay GetFullscreenDisplay(this EditorWindow editorWindow) { var fullscreenState = EditorFullscreenState.FindWindowState(editorWindow); EditorDisplay display = null; if (fullscreenState != null) { display = EditorDisplay.ClosestToPoint(fullscreenState.FullscreenAtPosition); } return(display); }
/// <summary> /// Get an EditorDisplay from a SystemDisplay /// </summary> private static EditorDisplay FromSystemDisplay(SystemDisplay sys) { if (sys == null) { return(null); } EditorDisplay ed = new EditorDisplay(sys.Bounds); ed.PrimaryDisplay = sys.IsPrimary; return(ed); }
/// <summary> /// Get all the displays which are attached to the desktop (As a List) /// </summary> public static List <EditorDisplay> GetAllDisplays() { var allDisplays = new List <EditorDisplay>(); try { var desktopBounds = PrimaryDesktopResolution; //Find all the displays var display = AddDisplayAtPoint(allDisplays, desktopBounds.center, true); if (display != null) { AddContiguousDisplays(allDisplays, display); } } catch (Exception e) { Debug.LogError("Failed to find all possible displays. " + e); } if (allDisplays.Count == 0) { /*Failed to find the displays, so add the primary Screen as a display*/ var display = new EditorDisplay(new Rect(0, 0, Screen.currentResolution.width, Screen.currentResolution.height)); allDisplays.Add(display); } //Sort screens by top-left to bottom-right allDisplays.Sort(delegate(EditorDisplay a, EditorDisplay b) { bool aIsLess; if (a.Bounds.y != b.Bounds.y) { aIsLess = a.Bounds.y < b.Bounds.y; } else { if (a.Bounds.x == b.Bounds.x) { return(0); //Equal } else { aIsLess = a.Bounds.x < b.Bounds.x; } } return(aIsLess ? -1 : 1); }); return(allDisplays); }
/// <summary> /// Closes all fullscreen editor windows. /// </summary> /// <returns>True if at least one fullscreen window was closed.</returns> public static bool CloseAllEditorFullscreenWindows() { bool closedAtLeastOneFullscreen = false; int numOfClosedFullscreens = 0; EWFDebugging.LogLine("Closing all fullscreen windows."); try { var allWinStates = EditorFullscreenState.fullscreenState.window.ToArray(); foreach (var win in allWinStates) { if (win.EditorWin != null && win.WindowType != EditorFullscreenState.MainWindowType) { if (win.IsFullscreen) { closedAtLeastOneFullscreen = true; if (EditorDisplay.ClosestToPoint(win.FullscreenAtPosition).Locked) { EditorFullscreenState.RunAfterDisplayNotLocked(win.FullscreenAtPosition, () => CloseAllEditorFullscreenWindows()); return(true); } if (settings.debugModeEnabled) { EWFDebugging.Log("Closing fullscreen for window, title: " + win.WindowTitle + " type: " + win.WindowType + " FullscreenAtPosition: " + win.FullscreenAtPosition + " Fullscreen in Bounds: " + win.ScreenBounds); } win.EditorWin.SetFullscreen(false); win.containerWindow = null; win.EditorWin = null; //Causes the fullscreen state to be removed in CleanDeletedWindows(); numOfClosedFullscreens++; } } } } catch (Exception e) { EWFDebugging.LogError("Error when closing all fullscreen windows: " + e.Message); } if (EditorMainWindow.IsFullscreen()) { closedAtLeastOneFullscreen = true; numOfClosedFullscreens++; EWFDebugging.Log("Closing main window fullscreen."); } EditorMainWindow.SetFullscreen(false); EditorFullscreenState.fullscreenState.CleanDeletedWindows(); EditorFullscreenState.TriggerFullscreenEvent(null, null, Vector2.zero, closedAtLeastOneFullscreen); EWFDebugging.LogLine("numOfClosedFullscreens: " + numOfClosedFullscreens); return(closedAtLeastOneFullscreen); }
private static EditorDisplay AddDisplayAtPoint(List <EditorDisplay> allDisplays, Vector2 point, bool primaryDisplay) { if (!allDisplays.Exists(d => d.Bounds.Contains(point))) { var displayBounds = GetBoundsOfDesktopAtPoint(point); if (!allDisplays.Exists(d => d.Bounds == displayBounds)) { var foundDisplay = new EditorDisplay(displayBounds); foundDisplay.PrimaryDisplay = primaryDisplay; allDisplays.Add(foundDisplay); return(foundDisplay); } } return(null); }
/// <summary> Exit fullscreen for other windows on the screen at the specified position. Returns true if at least one fullscreen was closed. </summary> public static bool ExitFullscreenForOtherWindowsOnScreen(this EditorWindow editorWindow, Vector2 screenAtPosition) { bool closedAFullscreen = false; var allWinStates = FS.fullscreenState.window.ToArray(); EditorDisplay display = EditorDisplay.ClosestToPoint(screenAtPosition); foreach (var win in allWinStates) { if (win.IsFullscreen && win.EditorWin != null && win.EditorWin != editorWindow && win.EditorWin.IsFullscreenOnDisplay(display)) { win.EditorWin.SetFullscreen(false); closedAFullscreen = true; } } return(closedAFullscreen); }
public static bool ToggleFullscreen(bool showTopToolbar, Vector2 fullscreenAtPosition) { var fullscreenState = GetWindowFullscreenState(); var currentScreenBounds = EditorDisplay.ClosestToPoint(position.center).Bounds; var newFullscreenBounds = EditorDisplay.ClosestToPoint(fullscreenAtPosition).Bounds; bool setFullscreen = !fullscreenState.IsFullscreen || currentScreenBounds != newFullscreenBounds; if (EditorWindowExtensions.ExitFullscreenForOtherWindowsOnScreen(fullscreenState.EditorWin, fullscreenAtPosition)) { setFullscreen = true; } SetFullscreen(setFullscreen, showTopToolbar, fullscreenAtPosition); return(setFullscreen); }
/// <summary> Make the EditorWindow into a fullscreen window, with the option to show the top tabs. Opens the fullscreen window on the screen at a specified position. </summary> private static Rect MakeFullscreenWindow(this EditorWindow editorWindow, bool hideTopToolbar, Vector2 atPosition) { var winRect = EditorDisplay.ClosestToPoint(atPosition).Bounds; if (hideTopToolbar == true) { /*Move the top tab off the screen*/ winRect.y -= FS.topTabFullHeight; winRect.height += FS.topTabFullHeight; } editorWindow.SetBorderlessPosition(winRect, hideTopToolbar); #if UNITY_STANDALONE_WIN //Fix positioning bug when monitors have differing scale var sysDisplays = SystemDisplay.GetAllDisplays(); var fullscreenDisp = sysDisplays.ClosestToPoint(atPosition); var mainWindowDisp = sysDisplays.WithMainWindow(); if (fullscreenDisp != mainWindowDisp) { //Check if there is a scaling difference between the main window display and the fullscreen display. float fullscreenDispScale = fullscreenDisp.PixelWidth / fullscreenDisp.Bounds.width; float mainWindowDispScale = mainWindowDisp.PixelWidth / mainWindowDisp.Bounds.width; if (fullscreenDispScale != mainWindowDispScale) { //There is a scaling difference, so adjust the winRect to account for the scaling. (Because the window is positioned based on the scaling of the main window display). float relativeScale = fullscreenDispScale / mainWindowDispScale; winRect.x = winRect.x * relativeScale; winRect.y = winRect.y * relativeScale; winRect.width = winRect.width * relativeScale; winRect.height = winRect.height * relativeScale; } editorWindow.SetBorderlessPosition(winRect, hideTopToolbar); //Call system SetWindowPosition to make sure the window covers the taskbar SystemDisplay.MakeWindowCoverTaskBar(editorWindow.GetWindowTitle(), fullscreenDisp); //Hide the top toolbar if necessary. editorWindow.SetToolbarVisibilityAtPos(winRect, hideTopToolbar, false); } #endif return(winRect); }
private static float GetPixelsPerPointAtPosition(Vector2 atPosition) { var screenBounds = EditorDisplay.ClosestToPoint(atPosition).Bounds; //Use a dummy scene view to get the real pixels per point (Because EditorGUIUtility.pixelsPerPoint is inconsistent). var dummySceneView = EditorWindowExtensions.CreateWindow(typeof(SceneView)); dummySceneView.SetFullscreen(true, atPosition, false); var pixelsPerPoint = screenBounds.width / dummySceneView.position.width; dummySceneView.SetFullscreen(false); if (dummySceneView != null) { dummySceneView.Close(); } if (dummySceneView != null) { UnityEngine.Object.DestroyImmediate(dummySceneView); } return(pixelsPerPoint); }
/// <summary> /// Get the display containing or closest to the specified point. /// </summary> public static EditorDisplay ClosestToPoint(Vector2 point) { float closestDistance = 0; EditorDisplay closestDisplay = null; foreach (EditorDisplay display in AllDisplays) { if (display.Bounds.Contains(point)) { return(display); } var dist = display.Bounds.DistanceToPoint(point); if (dist < closestDistance || closestDisplay == null) { closestDistance = dist; closestDisplay = display; } } return(closestDisplay); }
private static void AddContiguousDisplays(List <EditorDisplay> allDisplays, EditorDisplay display) { int searchDistance = 2700; //Other displays which are scaled may not be touching the display's bounds. So search a distance outside the display. int x, y, halfStep = 150, step = 300; EditorDisplay newDisplay; for (y = -searchDistance - halfStep; y < display.Bounds.height * 2 + step; y += step) //Display could be scaled up to 175% so check 2x height { newDisplay = AddDisplayAtPoint(allDisplays, new Vector2(-halfStep, y)); if (newDisplay != null) { AddContiguousDisplays(allDisplays, newDisplay); } newDisplay = AddDisplayAtPoint(allDisplays, new Vector2(display.Bounds.width + halfStep, y)); if (newDisplay != null) { AddContiguousDisplays(allDisplays, newDisplay); } } searchDistance = 5400; for (x = -searchDistance - halfStep; x < display.Bounds.width * 2 + step; x += step) { newDisplay = AddDisplayAtPoint(allDisplays, new Vector2(x, -halfStep)); if (newDisplay != null) { AddContiguousDisplays(allDisplays, newDisplay); } newDisplay = AddDisplayAtPoint(allDisplays, new Vector2(x, display.Bounds.height + halfStep)); if (newDisplay != null) { AddContiguousDisplays(allDisplays, newDisplay); } } }
/// <summary> Returns true if the EditorWindow is currently fullscreen on the screen at a position </summary> public static bool IsFullscreenOnDisplay(this EditorWindow editorWindow, EditorDisplay display) { Rect containerPosition = editorWindow.GetContainerPosition(); return(containerPosition.Contains(display.Bounds) && display.Bounds.width == containerPosition.width); }
/// <summary> /// Triggers a Fullscreen Hotkey. /// </summary> /// <param name="keyCode">The key code of the hotkey to be triggered.</param> /// <param name="modifiers">The modifiers of the hotkey to be triggered.</param> /// <returns></returns> internal static bool TriggerFullscreenHotkey(KeyCode keyCode, EventModifiers modifiers) { if (EditorInput.performedHotkeyActionThisUpdate) { return(false); //Already triggered the hotkey } EWFDebugging.Begin(); bool setFullscreen = false; bool fullscreenHotkeyTriggered = true; var settings = EditorFullscreenSettings.settings; if (settings.debugModeEnabled) { EWFDebugging.LogLine("Triggered hotkey: " + EditorInput.GetKeysDownString(keyCode, modifiers) + " (key " + keyCode.ToKeyString() + " modifiers " + modifiers.ToString() + ")"); } EditorDisplay.ClearCachedDisplays(); EWFDebugging.StartTimer("Check hotkey and fullscreen"); if (CheckHotkeyTriggered(keyCode, modifiers, settings.closeAllFullscreenWindows)) { setFullscreen = CloseAllEditorFullscreenWindows(); //In this case setFullscreen is set to true if at least one fullscreen was closed. } else if (CheckHotkeyTriggered(keyCode, modifiers, settings.mainUnityWindow)) { setFullscreen = ToggleMainWindowFullscreen(); } else if (CheckHotkeyTriggered(keyCode, modifiers, settings.sceneWindow)) { setFullscreen = ToggleSceneViewFullscreen(); } else if (CheckHotkeyTriggered(keyCode, modifiers, settings.gameWindow)) { setFullscreen = ToggleGameViewFullscreen(false, settings.gameWindow.OptionID); } else if (CheckHotkeyTriggered(keyCode, modifiers, settings.currentlyFocusedWindow)) { setFullscreen = ToggleFocusedWindowFullscreen(); } else if (CheckHotkeyTriggered(keyCode, modifiers, settings.windowUnderCursor)) { setFullscreen = ToggleWindowUnderCursorFullscreen(); } else if (CheckHotkeyTriggered(keyCode, modifiers, settings.toggleTopToolbar)) { ToggleTopToolbar(); } else { fullscreenHotkeyTriggered = false; //Check if a custom window hotkey is triggered if (settings.customWindows != null) { for (int i = 0; i < settings.customWindows.Count; i++) { if (CheckHotkeyTriggered(keyCode, modifiers, settings.customWindows[i])) { if (settings.customWindows[i].isGameView) { setFullscreen = ToggleGameViewFullscreen(false, settings.customWindows[i].OptionID); } else { setFullscreen = EditorFullscreenState.ToggleFullscreenUsingOptions(settings.customWindows[i].WindowType, settings.customWindows[i]); } fullscreenHotkeyTriggered = true; break; } } } } EWFDebugging.LogTime("Check hotkey and fullscreen"); if (fullscreenHotkeyTriggered) { triggeredHotkey = null; //Reset the triggered hotkey after fullscreen is toggled. } if (FullscreenHotkeyEventHandler != null && fullscreenHotkeyTriggered) { FullscreenHotkeyEventHandler.Invoke(keyCode, modifiers, setFullscreen); } EWFDebugging.LogLine("fullscreenHotkeyTriggered: " + fullscreenHotkeyTriggered + ", setFullscreen: " + setFullscreen); if (fullscreenHotkeyTriggered) { EWFDebugging.PrintLog(); EditorInput.performedHotkeyActionThisUpdate = true; } return(fullscreenHotkeyTriggered); }
/// <summary> Make the EditorWindow fullscreen, or return to how it was. Opens the fullscreen window on the screen at a specified position. </summary> public static void SetFullscreen(this EditorWindow editorWindow, bool setFullscreen, Vector2 atPosition) { Type windowType = editorWindow.GetWindowType(); var fullscreenState = EditorFullscreenState.FindWindowState(editorWindow); CursorLockMode currentCursorLockMode = Cursor.lockState; if (setFullscreen == false) { if (fullscreenState.EditorWin != null) { if (fullscreenState.CloseOnExitFullscreen) { //Close the window editorWindow.Close(); } else { //Restore the window editorWindow.SetBorderlessPosition(fullscreenState.PreFullscreenPosition); fullscreenState.EditorWin.minSize = fullscreenState.PreFullscreenMinSize; fullscreenState.EditorWin.maxSize = fullscreenState.PreFullscreenMaxSize; fullscreenState.EditorWin.position = fullscreenState.PreFullscreenPosition; if (editorWindow.maximized != fullscreenState.PreFullscreenMaximized) { editorWindow.maximized = fullscreenState.PreFullscreenMaximized; } } } if (editorWindow.GetWindowType() == FS.gameViewType) { Unsupported.SetAllowCursorLock(false); //Unlock the cursor when exiting game fullscreen } if (fullscreenState.UnfocusedGameViewOnEnteringFullscreen == true) { //Refocus the first docked game view var gameView = GetDockedGameView(editorWindow, false); if (gameView != null) { gameView.Focus(); } } } else { if (!fullscreenState.IsFullscreen) { fullscreenState.PreFullscreenPosition = editorWindow.position; fullscreenState.PreFullscreenPosition.y -= FS.windowTopPadding; fullscreenState.PreFullscreenMinSize = editorWindow.minSize; fullscreenState.PreFullscreenMaxSize = editorWindow.maxSize; fullscreenState.PreFullscreenMaximized = editorWindow.maximized; } editorWindow.SetWindowTitle("FULLSCREEN_WINDOW_" + editorWindow.GetInstanceID(), true); if (!editorWindow.IsFullscreen()) { editorWindow.maximized = false; if (fullscreenState.ShowTopTabs) { editorWindow.Show(); } else { editorWindow.ShowWithMode(ShowMode.PopupMenu); editorWindow.SetSaveToLayout(true); } fullscreenState.FullscreenAtPosition = atPosition; editorWindow.SetBorderlessPosition(new Rect(atPosition.x, atPosition.y, 100, 100)); } else if (fullscreenState.IsFullscreen) { //If already fullscreen, resize slightly to make sure the taskbar gets covered (E.g. when loading fullscreen state on startup) var tempBounds = editorWindow.position; tempBounds.yMax -= 1; editorWindow.SetBorderlessPosition(tempBounds); } fullscreenState.ScreenBounds = editorWindow.MakeFullscreenWindow(!fullscreenState.ShowTopToolbar, atPosition); editorWindow.ExitFullscreenForOtherWindowsOnScreen(atPosition); fullscreenState.WindowName = editorWindow.name; fullscreenState.EditorWin = editorWindow; fullscreenState.IsFullscreen = true; //Usability improvement for Unity bug where only one visible game window accepts input. (Unfocus docked game views if opening fullscreen view on the same screen.) try { var gameView = GetDockedGameView(editorWindow, true); if (gameView != null) { bool onSameDisplay = EditorDisplay.ClosestToPoint(gameView.position.center).Bounds.Contains(atPosition); var hostView = gameView.GetHostView(); if (onSameDisplay && hostView != null && FS.dockAreaType != null) { FieldInfo m_Panes = FS.dockAreaType.GetField("m_Panes", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); var dockAreaPanes = (List <EditorWindow>)m_Panes.GetValue(hostView); foreach (var sibling in dockAreaPanes) { if (sibling.GetType() != FS.gameViewType) { sibling.Focus(); //Focus the first non-game sibling of the docked game view fullscreenState.UnfocusedGameViewOnEnteringFullscreen = true; break; } } } } } catch (System.Exception e) { if (FS.LogNonFatalErrors) { Debug.LogException(e); } } editorWindow.Focus(); Cursor.lockState = currentCursorLockMode; //Ensure that the cursor lock mode remains the same when entering fullscreen } FS.SaveFullscreenState(); FS.TriggerFullscreenEvent(editorWindow, windowType, atPosition, setFullscreen); }
public static WindowFullscreenState FindWindowState(EditorWindow editorWin, System.Type windowType, EditorDisplay editorDisplay) { WindowFullscreenState winState = null; Type actualType = windowType; windowType = GetWindowType(actualType); try { if (editorWin != null) { winState = fullscreenState.window.Find(state => state.EditorWin == editorWin && (editorDisplay == null || state.EditorWin.GetFullscreenDisplay().Bounds.Equals(editorDisplay.Bounds))); } else { winState = fullscreenState.window.Find(state => (state.EditorWin != null || state.containerWindow != null) && state.WindowType == windowType && (editorDisplay == null || state.EditorWin != null && state.EditorWin.GetFullscreenDisplay() != null && state.EditorWin.GetFullscreenDisplay().Bounds.Equals(editorDisplay.Bounds))); } } catch (System.Exception e) { if (LogNonFatalErrors) { Debug.LogError("Error attempting to find window state."); Debug.LogException(e); } } if (winState == null) { winState = AddWindowState(editorWin, windowType, actualType); } return(winState); }
public static void SetFullscreen(bool fullscreen, bool showTopToolbar, Vector2 fullscreenAtPosition, bool disableUpdatePrePos) { var fullscreenState = GetWindowFullscreenState(); var fullscreenOnDisplay = EditorDisplay.ClosestToPoint(fullscreenAtPosition); var screenBounds = fullscreenOnDisplay.Bounds; #if UNITY_EDITOR_OSX if (fullscreenOnDisplay.Locked) { FS.RunAfterDisplayNotLocked(fullscreenAtPosition, () => SetFullscreen(fullscreen, showTopToolbar, fullscreenAtPosition, disableUpdatePrePos)); return; } #endif var originallyFocusedEditorWin = EditorWindow.focusedWindow; var originallyFocusedEditorWinType = originallyFocusedEditorWin == null ? null : originallyFocusedEditorWin.GetType(); object mainWindow = null; #if UNITY_EDITOR_OSX bool wasFullscreen = SystemDisplay.MainWindowIsFullscreen(); //If toggling the top toolbar, don't update pre positions. bool updatePrePos = fullscreen && !wasFullscreen && !disableUpdatePrePos; windowController = IntPtr.Zero; if (fullscreen) { fullscreenState.ScreenBounds = screenBounds; fullscreenState.FullscreenAtPosition = fullscreenAtPosition; } if (updatePrePos) { fullscreenState.PreFullscreenPosition = position; fullscreenState.PreFullscreenMinSize = minSize; fullscreenState.PreFullscreenMaxSize = maxSize; } var prePos = fullscreenState.PreFullscreenPosition; if (prePos.width < 100 || prePos.height < 100 || prePos.width < fullscreenState.PreFullscreenMinSize.x || prePos.height < fullscreenState.PreFullscreenMinSize.y) { prePos = new Rect(prePos.x, prePos.y, Mathf.Max(fullscreenState.PreFullscreenMinSize.x, 300), Mathf.Max(fullscreenState.PreFullscreenMinSize.y, 300)); //Make sure size is valid } if (fullscreen && !screenBounds.Contains(position.center)) { if (wasFullscreen) { //Exit fullscreen because we are fullscreen on another screen fullscreen = false; } else { //Move to the correct screen SystemDisplay.SetMainWindowPosition((int)screenBounds.xMin, (int)screenBounds.yMin, (int)screenBounds.width, (int)screenBounds.height); } } if (fullscreen != wasFullscreen) { windowController = SystemDisplay.ToggleFullscreenMainWindow((int)prePos.xMin, (int)prePos.yMin, (int)prePos.width, (int)prePos.height); if (!fullscreen) { if (fullscreenState.ScreenBounds.Contains(prePos)) { position = prePos; //Setting the position here first (even though still haven't finished exiting fullscreen) updates the docked window sizes so the shrinking animation is smoother. } else { var intermediatePos = fullscreenState.PreFullscreenPosition.CenterRectInBounds(fullscreenState.ScreenBounds); position = intermediatePos; //Can't move screen yet because still fullscreen, so use an intermediate pos. } //Restore position once the fullscreen has finished exiting if (windowController != IntPtr.Zero) { fullscreenOnDisplay.Locked = true; EditorApplication.update += CheckForFinishExitingFullscreen; numChecksForFinishExiting = 0; } } else { fullscreenOnDisplay.Locked = true; FS.RunAfter(() => { return(false); }, () => { fullscreenOnDisplay.Locked = false; fullscreenState.currentlyRestoringFromState = false; FS.SaveFullscreenState(); }, 50, true); } } fullscreenState.IsFullscreen = fullscreen; FS.SaveFullscreenState(); #else bool wasFullscreen = fullscreenState.IsFullscreen; fullscreenState.ShowTopToolbar = showTopToolbar; fullscreenState.originalContainerWindow = (ScriptableObject)FindOriginalContainerWindow(); fullscreenState.containerWindow = (ScriptableObject)FindContainerWindow(); mainWindow = FindMainWindow(); bool inOriginalContainer = fullscreenState.containerWindow == fullscreenState.originalContainerWindow; #if UNITY_2018_2_OR_NEWER var pixelsPerPoint = GetPixelsPerPointAtPosition(fullscreenAtPosition); screenBounds.width /= pixelsPerPoint; screenBounds.height /= pixelsPerPoint; #endif if (fullscreen) { fullscreenState.ScreenBounds = screenBounds; fullscreenState.FullscreenAtPosition = fullscreenAtPosition; if (!wasFullscreen) { var wasMaximized = maximized; if (wasMaximized) { ToggleMaximize(); } fullscreenState.PreFullscreenPosition = position; fullscreenState.PreFullscreenMinSize = minSize; fullscreenState.PreFullscreenMaxSize = maxSize; fullscreenState.PreFullscreenMaximized = wasMaximized; if (inOriginalContainer) { SystemDisplay.SaveMainWindowStyleInState(fullscreenState); } } } if (fullscreen && !showTopToolbar) { object fsContainerWindow; if (inOriginalContainer) { fsContainerWindow = ScriptableObject.CreateInstance(FS.ContainerWindowType); } else { fsContainerWindow = fullscreenState.containerWindow; } //Put the main view into the fullscreen container window containerMainView.SetValue(fsContainerWindow, mainWindow, null); inOriginalContainer = false; containerPosition.SetValue(fsContainerWindow, screenBounds, null); if (containerShow.GetParameters().Length == 3) { containerShow.Invoke(fsContainerWindow, new object[] { 3, false, true }); } else if (containerShow.GetParameters().Length == 4) { containerShow.Invoke(fsContainerWindow, new object[] { 3, false, true, true }); //4 parameters since Unity 2018 } SetMinMaxSizes(screenBounds.size, screenBounds.size); containerPosition.SetValue(fsContainerWindow, screenBounds, null); MethodInfo displayAllViews = FS.ContainerWindowType.GetMethod("DisplayAllViews", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, new System.Type[] { }, null); displayAllViews.Invoke(fsContainerWindow, null); fullscreenState.containerWindow = (ScriptableObject)fsContainerWindow; fullscreenState.IsFullscreen = true; } else { if (fullscreenState.EditorWin != null) { fullscreenState.EditorWin.Close(); } if (!inOriginalContainer) { //Reset main view back to original container view containerMainViewField.SetValue(fullscreenState.originalContainerWindow, null); containerMainView.SetValue(fullscreenState.originalContainerWindow, mainWindow, null); try { containerMainViewField.SetValue(fullscreenState.containerWindow, null); containerClose.Invoke(fullscreenState.containerWindow, null); } catch (System.Exception e) { if (EWFDebugging.Enabled) { Debug.LogException(e); EWFDebugging.LogError(e.Message); } } fullscreenState.containerWindow = fullscreenState.originalContainerWindow; fullscreenState.IsFullscreen = false; inOriginalContainer = true; } if (fullscreen) { //Set fullscreen with toolbar var newPos = screenBounds; newPos.yMin += topToolbarHeight; position = newPos; SetMinMaxSizes(newPos.size, newPos.size); position = newPos; if (position.x != newPos.x) { //Position didn't set correctly, so must be maximized fullscreenState.PreFullscreenMaximized = true; ToggleMaximize(); position = newPos; } fullscreenState.IsFullscreen = true; } } if (!fullscreen && inOriginalContainer && wasFullscreen) { //Reset position var prePos = fullscreenState.PreFullscreenPosition; position = prePos; fullscreenState.IsFullscreen = false; position = fullscreenState.PreFullscreenPosition; SetMinMaxSizes(fullscreenState.PreFullscreenMinSize, fullscreenState.PreFullscreenMaxSize); position = fullscreenState.PreFullscreenPosition; PropertyInfo pos = FS.ViewType.GetProperty("position", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); pos.SetValue(FindMainWindow(), fullscreenState.PreFullscreenPosition, null); fullscreenState.IsFullscreen = false; SystemDisplay.LoadMainWindowStyleInState(fullscreenState, true); TriggerOnResizedAll(); Focus(); position = fullscreenState.PreFullscreenPosition; //Reset position position = fullscreenState.PreFullscreenPosition; if (fullscreenState.PreFullscreenMaximized != maximized) { ToggleMaximize(); } } fullscreenState.currentlyRestoringFromState = false; FS.SaveFullscreenState(); #endif //All platforms FS.TriggerFullscreenEvent(mainWindow, FS.MainWindowType, fullscreenAtPosition, fullscreen); if (EditorWindow.focusedWindow == null) { if (originallyFocusedEditorWin != null) { originallyFocusedEditorWin.Focus(); } else if (originallyFocusedEditorWinType != null) { EditorWindow.FocusWindowIfItsOpen(originallyFocusedEditorWinType); } } }
internal static void LoadFullscreenState() { try { string fullscreenStateData = File.ReadAllText(Path.Combine(projectLibraryPath, FullscreenStateFilename)); fullscreenState = SerializerUtility.Deserialize <FullscreenState>(fullscreenStateData); } catch (FileNotFoundException) { } catch (System.Exception e) { Debug.LogException(e); } if (fullscreenState.window == null) { fullscreenState.window = new List <WindowFullscreenState>(); } var allFullscreenStates = fullscreenState.window.ToArray(); WindowFullscreenState mainWindowFullscreenState = null; //Load types from assembly qualified names foreach (var state in allFullscreenStates) { try { state.ActualType = Type.GetType(state.actualTypeAssemblyQualifiedName); state.WindowType = Type.GetType(state.windowTypeAssemblyQualifiedName); } catch (System.Exception e) { if (LogNonFatalErrors) { Debug.LogException(e); } } } //Re-assign recreated window instances to their fullscreen states var allWins = Resources.FindObjectsOfTypeAll <EditorWindow>(); var unassignedFullscreenWins = new List <EditorWindow>(); foreach (var win in allWins) { if (win.GetShowMode() == EditorWindowExtensions.ShowMode.PopupMenu) { unassignedFullscreenWins.Add(win); } } foreach (var state in allFullscreenStates) { if (state.EditorWin != null) { unassignedFullscreenWins.Remove(state.EditorWin); } else if (state.WindowType == mainWindowType) { mainWindowFullscreenState = state; } else if (state.IsFullscreen) { foreach (var win in unassignedFullscreenWins) { var containerPosition = win.GetContainerPosition(); if (win.GetType() == state.ActualType && containerPosition.x == state.ContainerPosition.x && containerPosition.y == state.ContainerPosition.y) { state.EditorWin = win; unassignedFullscreenWins.Remove(win); break; } } } } loadedInitialState = true; //Find the window which was focused var focusedWindow = fullscreenState.window.Find(state => state.HasFocus == true); //Remake fullscreen windows foreach (var state in allFullscreenStates) { if (state.IsFullscreen) { if (state.EditorWin != null) { state.EditorWin.SetFullscreen(true, state.FullscreenAtPosition); } else if (state.WindowType != mainWindowType) { ToggleFullscreen(state.ActualType, true, state.FullscreenAtPosition, state.ShowTopToolbar, state.CreatedAtGameStart); } } } //Recreate the main window fullscreen state if (mainWindowFullscreenState != null && mainWindowFullscreenState.IsFullscreen) { var atPosition = mainWindowFullscreenState.FullscreenAtPosition; var showTopToolbar = mainWindowFullscreenState.ShowTopToolbar; if (mainWindowFullscreenState.containerWindow == null || mainWindowFullscreenState.originalContainerWindow == null) { fullscreenState.window.Remove(mainWindowFullscreenState); //Remove the old fullscreen state because the originalContainer needs to be reset } EditorMainWindow.SetFullscreen(true, showTopToolbar, atPosition); } //Remove fullscreen popup windows which don't have a fullscreen state foreach (var win in unassignedFullscreenWins) { if (win != null) { if (win.GetContainerWindow() != null) { win.Close(); } else { UnityEngine.Object.DestroyImmediate(win, true); } } } fullscreenState.CleanDeletedWindows(); //Bring any fullscreen window which is on top of the main window to the front. try { var windowOverMain = fullscreenState.window.Find(state => state.IsFullscreen && state.EditorWin != null && EditorDisplay.ClosestToPoint(state.FullscreenAtPosition).Bounds == EditorDisplay.ClosestToPoint(EditorMainWindow.position.center).Bounds); if (windowOverMain != null) { GiveFocusAndBringToFront(windowOverMain.EditorWin); } } catch { } //Refocus the window which was previously focused if (focusedWindow != null && focusedWindow.EditorWin != null) { GiveFocusAndBringToFront(focusedWindow.EditorWin); } //Toggle fullscreen for states which were queued up before load was complete foreach (var state in queuedStatesToToggleOnLoad) { ToggleFullscreen(state.ActualType, state.CloseOnExitFullscreen, state.FullscreenAtPosition, state.ShowTopToolbar, state.CreatedAtGameStart); } queuedStatesToToggleOnLoad.Clear(); if (RunOnNextLoadMethods != null) { RunOnNextLoadMethods.Invoke(); RunOnNextLoadMethods = null; } }
/// <summary> Returns true if the EditorWindow is currently fullscreen on the screen at a position </summary> public static bool IsFullscreen(this EditorWindow editorWindow, Vector2 atPosition) { var fullscreenState = EditorFullscreenState.FindWindowState(editorWindow); return(fullscreenState.IsFullscreen && editorWindow.IsFullscreenOnDisplay(EditorDisplay.ClosestToPoint(atPosition))); }
/// <summary> Toggle fullscreen for a window type </summary> public static bool ToggleFullscreen(Type windowType, bool createNewWindow, Vector2 atPosition, bool showTopToolbar, bool triggeredOnPlayStateChange) { var windowState = EditorFullscreenState.FindWindowState(null, windowType, EditorDisplay.ClosestToPoint(atPosition)); if (showTopToolbar) { windowState.ShowTopToolbar = true; } if (triggeredOnPlayStateChange && !windowState.IsFullscreen) { windowState.CreatedAtGameStart = true; } return(ToggleFullscreen(windowState, createNewWindow, atPosition)); }
/// <summary> /// Get all the displays which are attached to the desktop (As a List) /// </summary> public static List <EditorDisplay> GetAllDisplays() { EWFDebugging.StartTimer("GetAllDisplays"); List <EditorDisplay> allDisplays = new List <EditorDisplay>(); try { #if UNITY_EDITOR_OSX //Get system displays allDisplays = FromSystemDisplays(SystemDisplay.GetAllDisplays()); #else allDisplays = FromSystemDisplays(SystemDisplay.GetAllDisplays()); //If couldn't find system displays, use backup method if (allDisplays == null || allDisplays.Count < 1) { var desktopBounds = PrimaryDesktopResolution; allDisplays = new List <EditorDisplay>(); //Find all the displays var display = AddDisplayAtPoint(allDisplays, desktopBounds.center, true); if (display != null) { AddContiguousDisplays(allDisplays, display); } } #endif } catch (Exception e) { if (EWFDebugging.Enabled) { string err = "Failed to find all possible displays. " + e; Debug.LogError(err); EWFDebugging.LogError(err); } } if (allDisplays.Count == 0) { /*Failed to find the displays, so add the primary Screen as a display*/ var display = new EditorDisplay(new Rect(0, 0, Screen.currentResolution.width, Screen.currentResolution.height)); allDisplays.Add(display); } //Sort screens by top-left to bottom-right allDisplays.Sort(delegate(EditorDisplay a, EditorDisplay b) { bool aIsLess; if (a.Bounds.y != b.Bounds.y) { aIsLess = a.Bounds.y < b.Bounds.y; } else { if (a.Bounds.x == b.Bounds.x) { return(0); //Equal } else { aIsLess = a.Bounds.x < b.Bounds.x; } } return(aIsLess ? -1 : 1); }); EWFDebugging.LogTime("GetAllDisplays", false); EditorDisplay.allDisplays = allDisplays; return(allDisplays); }
public static void SetFullscreen(bool fullscreen, bool showTopToolbar, Vector2 fullscreenAtPosition) { var originallyFocusedEditorWin = EditorWindow.focusedWindow; var originallyFocusedEditorWinType = originallyFocusedEditorWin == null ? null : originallyFocusedEditorWin.GetType(); var fullscreenState = GetWindowFullscreenState(); bool wasFullscreen = fullscreenState.IsFullscreen; fullscreenState.ShowTopToolbar = showTopToolbar; fullscreenState.originalContainerWindow = (ScriptableObject)FindOriginalContainerWindow(); fullscreenState.containerWindow = (ScriptableObject)FindContainerWindow(); object mainWindow = FindMainWindow(); bool inOriginalContainer = fullscreenState.containerWindow == fullscreenState.originalContainerWindow; var screenBounds = EditorDisplay.ClosestToPoint(fullscreenAtPosition).Bounds; if (fullscreen) { fullscreenState.ScreenBounds = screenBounds; fullscreenState.FullscreenAtPosition = fullscreenAtPosition; if (!wasFullscreen) { var wasMaximized = maximized; if (wasMaximized) { ToggleMaximize(); } fullscreenState.PreFullscreenPosition = position; fullscreenState.PreFullscreenMinSize = minSize; fullscreenState.PreFullscreenMaxSize = maxSize; fullscreenState.PreFullscreenMaximized = wasMaximized; } } if (fullscreen && !showTopToolbar) { object fsContainerWindow; if (inOriginalContainer) { fsContainerWindow = ScriptableObject.CreateInstance(FS.containerWindowType); } else { fsContainerWindow = fullscreenState.containerWindow; } //Custom toolbar //int toolbarHeight = 18; //fullscreenState.EditorWin = MainWindowMenu.Create(new Rect(newPos.xMin, newPos.yMin, newPos.width, toolbarHeight)); //newPos.yMin += toolbarHeight; //Put the main view into the fullscreen container window containerMainView.SetValue(fsContainerWindow, mainWindow, null); inOriginalContainer = false; containerPosition.SetValue(fsContainerWindow, screenBounds, null); containerShow.Invoke(fsContainerWindow, new object[] { 3, false, true }); SetMinMaxSizes(screenBounds.size, screenBounds.size); containerPosition.SetValue(fsContainerWindow, screenBounds, null); MethodInfo displayAllViews = FS.containerWindowType.GetMethod("DisplayAllViews", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, new System.Type[] { }, null); displayAllViews.Invoke(fsContainerWindow, null); fullscreenState.containerWindow = (ScriptableObject)fsContainerWindow; fullscreenState.IsFullscreen = true; } else { if (fullscreenState.EditorWin != null) { fullscreenState.EditorWin.Close(); } if (!inOriginalContainer) { //Reset main view back to original container view containerMainViewField.SetValue(fullscreenState.originalContainerWindow, null); containerMainView.SetValue(fullscreenState.originalContainerWindow, mainWindow, null); try { containerMainViewField.SetValue(fullscreenState.containerWindow, null); containerClose.Invoke(fullscreenState.containerWindow, null); } catch (System.Exception e) { if (FS.LogNonFatalErrors) { Debug.LogException(e); } } fullscreenState.containerWindow = fullscreenState.originalContainerWindow; fullscreenState.IsFullscreen = false; inOriginalContainer = true; } if (fullscreen) { //Set fullscreen with toolbar var newPos = screenBounds; newPos.yMin += topToolbarHeight; position = newPos; SetMinMaxSizes(newPos.size, newPos.size); position = newPos; if (position.x != newPos.x) { //Position didn't set correctly, so must be maximized fullscreenState.PreFullscreenMaximized = true; ToggleMaximize(); position = newPos; } fullscreenState.IsFullscreen = true; } } if (!fullscreen && inOriginalContainer && wasFullscreen) { //Reset position position = fullscreenState.PreFullscreenPosition; SetMinMaxSizes(fullscreenState.PreFullscreenMinSize, fullscreenState.PreFullscreenMaxSize); position = fullscreenState.PreFullscreenPosition; PropertyInfo pos = FS.viewType.GetProperty("position", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); pos.SetValue(FindMainWindow(), fullscreenState.PreFullscreenPosition, null); fullscreenState.IsFullscreen = false; //Save and reload temporary layout, to fix resizable main window var fsSaveToLayout = new Dictionary <FS.WindowFullscreenState, bool>(); var allWinStates = FS.fullscreenState.window.ToArray(); foreach (var state in allWinStates) { if (state.EditorWin != null) { fsSaveToLayout.Add(state, state.EditorWin.GetSaveToLayout()); state.EditorWin.SetSaveToLayout(true); } } FS.SaveFullscreenState(); WindowLayoutUtility.SaveProjectLayout("PostFullscreenLayout.dwlt"); foreach (var state in fsSaveToLayout) { if (state.Key.EditorWin != null) { state.Key.EditorWin.SetSaveToLayout(state.Value); } } WindowLayoutUtility.LoadProjectLayout("PostFullscreenLayout.dwlt"); Focus(); position = fullscreenState.PreFullscreenPosition; //Reset position position = fullscreenState.PreFullscreenPosition; if (fullscreenState.PreFullscreenMaximized != maximized) { ToggleMaximize(); } FS.LoadFullscreenState(); } FS.SaveFullscreenState(); FS.TriggerFullscreenEvent(mainWindow, FS.mainWindowType, fullscreenAtPosition, fullscreen); if (EditorWindow.focusedWindow == null) { if (originallyFocusedEditorWin != null) { originallyFocusedEditorWin.Focus(); } else if (originallyFocusedEditorWinType != null) { EditorWindow.FocusWindowIfItsOpen(originallyFocusedEditorWinType); } } }