/// <summary>
/// Exits the fullscreen game views.
/// </summary>
/// <param name="onlyThoseCreatedAtGameStart">If true, only exits the game views which were created when the game was started.</param>
public static void ExitGameFullscreens(bool onlyThoseCreatedAtGameStart)
{
EditorFullscreenState.RunOnLoad methodToRun = ExitGameFullscreensAll;
if (onlyThoseCreatedAtGameStart)
{
methodToRun = ExitGameFullscreensOnlyThoseCreatedAtGameStart;
}
if (EditorFullscreenState.RunAfterInitialStateLoaded(methodToRun))
{
return;
}
var fullscreenGameWindows = new List <EditorWindow>();
foreach (var state in EditorFullscreenState.fullscreenState.window)
{
if (state.EditorWin != null && state.WindowType == EditorFullscreenState.GameViewType && state.EditorWin.IsFullscreen())
{
if (!onlyThoseCreatedAtGameStart || state.CreatedAtGameStart)
{
fullscreenGameWindows.Add(state.EditorWin);
}
}
}
foreach (var gameWin in fullscreenGameWindows)
{
gameWin.SetFullscreen(false);
}
}
/// <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;
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;
}
win.EditorWin.SetFullscreen(false);
}
}
}
catch { }
if (EditorMainWindow.IsFullscreen())
{
closedAtLeastOneFullscreen = true;
}
EditorMainWindow.SetFullscreen(false);
EditorFullscreenState.fullscreenState.CleanDeletedWindows();
EditorFullscreenState.TriggerFullscreenEvent(null, null, Vector2.zero, closedAtLeastOneFullscreen);
return(closedAtLeastOneFullscreen);
}
/// <summary>
/// Returns true if a window type is fullscreen on the screen specified by the given options.
/// </summary>
public static bool WindowTypeIsFullscreenAtOptionsSpecifiedPosition(Type windowType, EditorFullscreenSettings.FullscreenOption fullscreenOptions)
{
var openAtPosition = fullscreenOptions.openAtPosition;
bool isFullscreen = false;
switch (openAtPosition)
{
case EditorFullscreenSettings.OpenFullscreenAtPosition.AtMousePosition:
EditorWindow mouseOverWin = EditorFullscreenState.GetMouseOverWindow();
if (mouseOverWin != null && mouseOverWin.GetWindowType() == windowType)
{
isFullscreen = mouseOverWin.IsFullscreen();
}
break;
case EditorFullscreenSettings.OpenFullscreenAtPosition.None:
isFullscreen = false;
break;
default:
Vector2 openAtPos = GetOptionsSpecifiedFullscreenOpenAtPosition(null, windowType, fullscreenOptions);
isFullscreen = WindowTypeIsFullscreenOnScreenAtPosition(windowType, openAtPos);
break;
}
return(isFullscreen);
}
void OnEnable()
{
window = this;
this.minSize = new Vector2(540, 670);
headerStyle.fontSize = 18;
headerStyle.fontStyle = FontStyle.Bold;
headerStyle.normal.textColor = EditorGUIUtility.isProSkin ? proHeadingColor : new Color(0.25f, 0.25f, 0.25f, 1f);
headerStyle.margin.top = 10;
headerStyle.margin.bottom = 5;
subHeaderStyle.fontSize = 14;
subHeaderStyle.fontStyle = FontStyle.Bold;
subHeaderStyle.normal.textColor = EditorGUIUtility.isProSkin ? proHeadingColor : new Color(0.25f, 0.25f, 0.25f, 1f);
subHeaderStyle.margin.top = 10;
smallHeadingStyle.fontStyle = FontStyle.Bold;
smallHeadingStyle.margin.top = 5;
smallHeadingStyle.margin.left = 6;
if (EditorGUIUtility.isProSkin)
{
smallHeadingStyle.normal.textColor = proHeadingColor;
}
_windowSettings = EditorFullscreenSettings.LoadSettings();
EditorFullscreenState.TriggerFullscreenEvent(this, this.GetType(), Vector2.zero, false); //Notify everyone that the settings window was opened.
}
/// <summary>
/// Toggles the top toolbar for the currently focused fullscreen window. (Only applies to Scene View, Game View, and Main Window, which have top toolbars).
/// </summary>
public static void ToggleTopToolbar()
{
if (EditorFullscreenState.RunAfterInitialStateLoaded(ToggleTopToolbar))
{
return;
}
EditorFullscreenState.ToggleToolbarInFullscreen();
}
private static bool ToggleGameViewFullscreen(bool triggeredOnPlayStateChange)
{
EditorFullscreenSettings.FullscreenOption fullscreenOps;
if (triggeredOnPlayStateChange)
{
fullscreenOps = EditorFullscreenSettings.settings.openFullscreenOnGameStart;
}
else
{
fullscreenOps = EditorFullscreenSettings.GetFullscreenOptionsForWindowType(EditorFullscreenState.gameViewType);
}
bool setFullscreen = !EditorFullscreenState.WindowTypeIsFullscreenAtOptionsSpecifiedPosition(EditorFullscreenState.gameViewType, fullscreenOps);
EditorFullscreenState.RunOnLoad methodToRun;
if (!triggeredOnPlayStateChange)
{
methodToRun = ToggleGameViewFullscreen;
}
else
{
methodToRun = ToggleGameViewFullscreenPlayStateWasChanged;
}
if (EditorFullscreenState.RunAfterInitialStateLoaded(methodToRun))
{
return(setFullscreen);
}
setFullscreen = EditorFullscreenState.ToggleFullscreenAtOptionsSpecifiedPosition(null, EditorFullscreenState.gameViewType, fullscreenOps, triggeredOnPlayStateChange);
var focusedWindow = EditorWindow.focusedWindow;
EditorMainWindow.Focus();
if (focusedWindow != null)
{
focusedWindow.Focus();
}
if (!triggeredOnPlayStateChange)
{
bool isPlaying = EditorApplication.isPlaying || EditorApplication.isPlayingOrWillChangePlaymode;
if (settings.startGameWhenEnteringFullscreen && !isPlaying && setFullscreen)
{
//Enter play mode
EditorApplication.ExecuteMenuItem("Edit/Play");
}
else if (settings.stopGameWhenExitingFullscreen != EditorFullscreenSettings.StopGameWhenExitingFullscreen.Never && isPlaying && !setFullscreen)
{
if (settings.stopGameWhenExitingFullscreen == EditorFullscreenSettings.StopGameWhenExitingFullscreen.WhenAnyFullscreenGameViewIsExited || !WindowTypeIsFullscreen(EditorFullscreenState.gameViewType))
{
//Exit play mode
EditorApplication.ExecuteMenuItem("Edit/Play");
}
}
}
return(setFullscreen);
}
/// <summary>
/// Toggles fullscreen for the focused window.
/// </summary>
/// <returns>True if the window became fullscreen. False if fullscreen was exited.</returns>
public static bool ToggleFocusedWindowFullscreen()
{
if (EditorWindow.focusedWindow != null)
{
return(EditorFullscreenState.ToggleFullscreenUsingOptions(EditorWindow.focusedWindow, EditorWindow.focusedWindow.GetType(), EditorFullscreenSettings.settings.currentlyFocusedWindow, false, true));
}
else
{
return(false);
}
}
/// <summary>
/// Toggle fullscreen for the window under the cursor.
/// </summary>
/// <returns>True if the window became fullscreen. False if fullscreen was exited.</returns>
public static bool ToggleWindowUnderCursorFullscreen()
{
if (EditorWindow.mouseOverWindow != null)
{
return(EditorFullscreenState.ToggleFullscreenAtOptionsSpecifiedPosition(EditorWindow.mouseOverWindow, EditorWindow.mouseOverWindow.GetType(), EditorFullscreenSettings.settings.windowUnderCursor));
}
else
{
return(false);
}
}
/// <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>
/// Toggles fullscreen for the focused window.
/// </summary>
/// <returns>True if the window became fullscreen. False if fullscreen was exited.</returns>
public static bool ToggleFocusedWindowFullscreen()
{
if (EditorWindow.focusedWindow != null)
{
return(EditorFullscreenState.ToggleFullscreenAtOptionsSpecifiedPosition(EditorWindow.focusedWindow, EditorWindow.focusedWindow.GetType(), EditorFullscreenSettings.settings.currentlyFocusedWindow));
}
else
{
return(false);
}
}
/// <summary>
/// Toggle fullscreen for the window under the cursor.
/// </summary>
/// <returns>True if the window became fullscreen. False if fullscreen was exited.</returns>
public static bool ToggleWindowUnderCursorFullscreen()
{
var mouseOverWin = EditorFullscreenState.GetMouseOverWindow();
if (mouseOverWin != null)
{
return(EditorFullscreenState.ToggleFullscreenUsingOptions(mouseOverWin, mouseOverWin.GetType(), EditorFullscreenSettings.settings.windowUnderCursor, false, true));
}
else
{
return(false);
}
}
/// <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);
}
/// <summary>
/// Toggle fullscreen at the current mouse position for the window with the specified type.
/// </summary>
public static bool ToggleFullscreenAtMousePosition(Type windowType, bool showTopToolbar, bool triggeredOnPlayStateChange)
{
EditorWindow mouseOverWin = GetMouseOverWindow();
if (mouseOverWin != null && (windowType == null || mouseOverWin.GetType() == windowType || mouseOverWin.GetWindowType() == windowType))
{
return(EditorFullscreenState.ToggleFullscreen(mouseOverWin.GetType(), true, EditorInput.MousePosition, showTopToolbar, triggeredOnPlayStateChange));
}
else if (windowType != null)
{
return(EditorFullscreenState.ToggleFullscreen(windowType, EditorInput.MousePosition, showTopToolbar, triggeredOnPlayStateChange));
}
return(false);
}
/// <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> Set fullscreen with the option to show or hide the top tabs </summary>
public static void SetFullscreen(this EditorWindow editorWindow, bool setFullscreen, Vector2 atPosition, bool showTopToolbar)
{
var fullscreenState = EditorFullscreenState.FindWindowState(editorWindow);
if (editorWindow.GetWindowType() == FS.gameViewType)
{
if (showTopToolbar && !fullscreenState.ShowTopToolbar)
{
fullscreenState.CursorLockModePreShowTopToolbar = Cursor.lockState;
Cursor.lockState = CursorLockMode.None; //Enable cursor when top tab is enabled
}
else if (!showTopToolbar && fullscreenState.ShowTopToolbar)
{
Cursor.lockState = fullscreenState.CursorLockModePreShowTopToolbar; //Reset cursor lock mode when top tab is disabled
}
}
fullscreenState.ShowTopToolbar = showTopToolbar;
SetFullscreen(fullscreenState.EditorWin, setFullscreen, atPosition);
}
/// <summary>
/// Exit all game views except for a single one (Multiple game views showing at the same time can cause FPS drops in-game)
/// </summary>
/// <param name="exceptForThisWindow">This is the only exception. Will not be closed.</param>
public static void ExitAllGameViews(EditorWindow exceptForThisWindow)
{
var gameViews = (EditorWindow[])Resources.FindObjectsOfTypeAll(EditorFullscreenState.GameViewType);
var exceptState = EditorFullscreenState.FindWindowState(exceptForThisWindow);
foreach (var win in gameViews)
{
var state = EditorFullscreenState.FindWindowState(win);
if (exceptState != null && exceptState.CreatedAtGameStart && state != null && state.CreatedAtGameStart)
{
//These game windows were created together at game start, so don't close them.
continue;
}
else
{
if (win != exceptForThisWindow)
{
state.CloseOnExitFullscreen = true;
win.SetFullscreen(false);
}
}
}
}
/// <summary>
/// Returns true if an editor window type is fullscreen on the screen at the specified position.
/// </summary>
public static bool WindowTypeIsFullscreenOnScreenAtPosition(Type windowType, Vector2 atPosition)
{
return(EditorFullscreenState.WindowTypeIsFullscreenOnScreenAtPosition(windowType, atPosition));
}
private static bool ToggleGameViewFullscreen(bool triggeredOnGameStart, int optionID)
{
EditorWindow focusedWindow = null;
List <FullscreenOption> allGameWins = null;
EditorFullscreenState.WindowFullscreenState state = null;
bool setFullscreen;
if (triggeredOnGameStart)
{
allGameWins = settings.AllGameWindows;
setFullscreen = true;
}
else
{
setFullscreen = !EditorFullscreenState.WindowTypeIsFullscreenAtOptionsSpecifiedPosition(EditorFullscreenState.GameViewType, settings.GetFullscreenOption(optionID));
}
EditorFullscreenState.RunOnLoad methodToRun;
if (!triggeredOnGameStart)
{
methodToRun = () => ToggleGameViewFullscreen(false, optionID);
}
else
{
methodToRun = () => ToggleGameViewFullscreen(true, optionID);
}
if (EditorFullscreenState.RunAfterInitialStateLoaded(methodToRun))
{
return(setFullscreen);
}
if (triggeredOnGameStart)
{
for (int i = 0; i < allGameWins.Count; i++)
{
if (allGameWins[i].openOnGameStart)
{
if (!EditorFullscreenState.WindowTypeIsFullscreenAtOptionsSpecifiedPosition(EditorFullscreenState.GameViewType, allGameWins[i]))
{
EditorFullscreenState.ToggleFullscreenUsingOptions(null, EditorFullscreenState.GameViewType, allGameWins[i], triggeredOnGameStart, false);
}
}
}
}
else
{
state = EditorFullscreenState.ToggleFullscreenUsingOptions(null, EditorFullscreenState.GameViewType, settings.GetFullscreenOption(optionID), triggeredOnGameStart, false, out setFullscreen);
focusedWindow = EditorWindow.focusedWindow;
}
EditorMainWindow.Focus();
if (focusedWindow != null)
{
focusedWindow.Focus();
}
if (!triggeredOnGameStart)
{
bool isPlaying = EditorApplication.isPlaying || EditorApplication.isPlayingOrWillChangePlaymode;
if (settings.startGameWhenEnteringFullscreen && !isPlaying && setFullscreen)
{
//Enter play mode
EditorApplication.ExecuteMenuItem("Edit/Play");
}
else if (settings.stopGameWhenExitingFullscreen != EditorFullscreenSettings.StopGameWhenExitingFullscreen.Never && isPlaying && !setFullscreen)
{
if (settings.stopGameWhenExitingFullscreen == EditorFullscreenSettings.StopGameWhenExitingFullscreen.WhenAnyFullscreenGameViewIsExited || !WindowTypeIsFullscreen(EditorFullscreenState.GameViewType, state))
{
//Exit play mode
EditorApplication.ExecuteMenuItem("Edit/Play");
}
}
}
return(setFullscreen);
}
/// <summary>
/// Toggles fullscreen for the scene view.
/// </summary>
public static bool ToggleSceneViewFullscreen()
{
return(EditorFullscreenState.ToggleFullscreenUsingOptions(typeof(CustomSceneView), settings.sceneWindow));
}
/// <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);
}
/******************************************/
/************ Hotkeyed Methods ************/
/******************************************/
/// <summary>
/// Toggles fullscreen for the main editor window.
/// </summary>
///
public static bool ToggleMainWindowFullscreen()
{
return(EditorFullscreenState.ToggleFullscreenUsingOptions(EditorFullscreenState.MainWindowType, settings.mainUnityWindow));
}
/// <summary>
/// Toggle fullscreen at a position decided according to the current settings for the specified window type.
/// </summary>
public static bool ToggleFullscreenAtOptionsSpecifiedPosition(Type windowType)
{
return(EditorFullscreenState.ToggleFullscreenAtOptionsSpecifiedPosition(windowType));
}
/// <summary>
/// Toggle fullscreen for a window type, on the screen at a position.
/// </summary>
/// <param name="windowType">The type of the window to create a fullscreen for.</param>
/// <param name="atPosition">Fullscreen will be toggled on the screen which is at this position.</param>
/// <param name="showTopToolbar">Show the top toolbar by default if opening a fullscreen.</param>
/// <returns>True if the window type became fullscreen. False if fullscreen was exited.</returns>
public static bool ToggleFullscreen(Type windowType, Vector2 atPosition, bool showTopToolbar)
{
return(EditorFullscreenState.ToggleFullscreen(windowType, atPosition, showTopToolbar, false));
}
/// <summary>
/// Toggle fullscreen for a window type (Creates a new fullscreen window if none already exists).
/// Enters fullscreen on the primary screen.
/// </summary>
/// <param name="windowType">The type of the window to create a fullscreen for.</param>
/// <returns>True if the window type became fullscreen. False if fullscreen was exited.</returns>
public static bool ToggleFullscreen(Type windowType)
{
return(EditorFullscreenState.ToggleFullscreen(windowType));
}
/// <summary>
/// Toggle fullscreen for a window type, on the screen at a position. Shows the toolbar if applicable.
/// </summary>
/// <param name="windowType">The type of the window to create a fullscreen for.</param>
/// <param name="atPosition">Fullscreen will be toggled on the screen which is at this position.</param>
/// <returns>True if the window type became fullscreen. False if fullscreen was exited.</returns>
public static bool ToggleFullscreen(Type windowType, Vector2 atPosition)
{
return(EditorFullscreenState.ToggleFullscreen(windowType, atPosition, true, false));
}
/// <summary>
/// Toggle fullscreen at the current mouse position for the window with the specified type.
/// </summary>
public static bool ToggleFullscreenAtMousePosition(Type windowType, bool showTopToolbar)
{
return(EditorFullscreenState.ToggleFullscreenAtMousePosition(windowType, showTopToolbar));
}
/// <summary>
/// Toggle fullscreen at the current mouse position for the window with the specified type. Shows the toolbar if applicable.
/// </summary>
public static bool ToggleFullscreenAtMousePosition(Type windowType)
{
return(EditorFullscreenState.ToggleFullscreenAtMousePosition(windowType, true));
}
/******************************************/
/************ Hotkeyed Methods ************/
/******************************************/
/// <summary>
/// Toggles fullscreen for the main editor window.
/// </summary>
///
public static bool ToggleMainWindowFullscreen()
{
return(EditorFullscreenState.ToggleFullscreenAtOptionsSpecifiedPosition(EditorFullscreenState.mainWindowType));
}
/// <summary>
/// Toggles fullscreen for the scene view.
/// </summary>
public static bool ToggleSceneViewFullscreen()
{
return(EditorFullscreenState.ToggleFullscreenAtOptionsSpecifiedPosition(typeof(CustomSceneView)));
}
private static void PlayModeStateChanged()
{
bool startingPlay = !EditorApplication.isPlaying && EditorApplication.isPlayingOrWillChangePlaymode;
bool stoppedPlay = !EditorApplication.isPlaying && !EditorApplication.isPlayingOrWillChangePlaymode;
if (startingPlay)
{
if (settings.openFullscreenOnGameStart.openAtPosition != EditorFullscreenSettings.OpenFullscreenAtPosition.None && !EditorFullscreenState.WindowTypeIsFullscreenAtOptionsSpecifiedPosition(EditorFullscreenState.gameViewType, settings.openFullscreenOnGameStart))
{
ToggleGameViewFullscreen(true);
}
}
else if (stoppedPlay)
{
if (settings.closeFullscreenOnGameStop == EditorFullscreenSettings.CloseFullscreenOnGameStop.AllFullscreenGameWindows)
{
ExitGameFullscreens(false);
}
else if (settings.closeFullscreenOnGameStop == EditorFullscreenSettings.CloseFullscreenOnGameStop.FullscreensCreatedAtGameStart)
{
ExitGameFullscreens(true);
}
}
}
