Merge pull request #4057 from Flow-Launcher/last_history_show_result_icon

History results display actual result icon for Last Opened history style

Author: jjw24

Flow.Launcher.Plugin/Result.cs

@@ -4,11 +4,13 @@
 using System.Threading.Tasks;
 using System.Windows.Controls;
 using System.Windows.Media;
+using System.Text.Json.Serialization;
 
 namespace Flow.Launcher.Plugin
 {
     /// <summary>
-    /// Describes a result of a <see cref="Query"/> executed by a plugin
+    /// Describes a result of a <see cref="Query"/> executed by a plugin.
+    /// This or its child classes is serializable.
     /// </summary>
     public class Result
     {
@@ -21,6 +23,8 @@ public class Result
 
         private string _icoPath;
 
+        private string _icoPathAbsolute;
+
         private string _copyText = string.Empty;
 
         private string _badgeIcoPath;
@@ -64,15 +68,27 @@ public string CopyText
         public string AutoCompleteText { get; set; }
 
         /// <summary>
-        /// The image to be displayed for the result.
+        /// Path or URI to the icon image for this result.
+        /// Updates <see cref="IcoPathAbsolute"/> appropriately when set.
         /// </summary>
-        /// <value>Can be a local file path or a URL.</value>
-        /// <remarks>GlyphInfo is prioritized if not null</remarks>
+        /// <remarks>
+        /// Preferred usage: provide a path relative to the plugin directory (for example: "Images\icon.png").
+        /// Because <see cref="IcoPath"/> is serialized, using relative paths keeps the icon reference portable
+        /// when Flow is moved.
+        ///
+        /// Accepted formats:
+        /// - Relative file paths (resolved against <see cref="PluginDirectory"/> into <see cref="IcoPathAbsolute"/>)
+        /// - Absolute file paths (left as-is)
+        /// - HTTP/HTTPS URLs (left as-is)
+        /// - Data URIs (left as-is)
+        /// </remarks>
         public string IcoPath
         {
             get => _icoPath;
             set
             {
+                _icoPath = value;
+
                 // As a standard this property will handle prepping and converting to absolute local path for icon image processing
                 if (!string.IsNullOrEmpty(value)
                     && !string.IsNullOrEmpty(PluginDirectory)
@@ -81,15 +97,23 @@ public string IcoPath
                     && !value.StartsWith("https://", StringComparison.OrdinalIgnoreCase)
                     && !value.StartsWith("data:image", StringComparison.OrdinalIgnoreCase))
                 {
-                    _icoPath = Path.Combine(PluginDirectory, value);
+                    _icoPathAbsolute = Path.Combine(PluginDirectory, value);
                 }
                 else
                 {
-                    _icoPath = value;
+                    _icoPathAbsolute = value;
                 }
             }
         }
 
+        /// <summary>
+        /// Absolute path or URI which is used to load and display the result icon for Flow. 
+        /// This is populated by the <see cref="IcoPath"/> setter.
+        /// If a relative path was provided to <see cref="IcoPath"/>, this property will contain the resolved
+        /// absolute local path after combining with <see cref="PluginDirectory"/>.
+        /// </summary>
+        public string IcoPathAbsolute => _icoPathAbsolute;
+
         /// <summary>
         /// The image to be displayed for the badge of the result.
         /// </summary>
@@ -131,17 +155,34 @@ public string BadgeIcoPath
         /// <summary>
         /// Delegate to load an icon for this result.
         /// </summary>
+        [JsonIgnore]
         public IconDelegate Icon = null;
 
         /// <summary>
         /// Delegate to load an icon for the badge of this result.
         /// </summary>
+        [JsonIgnore]
         public IconDelegate BadgeIcon = null;
 
+        private GlyphInfo _glyph;
+
         /// <summary>
         /// Information for Glyph Icon (Prioritized than IcoPath/Icon if user enable Glyph Icons)
         /// </summary>
-        public GlyphInfo Glyph { get; init; }
+        public GlyphInfo Glyph
+        {
+            get => _glyph;
+            init => _glyph = value;
+        }
+
+        /// <summary>
+        /// Set the Glyph Icon after initialization
+        /// </summary>
+        /// <param name="glyph"></param>
+        public void SetGlyph(GlyphInfo glyph)
+        {
+            _glyph = glyph;
+        }
 
         /// <summary>
         /// An action to take in the form of a function call when the result has been selected.
@@ -151,6 +192,7 @@ public string BadgeIcoPath
         /// Its result determines what happens to Flow Launcher's query form:
         /// when true, the form will be hidden; when false, it will stay in focus.
         /// </remarks>
+        [JsonIgnore]
         public Func<ActionContext, bool> Action { get; set; }
 
         /// <summary>
@@ -161,6 +203,7 @@ public string BadgeIcoPath
         /// Its result determines what happens to Flow Launcher's query form:
         /// when true, the form will be hidden; when false, it will stay in focus.
         /// </remarks>
+        [JsonIgnore]
         public Func<ActionContext, ValueTask<bool>> AsyncAction { get; set; }
 
         /// <summary>
@@ -203,11 +246,13 @@ public string PluginDirectory
         /// <example>
         /// As external information for ContextMenu
         /// </example>
+        [JsonIgnore]
         public object ContextData { get; set; }
 
         /// <summary>
         /// Plugin ID that generated this result
         /// </summary>
+        [JsonInclude]
         public string PluginID { get; internal set; }
 
         /// <summary>
@@ -223,6 +268,7 @@ public string PluginDirectory
         /// <summary>
         /// Customized Preview Panel
         /// </summary>
+        [JsonIgnore]
         public Lazy<UserControl> PreviewPanel { get; set; }
 
         /// <summary>
@@ -352,6 +398,7 @@ public record PreviewInfo
             /// <summary>
             /// Delegate to get the preview panel's image
             /// </summary>
+            [JsonIgnore]
             public IconDelegate PreviewDelegate { get; set; } = null;
 
             /// <summary>

Flow.Launcher/App.xaml.cs

@@ -259,6 +259,9 @@ await API.StopwatchLogInfoAsync(ClassName, "Startup cost", async () =>
 
                     await PluginManager.InitializePluginsAsync(_mainVM);
 
+                    // Refresh the history results after plugins are initialized so that we can parse the absolute icon paths
+                    _mainVM.RefreshLastOpenedHistoryResults();
+
                     // Refresh home page after plugins are initialized because users may open main window during plugin initialization
                     // And home page is created without full plugin list
                     if (_settings.ShowHomePage && _mainVM.QueryResultsSelected() && string.IsNullOrEmpty(_mainVM.QueryText))

Flow.Launcher/Helper/ResultHelper.cs

@@ -11,7 +11,7 @@ namespace Flow.Launcher.Helper;
 
 public static class ResultHelper
 {
-    public static async Task<Result?> PopulateResultsAsync(LastOpenedHistoryItem item)
+    public static async Task<Result?> PopulateResultsAsync(LastOpenedHistoryResult item)
     {
         return await PopulateResultsAsync(item.PluginID, item.Query, item.Title, item.SubTitle, item.RecordKey);
     }
@@ -24,7 +24,7 @@ public static class ResultHelper
         if (query == null) return null;
         try
         {
-            var freshResults = await plugin.Plugin.QueryAsync(query, CancellationToken.None);
+            var freshResults = await PluginManager.QueryForPluginAsync(plugin, query, CancellationToken.None);
             // Try to match by record key first if it is valid, otherwise fall back to title + subtitle match
             if (string.IsNullOrEmpty(recordKey))
             {

Flow.Launcher/SettingPages/Views/SettingsPanePluginStore.xaml

@@ -333,7 +333,7 @@
                                         Margin="18 24 0 0"
                                         HorizontalAlignment="Left"
                                         RenderOptions.BitmapScalingMode="Fant"
-                                        Source="{Binding IcoPath, IsAsync=True}" />
+                                        Source="{Binding IcoPathAbsolute, IsAsync=True}" />
                                     <Border
                                         x:Name="LabelUpdate"
                                         Height="12"

Flow.Launcher/Storage/HistoryItem.cs

@@ -2,7 +2,7 @@
 
 namespace Flow.Launcher.Storage
 {
-    [Obsolete("Use LastOpenedHistoryItem instead. This class will be removed in future versions.")]
+    [Obsolete("Use LastOpenedHistoryResult instead. This class will be removed in future versions.")]
     public class HistoryItem
     {
         public string Query { get; set; }

Flow.Launcher/Storage/LastOpenedHistoryItem.cs

@@ -0,0 +1,146 @@
+using System;
+using Flow.Launcher.Infrastructure;
+using Flow.Launcher.Plugin;
+
+namespace Flow.Launcher.Storage;
+
+/// <summary>
+/// A serializable result used to record the last opened history for reopening results.
+/// Inherits common result fields from <see cref="Result"/> and adds the original query and execution time.
+/// </summary>
+public class LastOpenedHistoryResult : Result
+{
+    /// <summary>
+    /// The query string from Query.TrimmedQuery property, it is stored as a string instead of the entire Query class <see cref="Result"/>. 
+    /// This is used so results can be reopened or re-run using the serialized query string.
+    /// </summary>
+    public string Query { get; set; } = string.Empty;
+    
+    /// <summary>
+    /// The local date and time when this result was executed/opened.
+    /// </summary>
+    public DateTime ExecutedDateTime { get; set; }
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="LastOpenedHistoryResult"/>.
+    /// </summary>
+    public LastOpenedHistoryResult()
+    {
+    }
+
+    /// <summary>
+    /// Creates a <see cref="LastOpenedHistoryResult"/> from an existing <see cref="Result"/>.
+    /// Copies required fields and sets up default reopening actions.
+    /// </summary>
+    /// <param name="result">The original result to create history from.</param>
+    public LastOpenedHistoryResult(Result result)
+    {
+        Title = result.Title;
+        SubTitle = result.SubTitle;
+        PluginID = result.PluginID;
+        Query = result.OriginQuery.TrimmedQuery;
+        OriginQuery = result.OriginQuery;
+        RecordKey = result.RecordKey;
+        IcoPath = result.IcoPath;
+        PluginDirectory = result.PluginDirectory;
+        Glyph = result.Glyph;
+        ExecutedDateTime = DateTime.Now;
+        // Used for Query History style reopening
+        Action = _ =>
+        {
+            App.API.BackToQueryResults();
+            App.API.ChangeQuery(result.OriginQuery.TrimmedQuery);
+            return false;
+        };
+        // Used for Last Opened History style reopening, currently need to be assigned at MainViewModel.cs
+        AsyncAction = null;
+    }
+
+    /// <summary>
+    /// Selectively creates a deep copy of the required properties for <see cref="LastOpenedHistoryResult"/>
+    /// based on the style of history- Last Opened or Query.
+    /// This copy should be independent of original and full isolated.
+    /// </summary>
+    /// <returns>A new <see cref="LastOpenedHistoryResult"/> containing the same required data.</returns>
+    public LastOpenedHistoryResult DeepCopyForHistoryStyle(bool isHistoryStyleLastOpened)
+    {
+        // queryValue and glyphValue are captured to ensure they are correctly referenced in the Action delegate.
+        var queryValue = Query;
+        var glyphValue = Glyph;
+
+        var title = string.Empty;
+        var showBadge = false;
+        var badgeIcoPath = string.Empty;
+        var icoPath = string.Empty;
+        var glyph = null as GlyphInfo;
+
+        if (isHistoryStyleLastOpened)
+        {
+            title = Title;
+            icoPath = IcoPath;
+            glyph = glyphValue != null
+                        ? new GlyphInfo(glyphValue.FontFamily, glyphValue.Glyph)
+                        : null;
+            showBadge = true;
+            badgeIcoPath = Constant.HistoryIcon;
+        }
+        else
+        {
+            title = Localize.executeQuery(Query);
+            icoPath = Constant.HistoryIcon;
+            glyph = new GlyphInfo(FontFamily: "/Resources/#Segoe Fluent Icons", Glyph: "\uE81C");
+            showBadge = false;
+        }
+
+        return new LastOpenedHistoryResult
+        {
+            Title = title,
+            // Subtitle has datetime which can cause duplicates when saving.
+            SubTitle = Localize.lastExecuteTime(ExecutedDateTime),
+            // Empty PluginID so the source of last opened history results won't be updated, this copy is meant to be temporary.
+            PluginID = string.Empty,
+            Query = Query,
+            OriginQuery = new Query { TrimmedQuery = Query },
+            RecordKey = RecordKey,
+            IcoPath = icoPath,
+            ShowBadge = showBadge,
+            BadgeIcoPath = badgeIcoPath,
+            PluginDirectory = PluginDirectory,
+            // Used for Query History style reopening
+            Action = _ =>
+            {
+                App.API.BackToQueryResults();
+                App.API.ChangeQuery(queryValue);
+                return false;
+            },
+            // Used for Last Opened History style reopening, currently need to be assigned at MainViewModel.cs
+            AsyncAction = null,
+            Glyph = glyph,
+            ExecutedDateTime = ExecutedDateTime
+            // Note: Other properties are left as default — copy if needed.
+        };
+    }
+
+    /// <summary>
+    /// Determines whether the specified <see cref="Result"/> is equivalent to this history result.
+    /// Comparison uses <see cref="Result.RecordKey"/> when available; otherwise falls back to title/subtitle/plugin id and query.
+    /// </summary>
+    /// <param name="r">The result to compare to.</param>
+    /// <returns><c>true</c> if the results are considered equal; otherwise <c>false</c>.</returns>
+    public bool Equals(Result r)
+    {
+        if (string.IsNullOrEmpty(RecordKey) || string.IsNullOrEmpty(r.RecordKey))
+        {
+            return Title == r.Title
+                && SubTitle == r.SubTitle
+                && PluginID == r.PluginID
+                && Query == r.OriginQuery.TrimmedQuery;
+        }
+        else
+        {
+            return RecordKey == r.RecordKey
+                && PluginID == r.PluginID
+                && Query == r.OriginQuery.TrimmedQuery;
+        }
+    }
+}