Merge branch 'dev' into l10n_dev

Author: jjw24

Flow.Launcher.Core/Plugin/ExecutablePluginV2.cs

@@ -12,15 +12,9 @@ internal sealed class ExecutablePluginV2 : ProcessStreamPluginV2
 
         public ExecutablePluginV2(string filename)
         {
-            StartInfo = new ProcessStartInfo
-            {
-                FileName = filename,
-                UseShellExecute = false,
-                CreateNoWindow = true,
-                RedirectStandardOutput = true,
-                RedirectStandardError = true
-            };
+            StartInfo = new ProcessStartInfo { FileName = filename };
         }
 
+        protected override MessageHandlerType MessageHandler { get; } = MessageHandlerType.NewLineDelimited;
     }
 }

Flow.Launcher.Core/Plugin/JsonRPCPluginV2.cs

@@ -15,8 +15,6 @@ namespace Flow.Launcher.Core.Plugin
 {
     internal abstract class JsonRPCPluginV2 : JsonRPCPluginBase, IAsyncDisposable, IAsyncReloadable, IResultUpdated
     {
-        public abstract string SupportedLanguage { get; set; }
-
         public const string JsonRpc = "JsonRPC";
 
         protected abstract IDuplexPipe ClientPipe { get; set; }
@@ -41,17 +39,31 @@ protected override async Task<bool> ExecuteResultAsync(JsonRPCResult result)
             }
         }
 
+        private JoinableTaskFactory JTF { get; } = new JoinableTaskFactory(new JoinableTaskContext());
+
         public override List<Result> LoadContextMenus(Result selectedResult)
         {
-            throw new NotImplementedException();
+            try
+            {
+                var res = JTF.Run(() => RPC.InvokeWithCancellationAsync<JsonRPCQueryResponseModel>("context_menu",
+                    new object[] { selectedResult.ContextData }));
+
+                var results = ParseResults(res);
+
+                return results;
+            }
+            catch
+            {
+                return new List<Result>();
+            }
         }
 
         public override async Task<List<Result>> QueryAsync(Query query, CancellationToken token)
         {
             try
             {
                 var res = await RPC.InvokeWithCancellationAsync<JsonRPCQueryResponseModel>("query",
-                    new[] { query },
+                    new object[] { query, Settings.Inner },
                     token);
 
                 var results = ParseResults(res);
@@ -88,12 +100,26 @@ async Task ReadErrorAsync()
 
         public event ResultUpdatedEventHandler ResultsUpdated;
 
+        protected enum MessageHandlerType
+        {
+            HeaderDelimited,
+            LengthHeaderDelimited,
+            NewLineDelimited
+        }
+
+        protected abstract MessageHandlerType MessageHandler { get; }
+
 
         private void SetupJsonRPC()
         {
             var formatter = new SystemTextJsonFormatter { JsonSerializerOptions = RequestSerializeOption };
-            var handler = new NewLineDelimitedMessageHandler(ClientPipe,
-                formatter);
+            IJsonRpcMessageHandler handler = MessageHandler switch
+            {
+                MessageHandlerType.HeaderDelimited => new HeaderDelimitedMessageHandler(ClientPipe, formatter),
+                MessageHandlerType.LengthHeaderDelimited => new LengthHeaderMessageHandler(ClientPipe, formatter),
+                MessageHandlerType.NewLineDelimited => new NewLineDelimitedMessageHandler(ClientPipe, formatter),
+                _ => throw new ArgumentOutOfRangeException()
+            };
 
             RPC = new JsonRpc(handler, new JsonRPCPublicAPI(Context.API));
 

Flow.Launcher.Core/Plugin/NodePluginV2.cs

@@ -10,29 +10,21 @@ namespace Flow.Launcher.Core.Plugin
     /// <summary>
     /// Execution of JavaScript & TypeScript plugins
     /// </summary>
-    internal class NodePluginV2 : ProcessStreamPluginV2
+    internal sealed class NodePluginV2 : ProcessStreamPluginV2
     {
         public NodePluginV2(string filename)
         {
-            StartInfo = new ProcessStartInfo
-            {
-                FileName = filename,
-                UseShellExecute = false,
-                CreateNoWindow = true,
-                RedirectStandardOutput = true,
-                RedirectStandardError = true
-            };
+            StartInfo = new ProcessStartInfo { FileName = filename, };
         }
 
-        public override string SupportedLanguage { get; set; }
         protected override ProcessStartInfo StartInfo { get; set; }
 
         public override async Task InitAsync(PluginInitContext context)
         {
             StartInfo.ArgumentList.Add(context.CurrentPluginMetadata.ExecuteFilePath);
-            StartInfo.ArgumentList.Add(string.Empty);
-            StartInfo.WorkingDirectory = context.CurrentPluginMetadata.PluginDirectory;
             await base.InitAsync(context);
         }
+
+        protected override MessageHandlerType MessageHandler { get; } = MessageHandlerType.HeaderDelimited;
     }
 }

Flow.Launcher.Core/Plugin/ProcessStreamPluginV2.cs

@@ -1,11 +1,14 @@
-using System;
+#nullable enable
+
+using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO.Pipelines;
 using System.Threading.Tasks;
 using Flow.Launcher.Infrastructure;
 using Flow.Launcher.Plugin;
 using Meziantou.Framework.Win32;
+using Microsoft.VisualBasic.ApplicationServices;
 using Nerdbank.Streams;
 
 namespace Flow.Launcher.Core.Plugin
@@ -18,31 +21,37 @@ static ProcessStreamPluginV2()
         {
             _jobObject.SetLimits(new JobObjectLimits()
             {
-                Flags = JobObjectLimitFlags.KillOnJobClose | JobObjectLimitFlags.DieOnUnhandledException
+                Flags = JobObjectLimitFlags.KillOnJobClose | JobObjectLimitFlags.DieOnUnhandledException |
+                        JobObjectLimitFlags.SilentBreakawayOk
             });
-            
+
             _jobObject.AssignProcess(Process.GetCurrentProcess());
         }
 
-        public override string SupportedLanguage { get; set; }
-        protected sealed override IDuplexPipe ClientPipe { get; set; }
+        protected sealed override IDuplexPipe ClientPipe { get; set; } = null!;
 
         protected abstract ProcessStartInfo StartInfo { get; set; }
 
-        protected Process ClientProcess { get; set; }
+        protected Process ClientProcess { get; set; } = null!;
 
         public override async Task InitAsync(PluginInitContext context)
         {
             StartInfo.EnvironmentVariables["FLOW_VERSION"] = Constant.Version;
             StartInfo.EnvironmentVariables["FLOW_PROGRAM_DIRECTORY"] = Constant.ProgramDirectory;
             StartInfo.EnvironmentVariables["FLOW_APPLICATION_DIRECTORY"] = Constant.ApplicationDirectory;
 
-            StartInfo.ArgumentList.Add(context.CurrentPluginMetadata.ExecuteFilePath);
+            StartInfo.RedirectStandardError = true;
+            StartInfo.RedirectStandardInput = true;
+            StartInfo.RedirectStandardOutput = true;
+            StartInfo.CreateNoWindow = true;
+            StartInfo.UseShellExecute = false;
             StartInfo.WorkingDirectory = context.CurrentPluginMetadata.PluginDirectory;
 
-            ClientProcess = Process.Start(StartInfo);
-            ArgumentNullException.ThrowIfNull(ClientProcess);
-            
+            var process = Process.Start(StartInfo);
+            ArgumentNullException.ThrowIfNull(process);
+            ClientProcess = process;
+            _jobObject.AssignProcess(ClientProcess);
+
             SetupPipe(ClientProcess);
 
             ErrorStream = ClientProcess.StandardError;

Flow.Launcher.Core/Plugin/PythonPluginV2.cs

@@ -18,26 +18,25 @@ namespace Flow.Launcher.Core.Plugin
 {
     internal sealed class PythonPluginV2 : ProcessStreamPluginV2
     {
-        public override string SupportedLanguage { get; set; } = AllowedLanguage.Python;
         protected override ProcessStartInfo StartInfo { get; set; }
-        
+
         public PythonPluginV2(string filename)
         {
-            StartInfo = new ProcessStartInfo
-            {
-                FileName = filename,
-                UseShellExecute = false,
-                CreateNoWindow = true,
-                RedirectStandardOutput = true,
-                RedirectStandardError = true,
-                RedirectStandardInput = true
-            };
+            StartInfo = new ProcessStartInfo { FileName = filename, };
 
             var path = Path.Combine(Constant.ProgramDirectory, JsonRpc);
             StartInfo.EnvironmentVariables["PYTHONPATH"] = path;
 
             //Add -B flag to tell python don't write .py[co] files. Because .pyc contains location infos which will prevent python portable
             StartInfo.ArgumentList.Add("-B");
         }
+
+        public override async Task InitAsync(PluginInitContext context)
+        {
+            StartInfo.ArgumentList.Add(context.CurrentPluginMetadata.ExecuteFilePath);
+            await base.InitAsync(context);
+        }
+
+        protected override MessageHandlerType MessageHandler { get; } = MessageHandlerType.NewLineDelimited;
     }
 }

Flow.Launcher/MainWindow.xaml

@@ -186,6 +186,10 @@
             Key="F12"
             Command="{Binding ToggleGameModeCommand}"
             Modifiers="Ctrl" />
+        <KeyBinding
+            Key="C"
+            Modifiers="Ctrl+Shift"
+            Command="{Binding CopyAlternativeCommand}" />
         <KeyBinding
             Key="{Binding PreviewHotkey, Converter={StaticResource StringToKeyBindingConverter}, ConverterParameter='key'}"
             Command="{Binding TogglePreviewCommand}"

Flow.Launcher/ResultListBox.xaml.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.IO;
 using System.Windows;
 using System.Windows.Controls;
@@ -137,6 +137,8 @@ private void ResultList_MouseMove(object sender, MouseEventArgs e)
 
             isDragging = false;
 
+            App.API.HideMainWindow();
+
             var data = new DataObject(DataFormats.FileDrop, new[]
             {
                 path