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);
}
}
}
