Exemple #1
0
        public Error OpenInExternalEditor(Script script, int line, int col)
        {
            var editor = (ExternalEditorId)editorSettings.GetSetting("mono/editor/external_editor");

            switch (editor)
            {
            case ExternalEditorId.None:
                // Tells the caller to fallback to the global external editor settings or the built-in editor
                return(Error.Unavailable);

            case ExternalEditorId.VisualStudio:
                throw new NotSupportedException();

            case ExternalEditorId.VisualStudioForMac:
                goto case ExternalEditorId.MonoDevelop;

            case ExternalEditorId.Rider:
            {
                string scriptPath = ProjectSettings.GlobalizePath(script.ResourcePath);
                RiderPathManager.OpenFile(GodotSharpDirs.ProjectSlnPath, scriptPath, line);
                return(Error.Ok);
            }

            case ExternalEditorId.MonoDevelop:
            {
                string scriptPath = ProjectSettings.GlobalizePath(script.ResourcePath);

                if (line >= 0)
                {
                    GodotIdeManager.SendOpenFile(scriptPath, line + 1, col);
                }
                else
                {
                    GodotIdeManager.SendOpenFile(scriptPath);
                }

                break;
            }

            case ExternalEditorId.VsCode:
            {
                if (_vsCodePath.Empty() || !File.Exists(_vsCodePath))
                {
                    // Try to search it again if it wasn't found last time or if it was removed from its location
                    _vsCodePath = VsCodeNames.SelectFirstNotNull(OS.PathWhich, orElse: string.Empty);
                }

                var args = new List <string>();

                bool osxAppBundleInstalled = false;

                if (OS.IsOSX)
                {
                    // The package path is '/Applications/Visual Studio Code.app'
                    const string vscodeBundleId = "com.microsoft.VSCode";

                    osxAppBundleInstalled = Internal.IsOsxAppBundleInstalled(vscodeBundleId);

                    if (osxAppBundleInstalled)
                    {
                        args.Add("-b");
                        args.Add(vscodeBundleId);

                        // The reusing of existing windows made by the 'open' command might not choose a wubdiw that is
                        // editing our folder. It's better to ask for a new window and let VSCode do the window management.
                        args.Add("-n");

                        // The open process must wait until the application finishes (which is instant in VSCode's case)
                        args.Add("--wait-apps");

                        args.Add("--args");
                    }
                }

                var resourcePath = ProjectSettings.GlobalizePath("res://");
                args.Add(resourcePath);

                string scriptPath = ProjectSettings.GlobalizePath(script.ResourcePath);

                if (line >= 0)
                {
                    args.Add("-g");
                    args.Add($"{scriptPath}:{line + 1}:{col}");
                }
                else
                {
                    args.Add(scriptPath);
                }

                string command;

                if (OS.IsOSX)
                {
                    if (!osxAppBundleInstalled && _vsCodePath.Empty())
                    {
                        GD.PushError("Cannot find code editor: VSCode");
                        return(Error.FileNotFound);
                    }

                    command = osxAppBundleInstalled ? "/usr/bin/open" : _vsCodePath;
                }
                else
                {
                    if (_vsCodePath.Empty())
                    {
                        GD.PushError("Cannot find code editor: VSCode");
                        return(Error.FileNotFound);
                    }

                    command = _vsCodePath;
                }

                try
                {
                    OS.RunProcess(command, args);
                }
                catch (Exception e)
                {
                    GD.PushError($"Error when trying to run code editor: VSCode. Exception message: '{e.Message}'");
                }

                break;
            }

            default:
                throw new ArgumentOutOfRangeException();
            }

            return(Error.Ok);
        }
Exemple #2
0
        public override void EnablePlugin()
        {
            base.EnablePlugin();

            if (Instance != null)
            {
                throw new InvalidOperationException();
            }
            Instance = this;

            var editorInterface   = GetEditorInterface();
            var editorBaseControl = editorInterface.GetBaseControl();

            editorSettings = editorInterface.GetEditorSettings();

            errorDialog = new AcceptDialog();
            editorBaseControl.AddChild(errorDialog);

            BottomPanel = new BottomPanel();

            bottomPanelBtn = AddControlToBottomPanel(BottomPanel, "Mono".TTR());

            AddChild(new HotReloadAssemblyWatcher {
                Name = "HotReloadAssemblyWatcher"
            });

            menuPopup = new PopupMenu();
            menuPopup.Hide();
            menuPopup.SetAsToplevel(true);

            AddToolSubmenuItem("Mono", menuPopup);

            // TODO: Remove or edit this info dialog once Mono support is no longer in alpha
            {
                menuPopup.AddItem("About C# support".TTR(), (int)MenuOptions.AboutCSharp);
                aboutDialog = new AcceptDialog();
                editorBaseControl.AddChild(aboutDialog);
                aboutDialog.WindowTitle = "Important: C# support is not feature-complete";

                // We don't use DialogText as the default AcceptDialog Label doesn't play well with the TextureRect and CheckBox
                // we'll add. Instead we add containers and a new autowrapped Label inside.

                // Main VBoxContainer (icon + label on top, checkbox at bottom)
                var aboutVBox = new VBoxContainer();
                aboutDialog.AddChild(aboutVBox);

                // HBoxContainer for icon + label
                var aboutHBox = new HBoxContainer();
                aboutVBox.AddChild(aboutHBox);

                var aboutIcon = new TextureRect();
                aboutIcon.Texture = aboutIcon.GetIcon("NodeWarning", "EditorIcons");
                aboutHBox.AddChild(aboutIcon);

                var aboutLabel = new Label();
                aboutHBox.AddChild(aboutLabel);
                aboutLabel.RectMinSize       = new Vector2(600, 150) * EditorScale;
                aboutLabel.SizeFlagsVertical = (int)Control.SizeFlags.ExpandFill;
                aboutLabel.Autowrap          = true;
                aboutLabel.Text =
                    "C# support in Godot Engine is in late alpha stage and, while already usable, " +
                    "it is not meant for use in production.\n\n" +
                    "Projects can be exported to Linux, macOS, Windows and Android, but not yet to iOS, HTML5 or UWP. " +
                    "Bugs and usability issues will be addressed gradually over future releases, " +
                    "potentially including compatibility breaking changes as new features are implemented for a better overall C# experience.\n\n" +
                    "If you experience issues with this Mono build, please report them on Godot's issue tracker with details about your system, MSBuild version, IDE, etc.:\n\n" +
                    "        https://github.com/godotengine/godot/issues\n\n" +
                    "Your critical feedback at this stage will play a great role in shaping the C# support in future releases, so thank you!";

                EditorDef("mono/editor/show_info_on_start", true);

                // CheckBox in main container
                aboutDialogCheckBox = new CheckBox {
                    Text = "Show this warning when starting the editor"
                };
                aboutDialogCheckBox.Connect("toggled", this, nameof(_ToggleAboutDialogOnStart));
                aboutVBox.AddChild(aboutDialogCheckBox);
            }

            if (File.Exists(GodotSharpDirs.ProjectSlnPath) && File.Exists(GodotSharpDirs.ProjectCsProjPath))
            {
                // Make sure the existing project has Api assembly references configured correctly
                CsProjOperations.FixApiHintPath(GodotSharpDirs.ProjectCsProjPath);
            }
            else
            {
                bottomPanelBtn.Hide();
                menuPopup.AddItem("Create C# solution".TTR(), (int)MenuOptions.CreateSln);
            }

            menuPopup.Connect("id_pressed", this, nameof(_MenuOptionPressed));

            var buildButton = new ToolButton
            {
                Text        = "Build",
                HintTooltip = "Build solution",
                FocusMode   = Control.FocusModeEnum.None
            };

            buildButton.Connect("pressed", this, nameof(_BuildSolutionPressed));
            AddControlToContainer(CustomControlContainer.Toolbar, buildButton);

            // External editor settings
            EditorDef("mono/editor/external_editor", ExternalEditorId.None);

            string settingsHintStr = "Disabled";

            if (OS.IsWindows)
            {
                settingsHintStr += $",MonoDevelop:{(int)ExternalEditorId.MonoDevelop}" +
                                   $",Visual Studio Code:{(int)ExternalEditorId.VsCode}" +
                                   $",JetBrains Rider:{(int)ExternalEditorId.Rider}";
            }
            else if (OS.IsOSX)
            {
                settingsHintStr += $",Visual Studio:{(int)ExternalEditorId.VisualStudioForMac}" +
                                   $",MonoDevelop:{(int)ExternalEditorId.MonoDevelop}" +
                                   $",Visual Studio Code:{(int)ExternalEditorId.VsCode}" +
                                   $",JetBrains Rider:{(int)ExternalEditorId.Rider}";
            }
            else if (OS.IsUnixLike())
            {
                settingsHintStr += $",MonoDevelop:{(int)ExternalEditorId.MonoDevelop}" +
                                   $",Visual Studio Code:{(int)ExternalEditorId.VsCode}" +
                                   $",JetBrains Rider:{(int)ExternalEditorId.Rider}";
            }

            editorSettings.AddPropertyInfo(new Godot.Collections.Dictionary
            {
                ["type"]        = Variant.Type.Int,
                ["name"]        = "mono/editor/external_editor",
                ["hint"]        = PropertyHint.Enum,
                ["hint_string"] = settingsHintStr
            });

            // Export plugin
            var exportPlugin = new ExportPlugin();

            AddExportPlugin(exportPlugin);
            exportPlugin.RegisterExportSettings();
            exportPluginWeak = WeakRef(exportPlugin);

            BuildManager.Initialize();
            RiderPathManager.Initialize();

            GodotIdeManager = new GodotIdeManager();
            AddChild(GodotIdeManager);
        }
Exemple #3
0
        public Error OpenInExternalEditor(Script script, int line, int col)
        {
            var editorId = (ExternalEditorId)_editorSettings.GetSetting("mono/editor/external_editor");

            switch (editorId)
            {
            case ExternalEditorId.None:
                // Not an error. Tells the caller to fallback to the global external editor settings or the built-in editor.
                return(Error.Unavailable);

            case ExternalEditorId.VisualStudio:
            {
                string scriptPath = ProjectSettings.GlobalizePath(script.ResourcePath);

                var args = new List <string>
                {
                    GodotSharpDirs.ProjectSlnPath,
                    line >= 0 ? $"{scriptPath};{line + 1};{col + 1}" : scriptPath
                };

                string command = Path.Combine(GodotSharpDirs.DataEditorToolsDir, "GodotTools.OpenVisualStudio.exe");

                try
                {
                    if (Godot.OS.IsStdoutVerbose())
                    {
                        Console.WriteLine($"Running: \"{command}\" {string.Join(" ", args.Select(a => $"\"{a}\""))}");
                    }

                    OS.RunProcess(command, args);
                }
                catch (Exception e)
                {
                    GD.PushError($"Error when trying to run code editor: VisualStudio. Exception message: '{e.Message}'");
                }

                break;
            }

            case ExternalEditorId.VisualStudioForMac:
                goto case ExternalEditorId.MonoDevelop;

            case ExternalEditorId.Rider:
            {
                string scriptPath = ProjectSettings.GlobalizePath(script.ResourcePath);
                RiderPathManager.OpenFile(GodotSharpDirs.ProjectSlnPath, scriptPath, line);
                return(Error.Ok);
            }

            case ExternalEditorId.MonoDevelop:
            {
                string scriptPath = ProjectSettings.GlobalizePath(script.ResourcePath);

                GodotIdeManager.LaunchIdeAsync().ContinueWith(launchTask =>
                    {
                        var editorPick = launchTask.Result;
                        if (line >= 0)
                        {
                            editorPick?.SendOpenFile(scriptPath, line + 1, col);
                        }
                        else
                        {
                            editorPick?.SendOpenFile(scriptPath);
                        }
                    });

                break;
            }

            case ExternalEditorId.VsCode:
            {
                if (string.IsNullOrEmpty(_vsCodePath) || !File.Exists(_vsCodePath))
                {
                    // Try to search it again if it wasn't found last time or if it was removed from its location
                    _vsCodePath = VsCodeNames.SelectFirstNotNull(OS.PathWhich, orElse: string.Empty);
                }

                var args = new List <string>();

                bool osxAppBundleInstalled = false;

                if (OS.IsMacOS)
                {
                    // The package path is '/Applications/Visual Studio Code.app'
                    const string vscodeBundleId = "com.microsoft.VSCode";

                    osxAppBundleInstalled = Internal.IsOsxAppBundleInstalled(vscodeBundleId);

                    if (osxAppBundleInstalled)
                    {
                        args.Add("-b");
                        args.Add(vscodeBundleId);

                        // The reusing of existing windows made by the 'open' command might not choose a wubdiw that is
                        // editing our folder. It's better to ask for a new window and let VSCode do the window management.
                        args.Add("-n");

                        // The open process must wait until the application finishes (which is instant in VSCode's case)
                        args.Add("--wait-apps");

                        args.Add("--args");
                    }
                }

                string resourcePath = ProjectSettings.GlobalizePath("res://");
                args.Add(resourcePath);

                string scriptPath = ProjectSettings.GlobalizePath(script.ResourcePath);

                if (line >= 0)
                {
                    args.Add("-g");
                    args.Add($"{scriptPath}:{line}:{col}");
                }
                else
                {
                    args.Add(scriptPath);
                }

                string command;

                if (OS.IsMacOS)
                {
                    if (!osxAppBundleInstalled && string.IsNullOrEmpty(_vsCodePath))
                    {
                        GD.PushError("Cannot find code editor: VSCode");
                        return(Error.FileNotFound);
                    }

                    command = osxAppBundleInstalled ? "/usr/bin/open" : _vsCodePath;
                }
                else
                {
                    if (string.IsNullOrEmpty(_vsCodePath))
                    {
                        GD.PushError("Cannot find code editor: VSCode");
                        return(Error.FileNotFound);
                    }

                    command = _vsCodePath;
                }

                try
                {
                    OS.RunProcess(command, args);
                }
                catch (Exception e)
                {
                    GD.PushError($"Error when trying to run code editor: VSCode. Exception message: '{e.Message}'");
                }

                break;
            }

            default:
                throw new ArgumentOutOfRangeException();
            }

            return(Error.Ok);
        }