31b7f02a29
ToolButton has no redeeming differences with Button; it's just a Button with the Flat property enabled by default. Removing it avoids some confusion when creating GUIs. Existing ToolButtons will be converted to Buttons, but the Flat property won't be enabled automatically. This closes https://github.com/godotengine/godot-proposals/issues/1081.
608 lines
24 KiB
C#
608 lines
24 KiB
C#
using Godot;
|
|
using GodotTools.Core;
|
|
using GodotTools.Export;
|
|
using GodotTools.Utils;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using GodotTools.Ides;
|
|
using GodotTools.Ides.Rider;
|
|
using GodotTools.Internals;
|
|
using GodotTools.ProjectEditor;
|
|
using JetBrains.Annotations;
|
|
using static GodotTools.Internals.Globals;
|
|
using File = GodotTools.Utils.File;
|
|
using OS = GodotTools.Utils.OS;
|
|
using Path = System.IO.Path;
|
|
|
|
namespace GodotTools
|
|
{
|
|
[SuppressMessage("ReSharper", "ClassNeverInstantiated.Global")]
|
|
public class GodotSharpEditor : EditorPlugin, ISerializationListener
|
|
{
|
|
private EditorSettings editorSettings;
|
|
|
|
private PopupMenu menuPopup;
|
|
|
|
private AcceptDialog errorDialog;
|
|
private AcceptDialog aboutDialog;
|
|
private CheckBox aboutDialogCheckBox;
|
|
|
|
private Button bottomPanelBtn;
|
|
|
|
public GodotIdeManager GodotIdeManager { get; private set; }
|
|
|
|
private WeakRef exportPluginWeak; // TODO Use WeakReference once we have proper serialization
|
|
|
|
public BottomPanel BottomPanel { get; private set; }
|
|
|
|
public PlaySettings? CurrentPlaySettings { get; set; }
|
|
|
|
public static string ProjectAssemblyName
|
|
{
|
|
get
|
|
{
|
|
var projectAssemblyName = (string)ProjectSettings.GetSetting("application/config/name");
|
|
if (string.IsNullOrEmpty(projectAssemblyName))
|
|
projectAssemblyName = "UnnamedProject";
|
|
return projectAssemblyName;
|
|
}
|
|
}
|
|
|
|
private bool CreateProjectSolution()
|
|
{
|
|
using (var pr = new EditorProgress("create_csharp_solution", "Generating solution...".TTR(), 3))
|
|
{
|
|
pr.Step("Generating C# project...".TTR());
|
|
|
|
string resourceDir = ProjectSettings.GlobalizePath("res://");
|
|
|
|
string path = resourceDir;
|
|
string name = ProjectAssemblyName;
|
|
|
|
string guid = CsProjOperations.GenerateGameProject(path, name);
|
|
|
|
if (guid.Length > 0)
|
|
{
|
|
var solution = new DotNetSolution(name)
|
|
{
|
|
DirectoryPath = path
|
|
};
|
|
|
|
var projectInfo = new DotNetSolution.ProjectInfo
|
|
{
|
|
Guid = guid,
|
|
PathRelativeToSolution = name + ".csproj",
|
|
Configs = new List<string> {"Debug", "ExportDebug", "ExportRelease"}
|
|
};
|
|
|
|
solution.AddNewProject(name, projectInfo);
|
|
|
|
try
|
|
{
|
|
solution.Save();
|
|
}
|
|
catch (IOException e)
|
|
{
|
|
ShowErrorDialog("Failed to save solution. Exception message: ".TTR() + e.Message);
|
|
return false;
|
|
}
|
|
|
|
pr.Step("Updating Godot API assemblies...".TTR());
|
|
|
|
string debugApiAssembliesError = Internal.UpdateApiAssembliesFromPrebuilt("Debug");
|
|
|
|
if (!string.IsNullOrEmpty(debugApiAssembliesError))
|
|
{
|
|
ShowErrorDialog("Failed to update the Godot API assemblies: " + debugApiAssembliesError);
|
|
return false;
|
|
}
|
|
|
|
string releaseApiAssembliesError = Internal.UpdateApiAssembliesFromPrebuilt("Release");
|
|
|
|
if (!string.IsNullOrEmpty(releaseApiAssembliesError))
|
|
{
|
|
ShowErrorDialog("Failed to update the Godot API assemblies: " + releaseApiAssembliesError);
|
|
return false;
|
|
}
|
|
|
|
pr.Step("Done".TTR());
|
|
|
|
// Here, after all calls to progress_task_step
|
|
CallDeferred(nameof(_RemoveCreateSlnMenuOption));
|
|
}
|
|
else
|
|
{
|
|
ShowErrorDialog("Failed to create C# project.".TTR());
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
private void _RemoveCreateSlnMenuOption()
|
|
{
|
|
menuPopup.RemoveItem(menuPopup.GetItemIndex((int)MenuOptions.CreateSln));
|
|
bottomPanelBtn.Show();
|
|
}
|
|
|
|
private void _ShowAboutDialog()
|
|
{
|
|
bool showOnStart = (bool)editorSettings.GetSetting("mono/editor/show_info_on_start");
|
|
aboutDialogCheckBox.Pressed = showOnStart;
|
|
aboutDialog.PopupCentered();
|
|
}
|
|
|
|
private void _MenuOptionPressed(int id)
|
|
{
|
|
switch ((MenuOptions)id)
|
|
{
|
|
case MenuOptions.CreateSln:
|
|
CreateProjectSolution();
|
|
break;
|
|
case MenuOptions.AboutCSharp:
|
|
_ShowAboutDialog();
|
|
break;
|
|
default:
|
|
throw new ArgumentOutOfRangeException(nameof(id), id, "Invalid menu option");
|
|
}
|
|
}
|
|
|
|
private void _BuildSolutionPressed()
|
|
{
|
|
if (!File.Exists(GodotSharpDirs.ProjectSlnPath))
|
|
{
|
|
if (!CreateProjectSolution())
|
|
return; // Failed to create solution
|
|
}
|
|
|
|
Instance.BottomPanel.BuildProjectPressed();
|
|
}
|
|
|
|
public override void _Notification(int what)
|
|
{
|
|
base._Notification(what);
|
|
|
|
if (what == NotificationReady)
|
|
{
|
|
bool showInfoDialog = (bool)editorSettings.GetSetting("mono/editor/show_info_on_start");
|
|
if (showInfoDialog)
|
|
{
|
|
aboutDialog.Exclusive = true;
|
|
_ShowAboutDialog();
|
|
// Once shown a first time, it can be seen again via the Mono menu - it doesn't have to be exclusive from that time on.
|
|
aboutDialog.Exclusive = false;
|
|
}
|
|
|
|
var fileSystemDock = GetEditorInterface().GetFileSystemDock();
|
|
|
|
fileSystemDock.FilesMoved += (file, newFile) =>
|
|
{
|
|
if (Path.GetExtension(file) == Internal.CSharpLanguageExtension)
|
|
{
|
|
ProjectUtils.RenameItemInProjectChecked(GodotSharpDirs.ProjectCsProjPath, "Compile",
|
|
ProjectSettings.GlobalizePath(file), ProjectSettings.GlobalizePath(newFile));
|
|
}
|
|
};
|
|
|
|
fileSystemDock.FileRemoved += file =>
|
|
{
|
|
if (Path.GetExtension(file) == Internal.CSharpLanguageExtension)
|
|
ProjectUtils.RemoveItemFromProjectChecked(GodotSharpDirs.ProjectCsProjPath, "Compile",
|
|
ProjectSettings.GlobalizePath(file));
|
|
};
|
|
|
|
fileSystemDock.FolderMoved += (oldFolder, newFolder) =>
|
|
{
|
|
ProjectUtils.RenameItemsToNewFolderInProjectChecked(GodotSharpDirs.ProjectCsProjPath, "Compile",
|
|
ProjectSettings.GlobalizePath(oldFolder), ProjectSettings.GlobalizePath(newFolder));
|
|
};
|
|
|
|
fileSystemDock.FolderRemoved += oldFolder =>
|
|
{
|
|
ProjectUtils.RemoveItemsInFolderFromProjectChecked(GodotSharpDirs.ProjectCsProjPath, "Compile",
|
|
ProjectSettings.GlobalizePath(oldFolder));
|
|
};
|
|
}
|
|
}
|
|
|
|
private enum MenuOptions
|
|
{
|
|
CreateSln,
|
|
AboutCSharp,
|
|
}
|
|
|
|
public void ShowErrorDialog(string message, string title = "Error")
|
|
{
|
|
errorDialog.Title = title;
|
|
errorDialog.DialogText = message;
|
|
errorDialog.PopupCentered();
|
|
}
|
|
|
|
private static string _vsCodePath = string.Empty;
|
|
|
|
private static readonly string[] VsCodeNames =
|
|
{
|
|
"code", "code-oss", "vscode", "vscode-oss", "visual-studio-code", "visual-studio-code-oss"
|
|
};
|
|
|
|
[UsedImplicitly]
|
|
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.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}:{col}");
|
|
}
|
|
else
|
|
{
|
|
args.Add(scriptPath);
|
|
}
|
|
|
|
string command;
|
|
|
|
if (OS.IsOSX)
|
|
{
|
|
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;
|
|
}
|
|
|
|
[UsedImplicitly]
|
|
public bool OverridesExternalEditor()
|
|
{
|
|
return (ExternalEditorId)editorSettings.GetSetting("mono/editor/external_editor") != ExternalEditorId.None;
|
|
}
|
|
|
|
public override bool Build()
|
|
{
|
|
return BuildManager.EditorBuildCallback();
|
|
}
|
|
|
|
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();
|
|
|
|
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.Title = "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.GetThemeIcon("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, Android, iOS and HTML5, but not yet to 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.Toggled += enabled =>
|
|
{
|
|
bool showOnStart = (bool)editorSettings.GetSetting("mono/editor/show_info_on_start");
|
|
if (showOnStart != enabled)
|
|
editorSettings.SetSetting("mono/editor/show_info_on_start", enabled);
|
|
};
|
|
aboutVBox.AddChild(aboutDialogCheckBox);
|
|
}
|
|
|
|
if (File.Exists(GodotSharpDirs.ProjectSlnPath) && File.Exists(GodotSharpDirs.ProjectCsProjPath))
|
|
{
|
|
try
|
|
{
|
|
// Migrate solution from old configuration names to: Debug, ExportDebug and ExportRelease
|
|
DotNetSolution.MigrateFromOldConfigNames(GodotSharpDirs.ProjectSlnPath);
|
|
|
|
var msbuildProject = ProjectUtils.Open(GodotSharpDirs.ProjectCsProjPath)
|
|
?? throw new Exception("Cannot open C# project");
|
|
|
|
// NOTE: The order in which changes are made to the project is important
|
|
|
|
// Migrate csproj from old configuration names to: Debug, ExportDebug and ExportRelease
|
|
ProjectUtils.MigrateFromOldConfigNames(msbuildProject);
|
|
|
|
// Apply the other fixes only after configurations have been migrated
|
|
|
|
// Make sure the existing project has the ProjectTypeGuids property (for VisualStudio)
|
|
ProjectUtils.EnsureHasProjectTypeGuids(msbuildProject);
|
|
|
|
// Make sure the existing project has Api assembly references configured correctly
|
|
ProjectUtils.FixApiHintPath(msbuildProject);
|
|
|
|
// Make sure the existing project references the Microsoft.NETFramework.ReferenceAssemblies nuget package
|
|
ProjectUtils.EnsureHasNugetNetFrameworkRefAssemblies(msbuildProject);
|
|
|
|
if (msbuildProject.HasUnsavedChanges)
|
|
{
|
|
// Save a copy of the project before replacing it
|
|
FileUtils.SaveBackupCopy(GodotSharpDirs.ProjectCsProjPath);
|
|
|
|
msbuildProject.Save();
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
GD.PushError(e.ToString());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bottomPanelBtn.Hide();
|
|
menuPopup.AddItem("Create C# solution".TTR(), (int)MenuOptions.CreateSln);
|
|
}
|
|
|
|
menuPopup.IdPressed += _MenuOptionPressed;
|
|
|
|
var buildButton = new Button
|
|
{
|
|
Text = "Build",
|
|
HintTooltip = "Build solution",
|
|
FocusMode = Control.FocusModeEnum.None
|
|
};
|
|
buildButton.PressedSignal += _BuildSolutionPressed;
|
|
AddControlToContainer(CustomControlContainer.Toolbar, buildButton);
|
|
|
|
// External editor settings
|
|
EditorDef("mono/editor/external_editor", ExternalEditorId.None);
|
|
|
|
string settingsHintStr = "Disabled";
|
|
|
|
if (OS.IsWindows)
|
|
{
|
|
settingsHintStr += $",Visual Studio:{(int)ExternalEditorId.VisualStudio}" +
|
|
$",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);
|
|
}
|
|
|
|
protected override void Dispose(bool disposing)
|
|
{
|
|
base.Dispose(disposing);
|
|
|
|
if (exportPluginWeak != null)
|
|
{
|
|
// We need to dispose our export plugin before the editor destroys EditorSettings.
|
|
// Otherwise, if the GC disposes it at a later time, EditorExportPlatformAndroid
|
|
// will be freed after EditorSettings already was, and its device polling thread
|
|
// will try to access the EditorSettings singleton, resulting in null dereferencing.
|
|
(exportPluginWeak.GetRef() as ExportPlugin)?.Dispose();
|
|
|
|
exportPluginWeak.Dispose();
|
|
}
|
|
|
|
GodotIdeManager?.Dispose();
|
|
}
|
|
|
|
public void OnBeforeSerialize()
|
|
{
|
|
}
|
|
|
|
public void OnAfterDeserialize()
|
|
{
|
|
Instance = this;
|
|
}
|
|
|
|
// Singleton
|
|
|
|
public static GodotSharpEditor Instance { get; private set; }
|
|
|
|
private GodotSharpEditor()
|
|
{
|
|
}
|
|
}
|
|
}
|