From 3066252a1e2ae6b1048e6af45fd42b05ea4d4571 Mon Sep 17 00:00:00 2001
From: Darkaxt <github.com.20240110@remaxku.eu>
Date: Mon, 30 Mar 2026 17:35:20 +0200
Subject: [PATCH 1/2] Harden path comparisons for Sysnative-aware checks

---
 WindowsPathEditor/MainWindow.xaml    |  16 +-
 WindowsPathEditor/MainWindow.xaml.cs |  64 +++++--
 WindowsPathEditor/PathChecker.cs     | 240 ++++++++++++++++++-----
 WindowsPathEditor/PathEntry.cs       | 273 +++++++++++++++------------
 4 files changed, 409 insertions(+), 184 deletions(-)

diff --git a/WindowsPathEditor/MainWindow.xaml b/WindowsPathEditor/MainWindow.xaml
index 5a0fbf7..64c9523 100644
--- a/WindowsPathEditor/MainWindow.xaml
+++ b/WindowsPathEditor/MainWindow.xaml
@@ -108,10 +108,18 @@
                 </StackPanel>
             </Button>
 
-            <Border Height="20" />
-
-            <Button Padding="0,5" Click="Scan_Click">
-                <StackPanel>
+            <Border Height="20" />
+            <Button Click="AutoSort_Click" Padding="0,5">
+                <StackPanel>
+                    <TextBlock TextWrapping="WrapWithOverflow" TextAlignment="Center" FontWeight="Bold">Auto Sort</TextBlock>
+                    <TextBlock TextWrapping="WrapWithOverflow" TextAlignment="Center" FontSize="10" Margin="0,10,0,0">Suggest and apply better order for DLL resolution.</TextBlock>
+                </StackPanel>
+            </Button>
+
+            <Border Height="20" />
+
+            <Button Padding="0,5" Click="Scan_Click">
+                <StackPanel>
                     <TextBlock TextWrapping="WrapWithOverflow" TextAlignment="Center" FontWeight="Bold">Automatic</TextBlock>
                     <TextBlock TextWrapping="WrapWithOverflow" TextAlignment="Center" FontSize="10" Margin="0,10,0,0">Search C:\ for directories called "bin".</TextBlock>
                 </StackPanel>
diff --git a/WindowsPathEditor/MainWindow.xaml.cs b/WindowsPathEditor/MainWindow.xaml.cs
index c4a6785..529f7f4 100644
--- a/WindowsPathEditor/MainWindow.xaml.cs
+++ b/WindowsPathEditor/MainWindow.xaml.cs
@@ -216,10 +216,15 @@ private bool UserPathChanged
         /// <summary>
         /// Compare two path lists
         /// </summary>
-        private bool PathListEqual(IEnumerable<PathEntry> original, ObservableCollectionEx<AnnotatedPathEntry> edited)
-        {
-            return original.Count() == edited.Count() && original.Zip(edited, (a, b) => a.SymbolicPath == b.SymbolicPath).All(_ => _);
-        }
+        private bool PathListEqual(IEnumerable<PathEntry> original, ObservableCollectionEx<AnnotatedPathEntry> edited)
+        {
+            return original.Count() == edited.Count() && original.Zip(edited, (a, b) => a.SymbolicPath == b.SymbolicPath).All(_ => _);
+        }
+
+        private static bool PathListEqual(IEnumerable<PathEntry> left, IEnumerable<PathEntry> right)
+        {
+            return left.Count() == right.Count() && left.Zip(right, (a, b) => a.SymbolicPath == b.SymbolicPath).All(_ => _);
+        }
 
         /// <summary>
         /// Remove paths that don't exist or are listed multiple times
@@ -281,7 +286,7 @@ private void CanExplore(object sender, CanExecuteRoutedEventArgs e)
             e.CanExecute = false;
             try
             {
-                e.CanExecute = GetSelectedEntry(e) != null && Directory.Exists(GetSelectedEntry(e).Path.ActualPath);
+                e.CanExecute = GetSelectedEntry(e) != null && Directory.Exists(GetSelectedEntry(e).Path.ActualPathForAccess);
             }
             catch (Exception ex)
             {
@@ -340,9 +345,9 @@ private void CanSave(object sender, CanExecuteRoutedEventArgs e)
             e.CanExecute = UserPathChanged || SystemPathChanged;
         }
 
-        private void Scan_Click(object sender, RoutedEventArgs e)
-        {
-            var currentPaths = CompletePath.Select(_ => _.Path);
+        private void Scan_Click(object sender, RoutedEventArgs e)
+        {
+            var currentPaths = CompletePath.Select(_ => _.Path);
 
             var window = new ScanningWindow();
             var search = new SearchOperation("C:\\", 4, window);
@@ -355,9 +360,38 @@ private void Scan_Click(object sender, RoutedEventArgs e)
                     .Select(PathEntry.FromFilePath)
                     .Where(path => !currentPaths.Contains(path))
                     .Each(path => UserPath.Add(new AnnotatedPathEntry(path)));
-                UserPath.SupressNotification = false;
-            }
-        }
+                UserPath.SupressNotification = false;
+            }
+        }
+
+        private void AutoSort_Click(object sender, RoutedEventArgs e)
+        {
+            lock (stateLock)
+            {
+                var previousSystem = SystemPath.Select(_ => _.Path).ToList();
+                var previousUser = UserPath.Select(_ => _.Path).ToList();
+
+                var sortedSystem = checker.SuggestBestOrder(previousSystem).ToList();
+                var sortedUser = checker.SuggestBestOrder(previousUser).ToList();
+
+                if (PathListEqual(previousSystem, sortedSystem) && PathListEqual(previousUser, sortedUser))
+                {
+                    MessageBox.Show(
+                        "The current order already appears optimal for DLL conflict resolution.",
+                        "Auto Sort",
+                        MessageBoxButton.OK,
+                        MessageBoxImage.Information);
+                    return;
+                }
+
+                SetPaths(sortedSystem, sortedUser);
+                MessageBox.Show(
+                    "Applied suggested order based on DLL version winners.",
+                    "Auto Sort",
+                    MessageBoxButton.OK,
+                    MessageBoxImage.Information);
+            }
+        }
 
         private void Add_Click(object sender, RoutedEventArgs e)
         {
@@ -371,10 +405,10 @@ private void Add_Click(object sender, RoutedEventArgs e)
             }
         }
 
-        private void ShowIssues_Checked(object sender, RoutedEventArgs e)
-        {
-
-        }
+        private void ShowIssues_Checked(object sender, RoutedEventArgs e)
+        {
+
+        }
 
         private void Button_Click(object sender, RoutedEventArgs e)
         {
diff --git a/WindowsPathEditor/PathChecker.cs b/WindowsPathEditor/PathChecker.cs
index 2ab7673..e9310a9 100644
--- a/WindowsPathEditor/PathChecker.cs
+++ b/WindowsPathEditor/PathChecker.cs
@@ -7,8 +7,8 @@
 using System.Reactive.Linq;
 using System.Reactive.Concurrency;
 using System.IO;
-using System.Collections;
-using System.Diagnostics;
+using System.Collections;
+using System.Diagnostics;
 
 namespace WindowsPathEditor
 {
@@ -27,7 +27,8 @@ public class PathChecker : IDisposable
         /// <summary>
         /// Cache for the listFiles operation
         /// </summary>
-        private ConcurrentDictionary<string, IEnumerable<string>> fileCache = new ConcurrentDictionary<string,IEnumerable<string>>();
+        private ConcurrentDictionary<string, IEnumerable<string>> fileCache = new ConcurrentDictionary<string,IEnumerable<string>>();
+        private ConcurrentDictionary<string, Version> versionCache = new ConcurrentDictionary<string, Version>();
 
         /// <summary>
         /// The currently applicable path
@@ -49,15 +50,84 @@ public PathChecker(IEnumerable<string> extensions)
             thread.Start();
         }
 
-        /// <summary>
-        /// Check all paths in the given set
-        /// </summary>
-        public void Check(IEnumerable<AnnotatedPathEntry> paths)
-        {
+        /// <summary>
+        /// Check all paths in the given set
+        /// </summary>
+        public void Check(IEnumerable<AnnotatedPathEntry> paths)
+        {
             currentPath = paths.Select(_ => _.Path).ToList();
             abortCurrentCheck = true;
-            pathsToProcess.Add(paths.ToList());
-        }
+            pathsToProcess.Add(paths.ToList());
+        }
+
+        /// <summary>
+        /// Suggest a better order for the given path list, preferring directories that
+        /// win DLL version conflicts.
+        /// </summary>
+        public IEnumerable<PathEntry> SuggestBestOrder(IEnumerable<PathEntry> orderedPath)
+        {
+            var pathList = orderedPath.ToList();
+            if (pathList.Count <= 1) return pathList;
+
+            var scores = Enumerable.Repeat(0, pathList.Count).ToArray();
+            var owners = new Dictionary<string, List<int>>(StringComparer.OrdinalIgnoreCase);
+            for (var i = 0; i < pathList.Count; i++)
+            {
+                var path = pathList[i];
+                if (!path.Exists)
+                {
+                    scores[i] -= 1000;
+                    continue;
+                }
+
+                foreach (var dll in listFiles(path.ActualPath)
+                    .Where(file => string.Equals(Path.GetExtension(file), ".dll", StringComparison.OrdinalIgnoreCase))
+                    .Distinct(StringComparer.OrdinalIgnoreCase))
+                {
+                    if (!owners.ContainsKey(dll))
+                    {
+                        owners[dll] = new List<int>();
+                    }
+
+                    owners[dll].Add(i);
+                }
+            }
+
+            foreach (var owner in owners.Where(_ => _.Value.Count > 1))
+            {
+                var dll = owner.Key;
+                var candidateData = owner.Value
+                    .Select(index => new
+                    {
+                        Index = index,
+                        Version = GetFileVersion(pathList[index], dll)
+                    })
+                    .ToList();
+
+                var maxVersion = candidateData.Max(_ => _.Version);
+                var preferred = candidateData
+                    .Where(_ => _.Version == maxVersion)
+                    .OrderBy(_ => _.Index)
+                    .First();
+                var runtimeWinner = candidateData.OrderBy(_ => _.Index).First();
+
+                if (runtimeWinner.Index == preferred.Index)
+                {
+                    scores[runtimeWinner.Index] += 1;
+                }
+                else
+                {
+                    scores[runtimeWinner.Index] -= 2;
+                    scores[preferred.Index] += 2;
+                }
+            }
+
+            return pathList.Select((path, index) => new { Path = path, Index = index })
+                .OrderByDescending(_ => scores[_.Index])
+                .ThenBy(_ => _.Index)
+                .Select(_ => _.Path)
+                .ToList();
+        }
 
         /// <summary>
         /// Method to do the actual checking (call from thread)
@@ -73,11 +143,12 @@ private void DoCheck(IEnumerable<AnnotatedPathEntry> paths)
             }
         }
 
-        private void CheckPath(AnnotatedPathEntry path)
-        {
-            path.ClearIssues();
-            try
-            {
+        private void CheckPath(AnnotatedPathEntry path)
+        {
+            path.ClearIssues();
+            path.SeriousError = false;
+            try
+            {
                 if (!path.Path.Exists)
                 {
                     path.AddIssue("Does not exist");
@@ -85,10 +156,10 @@ private void CheckPath(AnnotatedPathEntry path)
                     return;
                 }
     
-                listFiles(path.Path.ActualPath)
-                    .Select(file => new { file=file, hit=FirstDir(file)})
-                    .Where(fh => fh.hit.Directory.ToLower() != path.Path.ActualPath.ToLower())
-                    .Each(fh => path.AddIssue(string.Format("{0} shadowed by {1}", fh.file, fh.hit.FullPath)));
+                listFiles(path.Path.ActualPath)
+                    .Select(file => new { file=file, hit=FirstDir(file)})
+                    .Where(fh => !string.Equals(fh.hit.Directory, path.Path.ActualPath, StringComparison.OrdinalIgnoreCase))
+                    .Each(fh => AddIssueIfNeeded(path, fh.file, fh.hit));
             }
             catch (Exception ex)
             {
@@ -145,37 +216,122 @@ public IEnumerable<PathMatch> Search(string prefix)
         /// <summary>
         /// List all files in a directory, returning them from cache if available to speed up subsequent searches
         /// </summary>
-        private IEnumerable<string> listFiles(string path)
-        {
-            IEnumerable<string> fromCache;
-            if (fileCache.TryGetValue(path, out fromCache))
-            {
-                foreach (var s in fromCache) yield return s;
-                yield break;
-            }
+        private IEnumerable<string> listFiles(string path)
+        {
+            var pathForAccess = ResolvePathForAccess(path);
+
+            IEnumerable<string> fromCache;
+            if (fileCache.TryGetValue(pathForAccess, out fromCache))
+            {
+                foreach (var s in fromCache) yield return s;
+                yield break;
+            }
 
             var files = new List<string>();
-            foreach (var f in Directory.EnumerateFiles(path)
-                .Where(_ => extensions.Contains(Path.GetExtension(_).ToLower()))
-                .Select(Path.GetFileName))
-            {
-                files.Add(f);
-                yield return f;
-            }
-
-            fileCache[path] = files;
-        }
+            foreach (var f in Directory.EnumerateFiles(pathForAccess)
+                .Where(_ => extensions.Contains(Path.GetExtension(_).ToLower()))
+                .Select(Path.GetFileName))
+            {
+                files.Add(f);
+                yield return f;
+            }
+
+            fileCache[pathForAccess] = files;
+        }
+
+        private static string ResolvePathForAccess(string path)
+        {
+            if (Environment.Is64BitOperatingSystem && !Environment.Is64BitProcess)
+            {
+                var windowsDir = Environment.GetFolderPath(Environment.SpecialFolder.Windows).TrimEnd('\\');
+                var system32 = Path.Combine(windowsDir, "System32");
+                if (path.StartsWith(system32, StringComparison.OrdinalIgnoreCase))
+                {
+                    var tail = path.Substring(system32.Length).TrimStart('\\');
+                    var sysnative = Path.Combine(Path.Combine(windowsDir, "Sysnative"), tail);
+                    if (Directory.Exists(sysnative))
+                    {
+                        return sysnative;
+                    }
+                }
+            }
+
+            return path;
+        }
 
         /// <summary>
         /// Find the file on the given paths and return the first match
         /// </summary>
         private PathMatch FirstDir(string filename)
         {
-            return currentPath
-                .Where(path => File.Exists(Path.Combine(path.ActualPath, filename)))
-                .Select(path => new PathMatch(path.ActualPath, filename))
-                .FirstOrDefault() ?? new PathMatch("", "");
-        }
+            return currentPath
+                .Where(path => File.Exists(Path.Combine(path.ActualPathForAccess, filename)))
+                .Select(path => new PathMatch(path.ActualPath, filename))
+                .FirstOrDefault() ?? new PathMatch("", "");
+        }
+
+        private void AddIssueIfNeeded(AnnotatedPathEntry path, string filename, PathMatch firstHit)
+        {
+            if (!string.Equals(Path.GetExtension(filename), ".dll", StringComparison.OrdinalIgnoreCase))
+            {
+                path.AddIssue(string.Format("{0} shadowed by {1}", filename, firstHit.FullPath));
+                return;
+            }
+
+            var candidatePaths = currentPath
+                .Where(entry => File.Exists(Path.Combine(entry.ActualPathForAccess, filename)))
+                .ToList();
+
+            if (candidatePaths.Count <= 1)
+            {
+                return;
+            }
+
+            var winningPath = candidatePaths
+                .Select(entry => new { Entry = entry, Version = GetFileVersion(entry, filename) })
+                .OrderByDescending(_ => _.Version)
+                .ThenBy(_ => candidatePaths.IndexOf(_.Entry))
+                .First();
+
+            var firstPath = candidatePaths.First();
+            if (firstPath.Equals(winningPath.Entry))
+            {
+                return;
+            }
+
+            path.AddIssue(string.Format(
+                "{0} v{1} shadowed by {2} (v{3})",
+                filename,
+                FormatVersion(winningPath.Version),
+                firstHit.FullPath,
+                FormatVersion(GetFileVersion(firstPath, filename))));
+        }
+
+        private Version GetFileVersion(PathEntry path, string filename)
+        {
+            var fullPath = Path.Combine(path.ActualPathForAccess, filename);
+            return versionCache.GetOrAdd(fullPath, _ =>
+            {
+                try
+                {
+                    var info = FileVersionInfo.GetVersionInfo(fullPath);
+                    if (info.FileMajorPart >= 0)
+                    {
+                        return new Version(info.FileMajorPart, info.FileMinorPart, info.FileBuildPart, info.FilePrivatePart);
+                    }
+                }
+                catch
+                {
+                }
+
+                return new Version(0, 0, 0, 0);
+            });
+        }
+
+        private static string FormatVersion(Version version)
+        {
+            return version == null ? "0.0.0.0" : version.ToString();
+        }
 
         public void Dispose()
         {
diff --git a/WindowsPathEditor/PathEntry.cs b/WindowsPathEditor/PathEntry.cs
index 2834f0d..68d6092 100644
--- a/WindowsPathEditor/PathEntry.cs
+++ b/WindowsPathEditor/PathEntry.cs
@@ -1,123 +1,150 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.ComponentModel;
-using System.IO;
-using System.Collections;
-using System.Text.RegularExpressions;
-
-namespace WindowsPathEditor
-{
-    public class PathEntry
-    {
-        public PathEntry(string symbolicPath)
-        {
-            SymbolicPath = symbolicPath
-                .Replace('/', '\\');
-
-            var invalidChars = new Regex("[" + Regex.Escape(string.Join("", Path.GetInvalidPathChars())) + "]");
-            SymbolicPath = invalidChars.Replace(SymbolicPath, "");
-
-            var stripLaterColons = new Regex("^(.*:.*):");
-            while (stripLaterColons.IsMatch(SymbolicPath))
-            {
-                SymbolicPath = stripLaterColons.Replace(SymbolicPath, "$1");
-            }
-        }
-
-        /// <summary>
-        /// The path with placeholders (%WINDIR%, etc...)
-        /// </summary>
-        public string SymbolicPath { get; private set; }
-
-        /// <summary>
-        /// The actual path
-        /// </summary>
-        public string ActualPath 
-        {
-            get { return Path.GetFullPath(Environment.ExpandEnvironmentVariables(SymbolicPath)).TrimEnd('\\'); }
-        }
-
-        /// <summary>
-        /// Whether the given directory actually exists
-        /// </summary>
-        public bool Exists
-        {
-            get { return Directory.Exists(ActualPath); }
-        }
-
-        public IEnumerable<PathMatch> Find(string prefix)
-        {
-            try
-            {
-                return Directory.EnumerateFiles(ActualPath, prefix + "*")
-                    .Select(file => new PathMatch(ActualPath, Path.GetFileName(file)));
-            } 
-            catch (IOException)
-            {
-                return Enumerable.Empty<PathMatch>();
-            } 
-            catch(ArgumentException)
-            {
-                return Enumerable.Empty<PathMatch>();
-            }
-        }
-
-        public override string ToString()
-        {
-            return SymbolicPath;
-        }
-
-        public override bool Equals(object obj)
-        {
-            if (!(obj is PathEntry)) return false;
-            return ((PathEntry)obj).ActualPath.ToLower() == ActualPath.ToLower();
-        }
-
-        public override int GetHashCode()
-        {
-            return ActualPath.ToLower().GetHashCode();
-        }
-
-        private static IEnumerable<DictionaryEntry> environment;
-
-        /// <summary>
-        /// Try to find an environment variable that matches part of the path and
-        /// return that, otherwise return a normal path entry.
-        /// </summary>
-        /// <remarks>
-        /// Be sure to return the longest possible entry, but don't include entries
-        /// of fewer than 4 characters (this is to avoid returning %HOMEDRIVE% all the
-        /// time, because that one is fairly uninteresting and confusing).
-        /// </remarks>
-        public static PathEntry FromFilePath(string path)
-        {
-            if (environment == null)
-            {
-                environment = GetEnvironment()
-                    .Where(entry => ((string)entry.Value).Length > 3)
-                    .OrderBy(entry => -((string)entry.Value).Length).ToList();
-            }
-
-            foreach (var e in environment)
-            {
-                var value = (string)e.Value;
-                if (value != "" && Directory.Exists(value) && path.StartsWith(value))
-                {
-                    return new PathEntry("%" + e.Key + "%" + path.Substring(value.Length));
-                }
-            }
-            return new PathEntry(path);
-        }
-
-        private static IEnumerable<DictionaryEntry> GetEnvironment()
-        {
-            var ls = new List<DictionaryEntry>();
-            foreach (var entry in Environment.GetEnvironmentVariables())
-                ls.Add((DictionaryEntry)entry);
-            return ls;
-        }
-
-    }
-}
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.ComponentModel;
+using System.IO;
+using System.Collections;
+using System.Text.RegularExpressions;
+
+namespace WindowsPathEditor
+{
+    public class PathEntry
+    {
+        public PathEntry(string symbolicPath)
+        {
+            SymbolicPath = symbolicPath
+                .Replace('/', '\\');
+
+            var invalidChars = new Regex("[" + Regex.Escape(string.Join("", Path.GetInvalidPathChars())) + "]");
+            SymbolicPath = invalidChars.Replace(SymbolicPath, "");
+
+            var stripLaterColons = new Regex("^(.*:.*):");
+            while (stripLaterColons.IsMatch(SymbolicPath))
+            {
+                SymbolicPath = stripLaterColons.Replace(SymbolicPath, "$1");
+            }
+        }
+
+        /// <summary>
+        /// The path with placeholders (%WINDIR%, etc...)
+        /// </summary>
+        public string SymbolicPath { get; private set; }
+
+        /// <summary>
+        /// The actual path
+        /// </summary>
+        public string ActualPath 
+        {
+            get { return Path.GetFullPath(Environment.ExpandEnvironmentVariables(SymbolicPath)).TrimEnd('\\'); }
+        }
+
+        /// <summary>
+        /// Path used for file system access (handles WOW64 redirection for System32)
+        /// </summary>
+        public string ActualPathForAccess
+        {
+            get
+            {
+                var actual = ActualPath;
+                if (Environment.Is64BitOperatingSystem && !Environment.Is64BitProcess)
+                {
+                    var windowsDir = Environment.GetFolderPath(Environment.SpecialFolder.Windows).TrimEnd('\\');
+                    var system32 = Path.Combine(windowsDir, "System32");
+                    if (actual.StartsWith(system32, StringComparison.OrdinalIgnoreCase))
+                    {
+                        var tail = actual.Substring(system32.Length).TrimStart('\\');
+                        var sysnative = Path.Combine(Path.Combine(windowsDir, "Sysnative"), tail);
+                        if (Directory.Exists(sysnative))
+                        {
+                            return sysnative;
+                        }
+                    }
+                }
+
+                return actual;
+            }
+        }
+
+        /// <summary>
+        /// Whether the given directory actually exists
+        /// </summary>
+        public bool Exists
+        {
+            get { return Directory.Exists(ActualPathForAccess); }
+        }
+
+        public IEnumerable<PathMatch> Find(string prefix)
+        {
+            try
+            {
+                return Directory.EnumerateFiles(ActualPathForAccess, prefix + "*")
+                    .Select(file => new PathMatch(ActualPath, Path.GetFileName(file)));
+            } 
+            catch (IOException)
+            {
+                return Enumerable.Empty<PathMatch>();
+            } 
+            catch(ArgumentException)
+            {
+                return Enumerable.Empty<PathMatch>();
+            }
+        }
+
+        public override string ToString()
+        {
+            return SymbolicPath;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (!(obj is PathEntry)) return false;
+            return string.Equals(((PathEntry)obj).ActualPath, ActualPath, StringComparison.OrdinalIgnoreCase);
+        }
+
+        public override int GetHashCode()
+        {
+            return StringComparer.OrdinalIgnoreCase.GetHashCode(ActualPath);
+        }
+
+        private static IEnumerable<DictionaryEntry> environment;
+
+        /// <summary>
+        /// Try to find an environment variable that matches part of the path and
+        /// return that, otherwise return a normal path entry.
+        /// </summary>
+        /// <remarks>
+        /// Be sure to return the longest possible entry, but don't include entries
+        /// of fewer than 4 characters (this is to avoid returning %HOMEDRIVE% all the
+        /// time, because that one is fairly uninteresting and confusing).
+        /// </remarks>
+        public static PathEntry FromFilePath(string path)
+        {
+            if (environment == null)
+            {
+                environment = GetEnvironment()
+                    .Where(entry => ((string)entry.Value).Length > 3)
+                    .OrderBy(entry => -((string)entry.Value).Length).ToList();
+            }
+
+            foreach (var e in environment)
+            {
+                var value = (string)e.Value;
+                if (value != "" && Directory.Exists(value) && path.StartsWith(value))
+                {
+                    return new PathEntry("%" + e.Key + "%" + path.Substring(value.Length));
+                }
+            }
+            return new PathEntry(path);
+        }
+
+        private static IEnumerable<DictionaryEntry> GetEnvironment()
+        {
+            var ls = new List<DictionaryEntry>();
+            foreach (var entry in Environment.GetEnvironmentVariables())
+                ls.Add((DictionaryEntry)entry);
+            return ls;
+        }
+
+    }
+}

From cc4d7fd35e9e9600ca3bee9cef54962b27e5cd68 Mon Sep 17 00:00:00 2001
From: Darkaxt <github.com.20240110@remaxku.eu>
Date: Tue, 28 Apr 2026 20:30:05 +0200
Subject: [PATCH 2/2] Resolve PR merge against current master

---
 WindowsPathEditor/MainWindow.xaml.cs | 41 ++++------------------------
 1 file changed, 6 insertions(+), 35 deletions(-)

diff --git a/WindowsPathEditor/MainWindow.xaml.cs b/WindowsPathEditor/MainWindow.xaml.cs
index aec324b..aefb462 100644
--- a/WindowsPathEditor/MainWindow.xaml.cs
+++ b/WindowsPathEditor/MainWindow.xaml.cs
@@ -338,9 +338,9 @@ private void CanSave(object sender, CanExecuteRoutedEventArgs e)
             e.CanExecute = UserPathChanged || SystemPathChanged;
         }
 
-        private void Scan_Click(object sender, RoutedEventArgs e)
-        {
-            var currentPaths = CompletePath.Select(_ => _.Path);
+        private void Scan_Click(object sender, RoutedEventArgs e)
+        {
+            var currentPaths = CompletePath.Select(_ => _.Path);
 
             var window = new ScanningWindow();
             var search = new SearchOperation("C:\\", 4, window);
@@ -351,38 +351,9 @@ private void Scan_Click(object sender, RoutedEventArgs e)
                 UserPath.SupressNotification = true;
                 ScanImportPlanner.SelectPathsToImport(window.Paths, currentPaths)
                     .Each(path => UserPath.Add(new AnnotatedPathEntry(path)));
-                UserPath.SupressNotification = false;
-            }
-        }
-
-        private void AutoSort_Click(object sender, RoutedEventArgs e)
-        {
-            lock (stateLock)
-            {
-                var previousSystem = SystemPath.Select(_ => _.Path).ToList();
-                var previousUser = UserPath.Select(_ => _.Path).ToList();
-
-                var sortedSystem = checker.SuggestBestOrder(previousSystem).ToList();
-                var sortedUser = checker.SuggestBestOrder(previousUser).ToList();
-
-                if (PathListEqual(previousSystem, sortedSystem) && PathListEqual(previousUser, sortedUser))
-                {
-                    MessageBox.Show(
-                        "The current order already appears optimal for DLL conflict resolution.",
-                        "Auto Sort",
-                        MessageBoxButton.OK,
-                        MessageBoxImage.Information);
-                    return;
-                }
-
-                SetPaths(sortedSystem, sortedUser);
-                MessageBox.Show(
-                    "Applied suggested order based on DLL version winners.",
-                    "Auto Sort",
-                    MessageBoxButton.OK,
-                    MessageBoxImage.Information);
-            }
-        }
+                UserPath.SupressNotification = false;
+            }
+        }
 
         private void AutoSort_Click(object sender, RoutedEventArgs e)
         {