fixed

Author: BRUNER Patrick

src/LogExpert.Configuration/ConfigManager.cs

@@ -46,6 +46,7 @@ public class ConfigManager : IConfigManager
     };
 
     private const string SETTINGS_FILE_NAME = "settings.json";
+    private const int MAX_FILE_HISTORY = 10;
 
     #endregion
 
@@ -251,6 +252,35 @@ public void ImportHighlightSettings (FileInfo fileInfo, ExportImportFlags import
         Save(SettingsFlags.All);
     }
 
+    /// <summary>
+    /// Adds the specified file name to the file history list, moving it to the top if it already exists.
+    /// </summary>
+    /// <remarks>If the file name already exists in the history, it is moved to the top of the list. The file
+    /// history list is limited to a maximum number of entries; the oldest entries are removed if the limit is exceeded.
+    /// This method is supported only on Windows platforms.</remarks>
+    /// <param name="fileName">The name of the file to add to the file history list. Comparison is case-insensitive.</param>
+    [SupportedOSPlatform("windows")]
+    public void AddToFileHistory (string fileName)
+    {
+        bool findName (string s) => s.ToUpperInvariant().Equals(fileName.ToUpperInvariant(), StringComparison.Ordinal);
+
+        var index = Instance.Settings.FileHistoryList.FindIndex(findName);
+
+        if (index != -1)
+        {
+            Instance.Settings.FileHistoryList.RemoveAt(index);
+        }
+
+        Instance.Settings.FileHistoryList.Insert(0, fileName);
+
+        while (Instance.Settings.FileHistoryList.Count > MAX_FILE_HISTORY)
+        {
+            Instance.Settings.FileHistoryList.RemoveAt(Instance.Settings.FileHistoryList.Count - 1);
+        }
+
+        Save(SettingsFlags.FileHistory);
+    }
+
     #endregion
 
     #region Private Methods
@@ -1061,6 +1091,7 @@ private bool ValidateSettings (Settings settings)
 
         return true;
     }
+
     #endregion
 
     /// <summary>

src/LogExpert.Core/Classes/Persister/PersisterHelpers.cs

@@ -0,0 +1,71 @@
+using System.Collections.ObjectModel;
+
+using LogExpert.Core.Interface;
+
+namespace LogExpert.Core.Classes.Persister;
+
+public static class PersisterHelpers
+{
+
+    private const string LOCAL_FILE_SYSTEM_NAME = "LocalFileSystem";
+
+    /// <summary>
+    /// Checks if the file name is a settings file (.lxp). If so, the contained logfile name
+    /// is returned. If not, the given file name is returned unchanged.
+    /// </summary>
+    /// <param name="fileName">The file name to resolve</param>
+    /// <param name="pluginRegistry">Plugin registry for file system resolution (optional)</param>
+    /// <returns>The resolved log file path</returns>
+    public static string FindFilenameForSettings (string fileName, IPluginRegistry pluginRegistry)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(fileName, nameof(fileName));
+
+        if (fileName.EndsWith(".lxp", StringComparison.OrdinalIgnoreCase))
+        {
+            var persistenceData = Persister.Load(fileName);
+            if (persistenceData == null)
+            {
+                return fileName;
+            }
+
+            if (!string.IsNullOrEmpty(persistenceData.FileName))
+            {
+                if (pluginRegistry != null)
+                {
+                    var fs = pluginRegistry.FindFileSystemForUri(persistenceData.FileName);
+                    // Use file system plugin for non-local files (network, SFTP, etc.)
+                    if (fs != null && fs.GetType().Name != LOCAL_FILE_SYSTEM_NAME)
+                    {
+                        return persistenceData.FileName;
+                    }
+                }
+
+                // Handle rooted paths (absolute paths)
+                if (Path.IsPathRooted(persistenceData.FileName))
+                {
+                    return persistenceData.FileName;
+                }
+
+                // Handle relative paths in .lxp files
+                var dir = Path.GetDirectoryName(fileName);
+                return Path.Join(dir, persistenceData.FileName);
+            }
+        }
+
+        return fileName;
+    }
+
+    public static ReadOnlyCollection<string> FindFilenameForSettings (ReadOnlyCollection<string> fileNames, IPluginRegistry pluginRegistry)
+    {
+        ArgumentNullException.ThrowIfNull(fileNames);
+
+        var foundFiles = new List<string>(fileNames.Count);
+
+        foreach (var fileName in fileNames)
+        {
+            foundFiles.Add(FindFilenameForSettings(fileName, pluginRegistry));
+        }
+
+        return foundFiles.AsReadOnly();
+    }
+}

src/LogExpert.Core/Classes/Persister/PersisterXML.cs

@@ -601,7 +601,8 @@ public static PersistenceData Load (string fileName)
         }
         catch (Exception xmlParsingException) when (xmlParsingException is XmlException or
                                                                            UnauthorizedAccessException or
-                                                                           IOException)
+                                                                           IOException or
+                                                                           FileNotFoundException)
         {
             _logger.Error(xmlParsingException, $"Error loading persistence data from {fileName}, unknown format, parsing xml or json was not possible");
             return null;

src/LogExpert.Core/Classes/Persister/ProjectFileResolver.cs

@@ -0,0 +1,34 @@
+using System.Collections.ObjectModel;
+
+using LogExpert.Core.Interface;
+
+namespace LogExpert.Core.Classes.Persister;
+
+/// <summary>
+/// Helper class to resolve project file references to actual log files.
+/// Handles .lxp (persistence) files by extracting the actual log file path.
+/// </summary>
+public static class ProjectFileResolver
+{
+    /// <summary>
+    /// Resolves project file names to actual log files.
+    /// If a file is a .lxp persistence file, extracts the log file path from it.
+    /// </summary>
+    /// <param name="projectData">The project data containing file references</param>
+    /// <param name="pluginRegistry">Plugin registry for file system resolution (optional)</param>
+    /// <returns>List of tuples containing (logFilePath, originalFilePath)</returns>
+    public static ReadOnlyCollection<(string LogFile, string OriginalFile)> ResolveProjectFiles (ProjectData projectData, IPluginRegistry pluginRegistry = null)
+    {
+        ArgumentNullException.ThrowIfNull(projectData);
+
+        var resolved = new List<(string LogFile, string OriginalFile)>();
+
+        foreach (var fileName in projectData.FileNames)
+        {
+            var logFile = PersisterHelpers.FindFilenameForSettings(fileName, pluginRegistry);
+            resolved.Add((logFile, fileName));
+        }
+
+        return resolved.AsReadOnly();
+    }
+}

src/LogExpert.Core/Classes/Persister/ProjectLoadResult.cs

@@ -6,7 +6,7 @@ namespace LogExpert.Core.Classes.Persister;
 public class ProjectLoadResult
 {
     /// <summary>
-    /// The loaded project data.
+    /// The loaded project data (contains resolved log file paths).
     /// </summary>
     public ProjectData ProjectData { get; set; }
 
@@ -15,6 +15,14 @@ public class ProjectLoadResult
     /// </summary>
     public ProjectValidationResult ValidationResult { get; set; }
 
+    /// <summary>
+    /// Mapping of original file references to resolved log files.
+    /// Key: resolved log file path (.log)
+    /// Value: original file reference (.lxp or .log)
+    /// Used to update persistence files when user selects alternatives.
+    /// </summary>
+    public Dictionary<string, string> LogToOriginalFileMapping { get; set; } = [];
+
     /// <summary>
     /// Indicates whether the project has at least one valid file to load.
     /// </summary>

src/LogExpert.Core/Classes/Persister/ProjectPersister.cs

@@ -16,6 +16,7 @@ public static class ProjectPersister
 
     /// <summary>
     /// Loads the project session data from a specified file, including validation of referenced files.
+    /// Resolves .lxp persistence files to actual .log files before validation.
     /// </summary>
     /// <param name="projectFileName">The path to the project file (.lxj)</param>
     /// <param name="pluginRegistry">The plugin registry for file system validation</param>
@@ -35,13 +36,32 @@ public static ProjectLoadResult LoadProjectData (string projectFileName, IPlugin
             // Set project file path for alternative file search
             projectData.ProjectFilePath = projectFileName;
 
-            // Validate all files referenced in the project
-            var validationResult = ProjectFileValidator.ValidateProject(projectData, pluginRegistry);
+            // Resolve .lxp files to actual .log files
+            var resolvedFiles = ProjectFileResolver.ResolveProjectFiles(projectData, pluginRegistry);
+
+            // Create mapping: logFile → originalFile
+            var logToOriginalMapping = new Dictionary<string, string>();
+            foreach (var (logFile, originalFile) in resolvedFiles)
+            {
+                logToOriginalMapping[logFile] = originalFile;
+            }
+
+            // Create new ProjectData with resolved log file paths
+            var resolvedProjectData = new ProjectData
+            {
+                FileNames = [.. resolvedFiles.Select(r => r.LogFile)],
+                TabLayoutXml = projectData.TabLayoutXml,
+                ProjectFilePath = projectData.ProjectFilePath
+            };
+
+            // Validate the actual log files (not .lxp files)
+            var validationResult = ProjectFileValidator.ValidateProject(resolvedProjectData, pluginRegistry);
 
             return new ProjectLoadResult
             {
-                ProjectData = projectData,
-                ValidationResult = validationResult
+                ProjectData = resolvedProjectData,
+                ValidationResult = validationResult,
+                LogToOriginalFileMapping = logToOriginalMapping
             };
         }
         catch (Exception ex) when (ex is UnauthorizedAccessException or
@@ -55,13 +75,29 @@ IOException or
             // Set project file path for alternative file search
             projectData.ProjectFilePath = projectFileName;
 
-            // Validate files from XML fallback as well
-            var validationResult = ProjectFileValidator.ValidateProject(projectData, pluginRegistry);
+            // Resolve .lxp files for XML fallback as well
+            var resolvedFiles = ProjectFileResolver.ResolveProjectFiles(projectData, pluginRegistry);
+
+            var logToOriginalMapping = new Dictionary<string, string>();
+            foreach (var (logFile, originalFile) in resolvedFiles)
+            {
+                logToOriginalMapping[logFile] = originalFile;
+            }
+
+            var resolvedProjectData = new ProjectData
+            {
+                FileNames = [.. resolvedFiles.Select(r => r.LogFile)],
+                TabLayoutXml = projectData.TabLayoutXml,
+                ProjectFilePath = projectData.ProjectFilePath
+            };
+
+            var validationResult = ProjectFileValidator.ValidateProject(resolvedProjectData, pluginRegistry);
 
             return new ProjectLoadResult
             {
-                ProjectData = projectData,
-                ValidationResult = validationResult
+                ProjectData = resolvedProjectData,
+                ValidationResult = validationResult,
+                LogToOriginalFileMapping = logToOriginalMapping
             };
         }
     }

src/LogExpert.Core/Interface/IConfigManager.cs

@@ -142,4 +142,13 @@ public interface IConfigManager
     /// <exception cref="InvalidOperationException">Thrown if settings validation fails.</exception>
     /// <exception cref="IOException">Thrown if the file cannot be written.</exception>
     void Save (SettingsFlags flags);
+
+    /// <summary>
+    /// Adds the specified file name to the file history list, moving it to the top if it already exists.
+    /// </summary>
+    /// <remarks>If the file name already exists in the history, it is moved to the top of the list. The file
+    /// history list is limited to a maximum number of entries; the oldest entries are removed if the limit is exceeded.
+    /// This method is supported only on Windows platforms.</remarks>
+    /// <param name="fileName">The name of the file to add to the file history list. Comparison is case-insensitive.</param>
+    void AddToFileHistory (string fileName);
 }