Merge branch 'dev' into dev

Author: Jack251970

Flow.Launcher.Core/ExternalPlugins/PluginsManifest.cs

@@ -1,4 +1,4 @@
-using Flow.Launcher.Infrastructure.Logger;
+using Flow.Launcher.Infrastructure.Logger;
 using System;
 using System.Collections.Generic;
 using System.Threading;
@@ -21,7 +21,7 @@ public static class PluginsManifest
 
         public static List<UserPlugin> UserPlugins { get; private set; }
 
-        public static async Task UpdateManifestAsync(CancellationToken token = default, bool usePrimaryUrlOnly = false)
+        public static async Task<bool> UpdateManifestAsync(CancellationToken token = default, bool usePrimaryUrlOnly = false)
         {
             try
             {
@@ -31,8 +31,14 @@ public static async Task UpdateManifestAsync(CancellationToken token = default,
                 {
                     var results = await mainPluginStore.FetchAsync(token, usePrimaryUrlOnly).ConfigureAwait(false);
 
-                    UserPlugins = results;
-                    lastFetchedAt = DateTime.Now;
+                    // If the results are empty, we shouldn't update the manifest because the results are invalid.
+                    if (results.Count != 0)
+                    {
+                        UserPlugins = results;
+                        lastFetchedAt = DateTime.Now;
+
+                        return true;
+                    }
                 }
             }
             catch (Exception e)
@@ -43,6 +49,8 @@ public static async Task UpdateManifestAsync(CancellationToken token = default,
             {
                 manifestUpdateLock.Release();
             }
+
+            return false;
         }
     }
 }

Flow.Launcher.Core/Plugin/JsonRPCV2Models/JsonRPCPublicAPI.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.ComponentModel;
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Runtime.CompilerServices;
@@ -121,10 +120,10 @@ public Task<Stream> HttpGetStreamAsync(string url, CancellationToken token = def
             return _api.HttpGetStreamAsync(url, token);
         }
 
-        public Task HttpDownloadAsync([NotNull] string url, [NotNull] string filePath,
+        public Task HttpDownloadAsync([NotNull] string url, [NotNull] string filePath, Action<double> reportProgress = null,
             CancellationToken token = default)
         {
-            return _api.HttpDownloadAsync(url, filePath, token);
+            return _api.HttpDownloadAsync(url, filePath, reportProgress, token);
         }
 
         public void AddActionKeyword(string pluginId, string newActionKeyword)
@@ -162,16 +161,19 @@ public void OpenDirectory(string DirectoryPath, string FileNameOrFilePath = null
             _api.OpenDirectory(DirectoryPath, FileNameOrFilePath);
         }
 
-
         public void OpenUrl(string url, bool? inPrivate = null)
         {
             _api.OpenUrl(url, inPrivate);
         }
 
-
         public void OpenAppUri(string appUri)
         {
             _api.OpenAppUri(appUri);
         }
+
+        public void BackToQueryResults()
+        {
+            _api.BackToQueryResults();
+        }
     }
 }

Flow.Launcher.Infrastructure/FileExplorerHelper.cs

@@ -15,7 +15,20 @@ public static string GetActiveExplorerPath()
         {
             var explorerWindow = GetActiveExplorer();
             string locationUrl = explorerWindow?.LocationURL;
-            return !string.IsNullOrEmpty(locationUrl) ? new Uri(locationUrl).LocalPath + "\\" : null;
+            return !string.IsNullOrEmpty(locationUrl) ? GetDirectoryPath(new Uri(locationUrl).LocalPath) : null;
+        }
+
+        /// <summary>
+        /// Get directory path from a file path
+        /// </summary>
+        private static string GetDirectoryPath(string path)
+        {
+            if (!path.EndsWith("\\"))
+            {
+                return path + "\\";
+            }
+
+            return path;
         }
 
         /// <summary>

Flow.Launcher.Infrastructure/Http/Http.cs

@@ -83,15 +83,50 @@ var userName when string.IsNullOrEmpty(userName) =>
             }
         }
 
-        public static async Task DownloadAsync([NotNull] string url, [NotNull] string filePath, CancellationToken token = default)
+        public static async Task DownloadAsync([NotNull] string url, [NotNull] string filePath, Action<double> reportProgress = null, CancellationToken token = default)
         {
             try
             {
                 using var response = await client.GetAsync(url, HttpCompletionOption.ResponseHeadersRead, token);
+
                 if (response.StatusCode == HttpStatusCode.OK)
                 {
-                    await using var fileStream = new FileStream(filePath, FileMode.CreateNew);
-                    await response.Content.CopyToAsync(fileStream, token);
+                    var totalBytes = response.Content.Headers.ContentLength ?? -1L;
+                    var canReportProgress = totalBytes != -1;
+
+                    if (canReportProgress && reportProgress != null)
+                    {
+                        await using var contentStream = await response.Content.ReadAsStreamAsync(token);
+                        await using var fileStream = new FileStream(filePath, FileMode.CreateNew, FileAccess.Write, FileShare.None, 8192, true);
+
+                        var buffer = new byte[8192];
+                        long totalRead = 0;
+                        int read;
+                        double progressValue = 0;
+
+                        reportProgress(0);
+
+                        while ((read = await contentStream.ReadAsync(buffer, token)) > 0)
+                        {
+                            await fileStream.WriteAsync(buffer.AsMemory(0, read), token);
+                            totalRead += read;
+
+                            progressValue = totalRead * 100.0 / totalBytes;
+
+                            if (token.IsCancellationRequested)
+                                return;
+                            else
+                                reportProgress(progressValue);
+                        }
+
+                        if (progressValue < 100)
+                            reportProgress(100);
+                    }
+                    else
+                    {
+                        await using var fileStream = new FileStream(filePath, FileMode.CreateNew);
+                        await response.Content.CopyToAsync(fileStream, token);
+                    }
                 }
                 else
                 {

Flow.Launcher.Plugin/Interfaces/IPublicAPI.cs

@@ -1,4 +1,4 @@
-using Flow.Launcher.Plugin.SharedModels;
+using Flow.Launcher.Plugin.SharedModels;
 using JetBrains.Annotations;
 using System;
 using System.Collections.Generic;
@@ -181,9 +181,13 @@ public interface IPublicAPI
         /// </summary>
         /// <param name="url">URL to download file</param>
         /// <param name="filePath">path to save downloaded file</param>
+        /// <param name="reportProgress">
+        /// Action to report progress. The input of the action is the progress value which is a double value between 0 and 100.
+        /// It will be called if url support range request and the reportProgress is not null.
+        /// </param>
         /// <param name="token">place to store file</param>
         /// <returns>Task showing the progress</returns>
-        Task HttpDownloadAsync([NotNull] string url, [NotNull] string filePath, CancellationToken token = default);
+        Task HttpDownloadAsync([NotNull] string url, [NotNull] string filePath, Action<double> reportProgress = null, CancellationToken token = default);
 
         /// <summary>
         /// Add ActionKeyword for specific plugin
@@ -316,5 +320,19 @@ public interface IPublicAPI
         /// <param name="defaultResult">Specifies the default result of the message box.</param>
         /// <returns>Specifies which message box button is clicked by the user.</returns>
         public MessageBoxResult ShowMsgBox(string messageBoxText, string caption = "", MessageBoxButton button = MessageBoxButton.OK, MessageBoxImage icon = MessageBoxImage.None, MessageBoxResult defaultResult = MessageBoxResult.OK);
+
+        /// <summary>
+        /// Displays a standardised Flow message box.
+        /// If there is issue when showing the message box, it will return null.
+        /// </summary>
+        /// <param name="caption">The caption of the message box.</param>
+        /// <param name="reportProgressAsync">
+        /// Time-consuming task function, whose input is the action to report progress.
+        /// The input of the action is the progress value which is a double value between 0 and 100.
+        /// If there are any exceptions, this action will be null.
+        /// </param>
+        /// <param name="forceClosed">When user closes the progress box manually by button or esc key, this action will be called.</param>
+        /// <returns>A progress box interface.</returns>
+        public Task ShowProgressBoxAsync(string caption, Func<Action<double>, Task> reportProgressAsync, Action forceClosed = null);
     }
 }

Flow.Launcher.Plugin/Result.cs

@@ -185,6 +185,16 @@ public Result Clone()
                 TitleHighlightData = TitleHighlightData,
                 OriginQuery = OriginQuery,
                 PluginDirectory = PluginDirectory,
+                ContextData = ContextData,
+                PluginID = PluginID,
+                TitleToolTip = TitleToolTip,
+                SubTitleToolTip = SubTitleToolTip,
+                PreviewPanel = PreviewPanel,
+                ProgressBar = ProgressBar,
+                ProgressBarColor = ProgressBarColor,
+                Preview = Preview,
+                AddSelectedCount = AddSelectedCount,
+                RecordKey = RecordKey
             };
         }
 
@@ -252,6 +262,13 @@ public ValueTask<bool> ExecuteAsync(ActionContext context)
         /// </summary>
         public const int MaxScore = int.MaxValue;
 
+        /// <summary>
+        /// The key to identify the record. This is used when FL checks whether the result is the topmost record. Or FL calculates the hashcode of the result for user selected records.
+        /// This can be useful when your plugin will change the Title or SubTitle of the result dynamically.
+        /// If the plugin does not specific this, FL just uses Title and SubTitle to identify this result.
+        /// </summary>
+        public string RecordKey { get; set; } = string.Empty;
+
         /// <summary>
         /// Info of the preview section of a <see cref="Result"/>
         /// </summary>

Flow.Launcher/Flow.Launcher.csproj

@@ -100,7 +100,7 @@
     <PackageReference Include="NHotkey.Wpf" Version="3.0.0" />
     <PackageReference Include="PropertyChanged.Fody" Version="3.4.0" />
     <PackageReference Include="SemanticVersioning" Version="3.0.0" />
-    <PackageReference Include="VirtualizingWrapPanel" Version="2.1.0" />
+    <PackageReference Include="VirtualizingWrapPanel" Version="2.1.1" />
   </ItemGroup>
 
   <ItemGroup>

Flow.Launcher/Helper/WindowsInteropHelper.cs

@@ -148,4 +148,64 @@ public static Point TransformPixelsToDIP(Visual visual, double unitX, double uni
 
         return new Point((int)(matrix.M11 * unitX), (int)(matrix.M22 * unitY));
     }
+
+    #region Alt Tab
+
+    private static int SetWindowLong(HWND hWnd, WINDOW_LONG_PTR_INDEX nIndex, int dwNewLong)
+    {
+        PInvoke.SetLastError(WIN32_ERROR.NO_ERROR); // Clear any existing error
+
+        var result = PInvoke.SetWindowLong(hWnd, nIndex, dwNewLong);
+        if (result == 0 && Marshal.GetLastPInvokeError() != 0)
+        {
+            throw new Win32Exception(Marshal.GetLastPInvokeError());
+        }
+
+        return result;
+    }
+
+    /// <summary>
+    /// Hide windows in the Alt+Tab window list
+    /// </summary>
+    /// <param name="window">To hide a window</param>
+    public static void HideFromAltTab(Window window)
+    {
+        var exStyle = GetCurrentWindowStyle(window);
+
+        // Add TOOLWINDOW style, remove APPWINDOW style
+        var newExStyle = ((uint)exStyle | (uint)WINDOW_EX_STYLE.WS_EX_TOOLWINDOW) & ~(uint)WINDOW_EX_STYLE.WS_EX_APPWINDOW;
+
+        SetWindowLong(new(new WindowInteropHelper(window).Handle), WINDOW_LONG_PTR_INDEX.GWL_EXSTYLE, (int)newExStyle);
+    }
+
+    /// <summary>
+    /// Restore window display in the Alt+Tab window list.
+    /// </summary>
+    /// <param name="window">To restore the displayed window</param>
+    public static void ShowInAltTab(Window window)
+    {
+        var exStyle = GetCurrentWindowStyle(window);
+
+        // Remove the TOOLWINDOW style and add the APPWINDOW style.
+        var newExStyle = ((uint)exStyle & ~(uint)WINDOW_EX_STYLE.WS_EX_TOOLWINDOW) | (uint)WINDOW_EX_STYLE.WS_EX_APPWINDOW;
+
+        SetWindowLong(new(new WindowInteropHelper(window).Handle), WINDOW_LONG_PTR_INDEX.GWL_EXSTYLE, (int)newExStyle);
+    }
+
+    /// <summary>
+    /// To obtain the current overridden style of a window.
+    /// </summary>
+    /// <param name="window">To obtain the style dialog window</param>
+    /// <returns>current extension style value</returns>
+    private static int GetCurrentWindowStyle(Window window)
+    {
+        var style = PInvoke.GetWindowLong(new(new WindowInteropHelper(window).Handle), WINDOW_LONG_PTR_INDEX.GWL_EXSTYLE);
+        if (style == 0 && Marshal.GetLastPInvokeError() != 0)
+        {
+            throw new Win32Exception(Marshal.GetLastPInvokeError());
+        }
+        return style;
+    }
+
+    #endregion
 }

Flow.Launcher/MainWindow.xaml

@@ -20,6 +20,7 @@
     Closing="OnClosing"
     Deactivated="OnDeactivated"
     Icon="Images/app.png"
+    SourceInitialized="OnSourceInitialized"
     Initialized="OnInitialized"
     Left="{Binding Settings.WindowLeft, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
     Loaded="OnLoaded"

Flow.Launcher/MainWindow.xaml.cs

@@ -171,6 +171,11 @@ private async void OnClosing(object sender, CancelEventArgs e)
             Environment.Exit(0);
         }
 
+        private void OnSourceInitialized(object sender, EventArgs e)
+        {
+            WindowsInteropHelper.HideFromAltTab(this);
+        }
+
         private void OnInitialized(object sender, EventArgs e)
         {
         }