コード例 #1
0
        private static void Initialize()
        {
            initialized = true;
            try
            {
                scriptFileSubPath = GetMenuItemScriptFileRelativePath();
                if (scriptFileSubPath == null)
                {
                    return;
                }
                scriptFilePath = Application.dataPath + scriptFileSubPath;

                _settings = LoadSettings();

                if (MenuItemScriptNeedsRefresh())
                {
                    _settings.SaveSettings(false);
                    _settings.UpdateMenuItems();
                }
            }
            catch (System.Exception e)
            {
                if (EWFDebugging.Enabled)
                {
                    Debug.LogError("Settings failed to load.");
                    Debug.LogException(e);
                    EWFDebugging.LogError("Settings failed to load. " + e.Message);
                }
            }
        }
コード例 #2
0
        /// <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);
        }
コード例 #3
0
        internal static void TriggerOnResizedAll()
        {
            var containerWin = FindContainerWindow();

            if (containerWin != null)
            {
                MethodInfo OnResizedC = FS.ContainerWindowType.GetMethod("OnResize", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
                if (OnResizedC != null)
                {
                    OnResizedC.Invoke(containerWin, null);
                }
                else
                {
                    EWFDebugging.LogWarning("ContainerWindow OnResize method doesn't exist.");
                }
            }
        }
コード例 #4
0
#pragma warning restore 109
#else
        void OnGUI()
#endif
        {
            var offsetToolbarHeight = EditorFullscreenState.sceneViewToolbarHeight + 1;
            var pos = this.basePosField;

            if (!toolbarVisible)
            {
                GUI.BeginGroup(new Rect(0, -offsetToolbarHeight, this.position.width, this.position.height + offsetToolbarHeight));

                //Trick the base OnGUI into drawing the Scene View at full size by temporarily increasing the window height.
                pos.height       += offsetToolbarHeight;
                this.basePosField = pos;
            }

            try
            {
                baseOnGUI.Invoke(this, null);
            }
            catch (ExitGUIException e)
            {
                throw e;
            }
            catch (TargetInvocationException e)
            {
                if (e.InnerException is ExitGUIException)
                {
                    throw e.InnerException;
                }
                if (EWFDebugging.Enabled)
                {
                    Debug.LogException(e);
                    EWFDebugging.LogError(e.Message);
                }
            }

            if (!toolbarVisible)
            {
                //Reset the window height
                pos.height       -= offsetToolbarHeight;
                this.basePosField = pos;

                GUI.EndGroup();
            }
        }
コード例 #5
0
        public override void OnEnable()
        {
            var last = SceneView.lastActiveSceneView;

            var logEnabled = loggingEnabled;

            loggingEnabled = false;

            try
            {
                this.SetWindowTitle("Scene", true);
                base.OnEnable();

                var sceneIconContent = EditorGUIUtility.IconContent(typeof(SceneView).ToString());
                if (sceneIconContent != null)
                {
                    this.titleContent.image = sceneIconContent.image;
                }
            }
            catch (System.Exception e)
            {
                loggingEnabled = logEnabled;
                if (EWFDebugging.Enabled)
                {
                    Debug.LogException(e);
                    EWFDebugging.LogError(e.Message);
                }
            }
            finally
            {
                loggingEnabled = logEnabled;
            }

            if (last != null)
            {
                //Overwite the contents of the new scene view state with the last scene view state.
                tookStateFromSceneView = last;
#if UNITY_2019_1_OR_NEWER
                audioInitiallyEnabled = last.audioPlay;
#else
                audioInitiallyEnabled = last.m_AudioPlay;
#endif
                last.CopyStateTo(this);
            }
        }
コード例 #6
0
 internal static object[] GetAllChildViews()
 {
     try
     {
         var          mainWindow  = FindMainWindow();
         PropertyInfo allChildren = FS.ViewType.GetProperty("allChildren", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
         return((object[])allChildren.GetValue(mainWindow, null));
     }
     catch (System.Exception e)
     {
         if (EWFDebugging.Enabled)
         {
             Debug.LogException(e);
             EWFDebugging.LogError(e.Message);
         }
     }
     return(null);
 }
コード例 #7
0
        private static SceneViewState SetSceneViewState(this SceneView sceneView, SceneViewState newState)
        {
            SceneViewState state = null;

            try
            {
                FieldInfo sceneViewState = typeof(SceneView).GetField("m_SceneViewState", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
                sceneViewState.SetValue(sceneView, newState);
            }
            catch (System.Exception e)
            {
                if (EWFDebugging.Enabled)
                {
                    Debug.LogException(e);
                    EWFDebugging.LogError(e.Message);
                }
            }
            return(state);
        }
コード例 #8
0
        new void OnDestroy()
        {
            //If the scene view which had its audio state taken still exists, re-enable the audio if it was originally enabled (Only one SceneView at a time can have audio enabled).
#if UNITY_2019_1_OR_NEWER
            if (takeAudioState && tookStateFromSceneView != null && audioInitiallyEnabled && this.audioPlay)
            {
                tookStateFromSceneView.audioPlay = audioInitiallyEnabled;
#else
            if (takeAudioState && tookStateFromSceneView != null && audioInitiallyEnabled && this.m_AudioPlay)
            {
                tookStateFromSceneView.m_AudioPlay = audioInitiallyEnabled;
#endif
                base.OnDestroy();
                try
                {
                    MethodInfo onFocusMethod = typeof(SceneView).GetMethod("OnFocus", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
                    if (onFocusMethod != null)
                    {
                        onFocusMethod.Invoke(tookStateFromSceneView, null);
                    }
                    else
                    {
                        tookStateFromSceneView.RefreshAudioPlay();
                    }
                }
                catch (System.Exception e)
                {
                    if (EWFDebugging.Enabled)
                    {
                        Debug.LogException(e);
                        EWFDebugging.LogError(e.Message);
                    }
                }
            }
            else
            {
                base.OnDestroy();
            }
        }
コード例 #9
0
        /// <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);
        }
コード例 #10
0
        /// <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);
        }
コード例 #11
0
        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);
                }
            }
        }