private static bool     DetectDiff()
        {
            if (HQ.Settings == null || NGFullscreenBindingsWindow.isGenerating == true)
            {
                return(false);
            }

            Type type = Utility.GetType("NGToolsEditor.NGFullscreenBindings", "ExternalNGFullscreenBindings");
            FullscreenBindingsSettings settings = HQ.Settings.Get <FullscreenBindingsSettings>();

            for (int i = 0; i < settings.bindings.Length; i++)
            {
                bool      changeDetected = false;
                FieldInfo field          = type.GetField("F" + (i + 1));

                if (field == null)
                {
                    changeDetected = true;
                }
                else
                {
                    TypeWitnessAttribute[] attr = field.GetCustomAttributes(typeof(TypeWitnessAttribute), false) as TypeWitnessAttribute[];

                    changeDetected = settings.bindings[i].Equals(new FullscreenBindingsSettings.Binding((string)field.GetRawConstantValue(), attr.Length > 0 ? attr[0].type : string.Empty)
                    {
                        active = type.GetMethod("ToggleFullscreenF" + (i + 1)) != null
                    }) == false;
                }

                if (changeDetected == true)
                {
                    InternalNGDebug.VerboseLog(NGFullscreenBindingsWindow.Title + " has detected a change between the code file and the configuration.");

                    EditorApplication.delayCall += () =>
                    {
                        if (EditorUtility.DisplayDialog(NGFullscreenBindingsWindow.Title, "The current fullscreen bindings do not match your settings.\nThis might happen after an update of NG Tools.\n\nDo you want to restore your setup?", LC.G("Yes"), LC.G("No")) == true)
                        {
                            NGFullscreenBindingsWindow.isGenerating = true;
                            NGFullscreenBindingsWindow.Generate();
                        }
                    };
                    return(true);
                }
            }

            return(false);
        }
        public static void      ToggleFullscreen(int f)
        {
            Metrics.UseTool(22);             // NGFullscreenBindings

            NGChangeLogWindow.CheckLatestVersion(NGAssemblyInfo.Name);

            if (NGFullscreenBindingsWindow.DetectDiff() == true)
            {
                return;
            }

            if (HQ.Settings == null || f > HQ.Settings.Get <FullscreenBindingsSettings>().bindings.Length)
            {
                EditorUtility.DisplayDialog(Constants.PackageTitle, "The binding is invalid. Please regenerate it.", "OK");
                NGFullscreenBindingsWindow.Open();
                return;
            }

            Type type = NGFullscreenBindingsWindow.GetType(HQ.Settings.Get <FullscreenBindingsSettings>().bindings[f - 1].type);

            if (type == null)
            {
                EditorUtility.DisplayDialog(Constants.PackageTitle, "The binding has been assigned an invalid Window.", "OK");
                NGFullscreenBindingsWindow.Open();
                return;
            }

            InternalNGDebug.VerboseLogFormat("Toggling fullscreen window \"{0}\".", type);

            EditorWindow[] windows = Resources.FindObjectsOfTypeAll <EditorWindow>();

            for (int i = 0; i < windows.Length; i++)
            {
                if (windows[i].GetType() != type && windows[i].maximized == true)
                {
                    windows[i].maximized = false;
                    break;
                }
            }

            EditorWindow window = EditorWindow.GetWindow(type);

            EditorApplication.delayCall += () => window.maximized = !window.maximized;
        }
        private static void     OnGUISettings()
        {
            if (HQ.Settings == null)
            {
                return;
            }

            EditorGUILayout.Space();

            FullscreenBindingsSettings settings = HQ.Settings.Get <FullscreenBindingsSettings>();

            // Rebuild and restore as much as we can the previous bindings.
            if (settings.bindings == null ||
                settings.bindings.Length != 12)
            {
                FullscreenBindingsSettings.Binding[] newBindings = new FullscreenBindingsSettings.Binding[12];
                Type type = Utility.GetType("NGToolsEditor.NGFullscreenBindings", "ExternalNGFullscreenBindings");

                if (settings.bindings != null)
                {
                    for (int i = 0; i < settings.bindings.Length && i < newBindings.Length; i++)
                    {
                        newBindings[i] = new FullscreenBindingsSettings.Binding(settings.bindings[i].label, settings.bindings[i].type)
                        {
                            active = settings.bindings[i].active,
                            ctrl   = settings.bindings[i].ctrl,
                            shift  = settings.bindings[i].shift,
                            alt    = settings.bindings[i].alt,
                        };
                    }

                    for (int i = 0; i < settings.bindings.Length; i++)
                    {
                        FieldInfo field = type.GetField("F" + (i + 1));

                        if (field != null)
                        {
                            newBindings[i] = new FullscreenBindingsSettings.Binding((string)field.GetRawConstantValue(), string.Empty)
                            {
                                active = type.GetMethod("ToggleFullscreenF" + (i + 1)) != null
                            }
                        }
                        ;
                    }
                }

                for (int i = 0; i < newBindings.Length; i++)
                {
                    if (newBindings[i] == null)
                    {
                        newBindings[i] = new FullscreenBindingsSettings.Binding(string.Empty, string.Empty);
                    }
                }

                settings.bindings = newBindings;
            }

            using (LabelWidthRestorer.Get(30F))
            {
                for (int i = 0; i < settings.bindings.Length; i++)
                {
                    FullscreenBindingsSettings.Binding binding = settings.bindings[i];

                    EditorGUILayout.BeginHorizontal();
                    {
                        binding.active = EditorGUILayout.Toggle(binding.active, GUILayoutOptionPool.Width(12F));

                        EditorGUI.BeginDisabledGroup(binding.active == false);
                        {
                            GUILayout.Label("F" + (i + 1), GUILayoutOptionPool.Width(25F));

                            binding.ctrl  = GUILayout.Toggle(binding.ctrl, "Ctrl", "ToolbarButton", GUILayoutOptionPool.Width(35F));
                            binding.shift = GUILayout.Toggle(binding.shift, "Shift", "ToolbarButton", GUILayoutOptionPool.Width(35F));
                            binding.alt   = GUILayout.Toggle(binding.alt, "Alt", "ToolbarButton", GUILayoutOptionPool.Width(35F));
                            binding.label = EditorGUILayout.TextField(binding.label);

                            GUILayout.FlexibleSpace();

                            Type t = NGFullscreenBindingsWindow.GetType(settings.bindings[i].type);
                            if (t != null)
                            {
                                GUILayout.Label(t.Name, GUILayoutOptionPool.ExpandWidthFalse);
                            }

                            if (GUILayout.Button("Pick", GUILayoutOptionPool.Width(50F)) == true)
                            {
                                NGFullscreenBindingsWindow.PickType(i);
                            }
                        }
                        EditorGUI.EndDisabledGroup();
                    }
                    EditorGUILayout.EndHorizontal();

                    if (NGFullscreenBindingsWindow.regex.IsMatch(binding.label) == false)
                    {
                        EditorGUILayout.HelpBox("Must contains only alpha numeric chars, space, tab, dash, underscore.", MessageType.Error, true);
                    }

                    if (i == 0 && binding.ctrl == false && binding.shift == false && binding.alt == true)
                    {
                        EditorGUILayout.HelpBox("This binding is already used. You must change it.", MessageType.Error, true);
                    }
                }
            }

            if (EditorApplication.isCompiling == true)
            {
                using (BgColorContentRestorer.Get(GeneralStyles.HighlightResultButton))
                {
                    GUILayout.Button("Compiling...");
                }
            }
            else if (GUILayout.Button("Save") == true)
            {
                HQ.InvalidateSettings();
                NGFullscreenBindingsWindow.Generate();
            }
        }
 public static void      ToggleFullscreenF12()
 {
     NGFullscreenBindingsWindow.ToggleFullscreen(12);
 }
 public static void      ToggleFullscreenF9()
 {
     NGFullscreenBindingsWindow.ToggleFullscreen(9);
 }