fix: refactor editor custom cursors to only create each tool cursor once (#2459)

* fix: refactor editor custom cursors to only create each tool cursor once

* fix: make cursor creation non-fatal

Author: pandinocoder

Intersect.Editor/Configuration/ToolCursor.cs

@@ -5,6 +5,8 @@ namespace Intersect.Editor.Configuration;
 
 public sealed class ToolCursor
 {
+    public const string CursorsFolder = "resources/cursors";
+    
     public Point CursorClickPoint { get; set; }
 
     private static readonly Dictionary<EditingTool, ToolCursor> _toolCursorDict;
@@ -26,33 +28,32 @@ static ToolCursor()
 
     public static void Load()
     {
-        const string cursorFolder = "resources/cursors/";
-
-        if (!Directory.Exists(cursorFolder))
+        if (!Directory.Exists(CursorsFolder))
         {
             return;
         }
 
         foreach (EditingTool tool in Enum.GetValues(typeof(EditingTool)))
         {
-            var fileName = $"{cursorFolder}editor_{tool.ToString().ToLowerInvariant()}.json";
+            var fileName = $"editor_{tool.ToString().ToLowerInvariant()}.json";
+            var filePath = Path.Combine(CursorsFolder, fileName);
             ToolCursor toolCursor;
 
-            if (File.Exists(fileName))
+            if (File.Exists(filePath))
             {
                 if (!_toolCursorDict.TryGetValue(tool, out toolCursor))
                 {
                     continue;
                 }
 
-                var json = File.ReadAllText(fileName);
+                var json = File.ReadAllText(filePath);
                 toolCursor = JsonConvert.DeserializeObject<ToolCursor>(json);
             }
             else
             {
                 toolCursor = new ToolCursor();
                 var json = JsonConvert.SerializeObject(toolCursor);
-                File.WriteAllText(fileName, json);
+                File.WriteAllText(filePath, json);
             }
 
             _toolCursorDict[tool] = toolCursor;

Intersect.Editor/Core/Preferences.cs

@@ -7,6 +7,22 @@ namespace Intersect.Editor.Core;
 
 public static partial class Preferences
 {
+    private static bool? _enableCursorSprites;
+
+    public static bool EnableCursorSprites
+    {
+        get => _enableCursorSprites ??= LoadPreferenceBool(nameof(EnableCursorSprites)) ?? false;
+        set
+        {
+            if (_enableCursorSprites == value)
+            {
+                return;
+            }
+
+            _enableCursorSprites = value;
+            SavePreference(nameof(EnableCursorSprites), _enableCursorSprites.ToString() ?? string.Empty);
+        }
+    }
 
     public static void SavePreference(string key, string value)
     {
@@ -18,6 +34,17 @@ public static void SavePreference(string key, string value)
         regkey.SetValue(key, value);
     }
 
+    private static bool? LoadPreferenceBool(string key)
+    {
+        var rawPreference = LoadPreference(key);
+        if (string.IsNullOrWhiteSpace(rawPreference))
+        {
+            return null;
+        }
+
+        return Convert.ToBoolean(rawPreference);
+    }
+
     public static string LoadPreference(string key)
     {
         var regkey = Registry.CurrentUser.OpenSubKey("Software", false);

Intersect.Editor/Forms/DockingElements/frmMapEditor.cs

@@ -37,14 +37,6 @@ public partial class FrmMapEditor : DockContent
     private bool mMapChanged;
 
     // MapGrid Cursor
-    private Bitmap mCurSprite;
-
-    private readonly string mCurFolder = "resources/cursors/";
-
-    private string mCurPath;
-
-    private Point mCurClickPoint;
-
     private Timer cursorUpdateTimer;
 
     public struct IconInfo
@@ -2356,17 +2348,12 @@ private void pnlMapContainer_Resize(object sender, EventArgs e)
 
     private void picMap_MouseEnter(object sender, EventArgs e)
     {
-        var enableCursorSprites = Preferences.LoadPreference("EnableCursorSprites");
-
         if (!Globals.MapEditorWindow.DockPanel.Focused && Globals.CurrentEditor == -1)
         {
             Globals.MapEditorWindow.DockPanel.Focus();
         }
 
-        if (!string.IsNullOrEmpty(enableCursorSprites) && !Convert.ToBoolean(enableCursorSprites))
-        {
-            RemoveSpriteCursorInGrid();
-        }
+        RemoveSpriteCursorInGrid();
     }
 
     private void picMap_MouseLeave(object sender, EventArgs e)
@@ -2387,55 +2374,128 @@ private void CursorUpdateTimer_Tick(object sender, EventArgs e)
 
     private void SetCursorSpriteInGrid()
     {
-        if (!Directory.Exists(mCurFolder))
+        if (!Preferences.EnableCursorSprites)
         {
             return;
         }
 
-        var enableCursorSprites = Preferences.LoadPreference("EnableCursorSprites");
+        var currentTool = Globals.CurrentTool;
+        var toolCursor = GetOrCreateCursorForTool(currentTool);
+        Cursor = toolCursor ?? Cursors.Default;
+    }
 
-        if (!(!string.IsNullOrEmpty(enableCursorSprites) && Convert.ToBoolean(enableCursorSprites)))
+    private void RemoveSpriteCursorInGrid()
+    {
+        if (!_toolCursors.Contains(Cursor))
         {
+            // Exit instead of setting the cursor to default if it's not a custom cursor
             return;
         }
+        
+        Cursor = Cursors.Default;
+    }
 
-        mCurPath = $"{mCurFolder}editor_{Globals.CurrentTool.ToString().ToLowerInvariant()}.png";
+    private static Cursor? GetOrCreateCursorForTool(EditingTool editingTool)
+    {
+        if (_toolCursorCache.TryGetValue(editingTool, out var toolCursor))
+        {
+            return toolCursor;
+        }
 
-        if (!File.Exists(mCurPath))
+        if (!ToolCursor.ToolCursorDict.TryGetValue(editingTool, out var toolCursorInfo))
         {
-            return;
+            var loadedClickPointKeys = string.Join(", ", ToolCursor.ToolCursorDict.Keys);
+            Log.Error(
+                $"Unable to load click point for {editingTool}, click points only exist for: {loadedClickPointKeys}"
+            );
+            return null;
         }
 
-        mCurClickPoint = ToolCursor.ToolCursorDict[Globals.CurrentTool].CursorClickPoint;
-        mCurSprite = new Bitmap(mCurPath);
-        Cursor = CreateCursorInGrid(mCurSprite, mCurClickPoint);
-    }
+        if (!Directory.Exists(ToolCursor.CursorsFolder))
+        {
+            return null;
+        }
 
-    private void RemoveSpriteCursorInGrid()
-    {
-        if (mCurSprite == default)
+        var cursorFileName = $"editor_{editingTool.ToString().ToLowerInvariant()}.png";
+        var cursorPath = Path.Combine(ToolCursor.CursorsFolder, cursorFileName);
+        var cursorAbsolutePath = Path.GetFullPath(cursorPath);
+        var loggingCursorPath = cursorPath;
+#if DEBUG
+        loggingCursorPath = cursorAbsolutePath;
+#endif
+        if (!File.Exists(cursorAbsolutePath))
         {
-            return;
+            Log.Error(
+                $"Custom cursor texture '{cursorFileName}' does not exist in {ToolCursor.CursorsFolder} resolved to {loggingCursorPath}"
+            );
+            return null;
         }
 
-        mCurSprite.Dispose();
-        DestroyIcon(Cursor.Handle);
-        Cursor = Cursors.Default;
+        Bitmap cursorBitmap;
+        try
+        {
+            cursorBitmap = new Bitmap(cursorAbsolutePath);
+        }
+        catch (Exception exception)
+        {
+            Log.Error(exception, $"Failed to load custom cursor for {editingTool} resolved to {loggingCursorPath}");
+            return null;
+        }
+
+        toolCursor = CreateCursorInGrid(cursorBitmap, toolCursorInfo.CursorClickPoint, cursorFileName);
+        if (toolCursor == null)
+        {
+            return null;
+        }
+
+        _toolCursors.Add(toolCursor);
+        _toolCursorCache[editingTool] = toolCursor;
+
+        return toolCursor;
     }
 
     /// <summary>
     /// Creates a cursor from a bitmap depending on the user preferences and selected tool.
     /// </summary>
-    private Cursor CreateCursorInGrid(Bitmap bmp, Point curHotSpot)
+    private static Cursor? CreateCursorInGrid(Bitmap cursorBitmap, Point cursorClickPoint, string logName)
     {
-        DestroyIcon(Cursor.Handle);
-        IntPtr ptr = bmp.GetHicon();
-        IconInfo tmp = new IconInfo();
-        GetIconInfo(ptr, ref tmp);
-        tmp.XHotspot = curHotSpot.X;
-        tmp.YHotspot = curHotSpot.Y;
-        tmp.FIcon = false;
-        ptr = CreateIconIndirect(ref tmp);
-        return new Cursor(ptr);
+        try
+        {
+            IntPtr bitmapHicon = cursorBitmap.GetHicon();
+            if (bitmapHicon == IntPtr.Zero)
+            {
+                Log.Warn($"Failed to get bitmap icon handle for {logName}");
+                return null;
+            }
+
+            IconInfo cursorIconInfo = new IconInfo();
+            if (!GetIconInfo(bitmapHicon, ref cursorIconInfo))
+            {
+                Log.Warn($"Failed to get icon info for {logName}");
+                return null;
+            }
+
+            cursorIconInfo.XHotspot = cursorClickPoint.X;
+            cursorIconInfo.YHotspot = cursorClickPoint.Y;
+            cursorIconInfo.FIcon = false;
+
+            var cursorIcon = CreateIconIndirect(ref cursorIconInfo);
+            // ReSharper disable once InvertIf
+            if (cursorIcon == IntPtr.Zero)
+            {
+                Log.Warn($"Failed to create cursor icon for {logName}");
+                return null;
+            }
+
+            return new Cursor(cursorIcon);
+        }
+        catch (Exception exception)
+        {
+            Log.Error(exception, $"Error while creating cursor for {logName}");
+            return null;
+        }
     }
+
+    private static readonly HashSet<Cursor> _toolCursors = [];
+    private static readonly Dictionary<EditingTool, Cursor> _toolCursorCache = [];
 }

Intersect.Editor/Forms/frmOptions.cs

@@ -26,7 +26,6 @@ private void InitForm()
 
         // Load settings for the General tab
         var suppressTilesetWarning = Preferences.LoadPreference("SuppressTextureWarning");
-        var enableCursorSprites = Preferences.LoadPreference("EnableCursorSprites");
 
         if (suppressTilesetWarning == "")
         {
@@ -37,8 +36,7 @@ private void InitForm()
             chkSuppressTilesetWarning.Checked = Convert.ToBoolean(suppressTilesetWarning);
         }
 
-        chkCursorSprites.Checked = !string.IsNullOrEmpty(enableCursorSprites) &&
-                                   Convert.ToBoolean(enableCursorSprites);
+        chkCursorSprites.Checked = Preferences.EnableCursorSprites;
 
         txtGamePath.Text = Preferences.LoadPreference("ClientPath");
 
@@ -95,7 +93,7 @@ private void InitLocalization()
     private void frmOptions_FormClosing(object sender, FormClosingEventArgs e)
     {
         Preferences.SavePreference("SuppressTextureWarning", chkSuppressTilesetWarning.Checked.ToString());
-        Preferences.SavePreference("EnableCursorSprites", chkCursorSprites.Checked.ToString());
+        Preferences.EnableCursorSprites = chkCursorSprites.Checked;
         Preferences.SavePreference("ClientPath", txtGamePath.Text);
         Preferences.SavePreference("PackageUpdateAssets", chkPackageAssets.Checked.ToString());
         Preferences.SavePreference("SoundPackSize", nudSoundBatch.Value.ToString(CultureInfo.InvariantCulture));