feat: improve performance and add support for custom vs code install locations

Author: JonahFintzDev

VsCode/Classes/VSCodeHandler.cs

@@ -1,6 +1,7 @@
 using Microsoft.Data.Sqlite;
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.IO;
 using System.Text.Json;
 
@@ -30,11 +31,79 @@ public static void LoadInstances(string preferredEdition)
         AddInstance("VS Code - Insiders", Path.Combine(appdataProgramFilesPath, "Programs", "Microsoft VS Code Insiders", "Code - Insiders.exe"), insiderStoragePath, VSCodeInstallationType.User, VSCodeType.Insider);
         AddInstance("VS Code - Insiders [System]", Path.Combine(programsFolderPathBase, "Microsoft VS Code Insiders", "Code - Insiders.exe"), insiderStoragePath, VSCodeInstallationType.System, VSCodeType.Insider);
 
+        // search for custom installations in PATH environment variable
+        try
+        {
+            var pathEnv = Environment.GetEnvironmentVariable("PATH");
+            if (!string.IsNullOrEmpty(pathEnv))
+            {
+                var paths = pathEnv.Split(Path.PathSeparator, StringSplitOptions.RemoveEmptyEntries);
+                foreach (var dir in paths)
+                {
+
+                    // get parent directory of the current directory
+                    if (string.IsNullOrEmpty(dir) || !Directory.Exists(dir))
+                    {
+                        continue;
+                    }
+                    var parentDir = Path.GetDirectoryName(dir) ?? dir;
+                    try
+                    {
+                        var codeExe = Path.Combine(parentDir, "code.exe");
+                        var codeInsidersExe = Path.Combine(parentDir, "Code - Insiders.exe");
+
+                        if (File.Exists(codeExe))
+                        {
+                            AddInstance("VS Code [Custom]", codeExe, defaultStoragePath, VSCodeInstallationType.User, VSCodeType.Default);
+                        }
+                        if (File.Exists(codeInsidersExe))
+                        {
+                            AddInstance("VS Code - Insiders [Custom]", codeInsidersExe, insiderStoragePath, VSCodeInstallationType.User, VSCodeType.Insider);
+                        }
+                    }
+                    catch
+                    {
+                        // ignore any errors while checking for custom installations
+                    }
+                }
+            }
+        }
+        catch
+        {
+            // ignore invalid PATH entries
+        }
 
         if (preferredEdition == "Insider")
         {
-            // Reverse the order of the instances
-            Instances.Reverse();
+            // sort instances to have insiders first
+            Instances.Sort((x, y) =>
+            {
+                if (x.VSCodeType == VSCodeType.Insider && y.VSCodeType != VSCodeType.Insider)
+                {
+                    return -1;
+                }
+                else if (x.VSCodeType != VSCodeType.Insider && y.VSCodeType == VSCodeType.Insider)
+                {
+                    return 1;
+                }
+                return 0;
+            });
+        }
+        else
+        {
+            // sort instances to have default first
+            Instances.Sort((x, y) =>
+            {
+                if (x.VSCodeType == VSCodeType.Default && y.VSCodeType != VSCodeType.Default)
+                {
+                    return -1;
+                }
+                else if (x.VSCodeType != VSCodeType.Default && y.VSCodeType == VSCodeType.Default)
+                {
+                    return 1;
+                }
+                return 0;
+            });
         }
     }
 
@@ -50,6 +119,11 @@ private static void AddInstance(string name, string path, string storagePath, VS
     {
         if (File.Exists(path))
         {
+            // check if there is already an instance with the same executable path
+            if (Instances.Exists(instance => instance.ExecutablePath.Equals(path, StringComparison.OrdinalIgnoreCase)))
+            {
+                return; // Instance already exists
+            }
             Instances.Add(new VSCodeInstance(name, path, storagePath, type, codeType));
         }
     }

VsCode/Classes/VSCodeInstance.cs

@@ -31,6 +31,7 @@ internal class VSCodeInstance
     public string StoragePath;
     public VSCodeInstallationType InstallationType;
     public VSCodeType VSCodeType;
+    public IconInfo Icon;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="VSCodeInstance"/> class.
@@ -47,13 +48,15 @@ public VSCodeInstance(string name, string executablePath, string storagePath, VS
         this.StoragePath = storagePath;
         this.InstallationType = installationType;
         this.VSCodeType = type;
+        this.Icon = GetIcon();
+
     }
 
     /// <summary>
     /// Gets the icon associated with the VS Code instance.
     /// </summary>
     /// <returns>An icon representing the VS Code instance.</returns>
-    public IIconInfo GetIcon()
+    private IconInfo GetIcon()
     {
         switch (VSCodeType)
         {

VsCode/Classes/VSCodeWorkspace.cs

@@ -23,6 +23,10 @@ internal class VSCodeWorkspace
     public VSCodeInstance Instance;
     public string Path;
     public VSCodeWorkspaceType VSCodeWorkspaceType;
+    public string WorkspaceName = "";
+    public string VSTypeString = "";
+    public string WorkspaceTypeString = "";
+    public DetailsElement[] Details = [];
 
     /// <summary>
     /// Initializes a new instance of the <see cref="VSCodeWorkspace"/> class.
@@ -34,72 +38,76 @@ public VSCodeWorkspace(VSCodeInstance instance, string path, VSCodeWorkspaceType
         this.Path = path;
         this.Instance = instance;
         this.VSCodeWorkspaceType = vsCodeWorkspaceType;
+
+        SetName();
+        SetVSType();
+        SetWorkspaceType();
+        SetMetadata();
     }
 
     /// <summary>
-    /// Gets the name of the workspace.
+    /// Sets the name of the workspace.
     /// </summary>
     /// <returns>The name of the workspace.</returns>
-    public string GetName()
+    public void SetName()
     {
-        string workspaceName = "";
+        WorkspaceName = "";
 
         // split name by / and get last part
         var nameParts = Uri.UnescapeDataString(Path).Split('/');
         if (nameParts.Length == 0)
         {
-            return workspaceName;
+            return;
         }
 
-        workspaceName = nameParts[nameParts.Length - 1];
+        WorkspaceName = nameParts[nameParts.Length - 1];
 
         if (VSCodeWorkspaceType == VSCodeWorkspaceType.Workspace)
         {
             // remove .code-workspace
-            workspaceName = workspaceName.Replace(".code-workspace", "");
+            WorkspaceName = WorkspaceName.Replace(".code-workspace", "");
 
             // if the workspace name is "workspace", use the folder name instead
-            if (workspaceName == "workspace" && nameParts.Length >= 2)
+            if (WorkspaceName == "workspace" && nameParts.Length >= 2)
             {
-                workspaceName = nameParts[nameParts.Length - 2];
+                WorkspaceName = nameParts[nameParts.Length - 2];
             }
         }
-
-        return workspaceName;
     }
 
     /// <summary>
     /// Determines the type of the workspace (e.g., Local, WSL, Remote).
     /// </summary>
     /// <returns>The type of the workspace as a string.</returns>
-    public string GetVSType()
+    public void SetVSType()
     {
         if (Path.StartsWith("vscode-remote://wsl", System.StringComparison.OrdinalIgnoreCase))
         {
-            return "WSL";
+            VSTypeString = "WSL";
         }
         else if (Path.StartsWith("vscode-remote://", System.StringComparison.OrdinalIgnoreCase))
         {
-            return "Remote";
+            VSTypeString = "Remote";
         }
-
-        return "";
     }
 
     /// <summary>
-    /// Gets the workspace type (e.g., Workspace, Folder).
+    /// Sets the workspace type (e.g., Workspace, Folder).
     /// </summary>
     /// <returns>The type of the workspace as a string.</returns>
-    public string GetWorkspaceType()
+    public void SetWorkspaceType()
     {
         switch (VSCodeWorkspaceType)
         {
             case VSCodeWorkspaceType.Workspace:
-                return "Workspace";
+                WorkspaceTypeString = "Workspace";
+                break;
             case VSCodeWorkspaceType.Folder:
-                return "Folder";
+                WorkspaceTypeString = "Folder";
+                break;
             default:
-                return "Unknown Type";
+                WorkspaceTypeString = "Unknown Type";
+                break;
         }
     }
 
@@ -108,15 +116,15 @@ public string GetWorkspaceType()
     /// Gets the details of the workspace.
     /// </summary>
     /// <returns>An array of details elements containing information about the workspace.</returns>
-    public DetailsElement[] GetMetadata()
+    public void SetMetadata()
     {
-        var typeTags = new List<Tag>() { new Tag(GetWorkspaceType()) };
-        if (GetVSType() != "")
+        var typeTags = new List<Tag>() { new Tag(WorkspaceTypeString) };
+        if (VSTypeString != "")
         {
-            typeTags.Add(new Tag(GetVSType()));
+            typeTags.Add(new Tag(VSTypeString));
         }
 
-        return new List<DetailsElement>(){
+        Details = new List<DetailsElement>(){
             new DetailsElement()
             {
                 Key = Resource.item_details_target,

VsCode/Commands/OpenVsCodeCommand.cs

@@ -47,6 +47,8 @@ public override CommandResult Invoke()
         page.UpdateSearchText(page.SearchText, "");
         page.SearchText = "";
 
-        return CommandResult.Hide();
+        VSCodePage.LoadItems = true;
+
+        return CommandResult.GoHome();
     }
 }