Merge remote-tracking branch 'origin/dev'

Author: jjw24

Doc/app.ico

@@ -11,6 +11,7 @@
     <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
     <AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
+    <SatelliteResourceLanguages>en</SatelliteResourceLanguages>
   </PropertyGroup>
 
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
@@ -52,10 +53,11 @@
   </ItemGroup>
 
   <ItemGroup>
+    <PackageReference Include="FSharp.Core" Version="4.7.1" />
     <PackageReference Include="JetBrains.Annotations" Version="2019.1.3" />
     <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
     <PackageReference Include="squirrel.windows" Version="1.5.2" />
-    <PackageReference Include="PropertyChanged.Fody" Version="2.2.4">
+    <PackageReference Include="PropertyChanged.Fody" Version="3.2.8">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>

Doc/app.png

@@ -20,21 +20,21 @@ public static class PluginsLoader
 
         public static List<PluginPair> Plugins(List<PluginMetadata> metadatas, PluginsSettings settings)
         {
-            var csharpPlugins = CSharpPlugins(metadatas).ToList();
+            var dotnetPlugins = DotNetPlugins(metadatas).ToList();
             var pythonPlugins = PythonPlugins(metadatas, settings.PythonDirectory);
             var executablePlugins = ExecutablePlugins(metadatas);
-            var plugins = csharpPlugins.Concat(pythonPlugins).Concat(executablePlugins).ToList();
+            var plugins = dotnetPlugins.Concat(pythonPlugins).Concat(executablePlugins).ToList();
             return plugins;
         }
 
-        public static IEnumerable<PluginPair> CSharpPlugins(List<PluginMetadata> source)
+        public static IEnumerable<PluginPair> DotNetPlugins(List<PluginMetadata> source)
         {
             var plugins = new List<PluginPair>();
-            var metadatas = source.Where(o => o.Language.ToUpper() == AllowedLanguage.CSharp);
+            var metadatas = source.Where(o => AllowedLanguage.IsDotNet(o.Language));
 
             foreach (var metadata in metadatas)
             {
-                var milliseconds = Stopwatch.Debug($"|PluginsLoader.CSharpPlugins|Constructor init cost for {metadata.Name}", () =>
+                var milliseconds = Stopwatch.Debug($"|PluginsLoader.DotNetPlugins|Constructor init cost for {metadata.Name}", () =>
                 {
 
 #if DEBUG
@@ -50,7 +50,7 @@ public static IEnumerable<PluginPair> CSharpPlugins(List<PluginMetadata> source)
                     }
                     catch (Exception e)
                     {
-                        Log.Exception($"|PluginsLoader.CSharpPlugins|Couldn't load assembly for {metadata.Name}", e);
+                        Log.Exception($"|PluginsLoader.DotNetPlugins|Couldn't load assembly for {metadata.Name}", e);
                         return;
                     }
                     var types = assembly.GetTypes();
@@ -61,7 +61,7 @@ public static IEnumerable<PluginPair> CSharpPlugins(List<PluginMetadata> source)
                     }
                     catch (InvalidOperationException e)
                     {
-                        Log.Exception($"|PluginsLoader.CSharpPlugins|Can't find class implement IPlugin for <{metadata.Name}>", e);
+                        Log.Exception($"|PluginsLoader.DotNetPlugins|Can't find class implement IPlugin for <{metadata.Name}>", e);
                         return;
                     }
                     IPlugin plugin;
@@ -71,7 +71,7 @@ public static IEnumerable<PluginPair> CSharpPlugins(List<PluginMetadata> source)
                     }
                     catch (Exception e)
                     {
-                        Log.Exception($"|PluginsLoader.CSharpPlugins|Can't create instance for <{metadata.Name}>", e);
+                        Log.Exception($"|PluginsLoader.DotNetPlugins|Can't create instance for <{metadata.Name}>", e);
                         return;
                     }
 #endif

Doc/app.psd

@@ -13,12 +13,13 @@ namespace Flow.Launcher.Infrastructure.Image
 {
     public static class ImageLoader
     {
-        private static readonly ImageCache ImageCache = new ImageCache();
+        private static readonly ImageCache _imageCache = new ImageCache();
+        private static readonly ConcurrentDictionary<string, string> _guidToKey = new ConcurrentDictionary<string, string>();
+        private static readonly bool _enableHashImage = true;
+
         private static BinaryStorage<Dictionary<string, int>> _storage;
-        private static readonly ConcurrentDictionary<string, string> GuidToKey = new ConcurrentDictionary<string, string>();
         private static IImageHashGenerator _hashGenerator;
 
-
         private static readonly string[] ImageExtensions =
         {
             ".png",
@@ -30,38 +31,38 @@ public static class ImageLoader
             ".ico"
         };
 
-
         public static void Initialize()
         {
             _storage = new BinaryStorage<Dictionary<string, int>>("Image");
             _hashGenerator = new ImageHashGenerator();
 
-            ImageCache.Usage = LoadStorageToConcurrentDictionary();
+            _imageCache.Usage = LoadStorageToConcurrentDictionary();
 
             foreach (var icon in new[] { Constant.DefaultIcon, Constant.ErrorIcon })
             {
                 ImageSource img = new BitmapImage(new Uri(icon));
                 img.Freeze();
-                ImageCache[icon] = img;
+                _imageCache[icon] = img;
             }
+
             Task.Run(() =>
             {
                 Stopwatch.Normal("|ImageLoader.Initialize|Preload images cost", () =>
                 {
-                    ImageCache.Usage.AsParallel().ForAll(x =>
+                    _imageCache.Usage.AsParallel().ForAll(x =>
                     {
                         Load(x.Key);
                     });
                 });
-                Log.Info($"|ImageLoader.Initialize|Number of preload images is <{ImageCache.Usage.Count}>, Images Number: {ImageCache.CacheSize()}, Unique Items {ImageCache.UniqueImagesInCache()}");
+                Log.Info($"|ImageLoader.Initialize|Number of preload images is <{_imageCache.Usage.Count}>, Images Number: {_imageCache.CacheSize()}, Unique Items {_imageCache.UniqueImagesInCache()}");
             });
         }
 
         public static void Save()
         {
             lock (_storage)
             {
-                _storage.Save(ImageCache.CleanupAndToDictionary());
+                _storage.Save(_imageCache.CleanupAndToDictionary());
             }
         }
 
@@ -99,17 +100,17 @@ private enum ImageType
 
         private static ImageResult LoadInternal(string path, bool loadFullImage = false)
         {
-            ImageSource image;
-            ImageType type = ImageType.Error;
+            ImageResult imageResult;
+
             try
             {
                 if (string.IsNullOrEmpty(path))
                 {
-                    return new ImageResult(ImageCache[Constant.ErrorIcon], ImageType.Error);
+                    return new ImageResult(_imageCache[Constant.ErrorIcon], ImageType.Error);
                 }
-                if (ImageCache.ContainsKey(path))
+                if (_imageCache.ContainsKey(path))
                 {
-                    return new ImageResult(ImageCache[path], ImageType.Cache);
+                    return new ImageResult(_imageCache[path], ImageType.Cache);
                 }
 
                 if (path.StartsWith("data:", StringComparison.OrdinalIgnoreCase))
@@ -124,95 +125,121 @@ private static ImageResult LoadInternal(string path, bool loadFullImage = false)
                     path = Path.Combine(Constant.ProgramDirectory, "Images", Path.GetFileName(path));
                 }
 
-                if (Directory.Exists(path))
+                imageResult = GetThumbnailResult(ref path, loadFullImage);
+            }
+            catch (System.Exception e)
+            {
+                try
+                {
+                    // Get thumbnail may fail for certain images on the first try, retry again has proven to work
+                    imageResult = GetThumbnailResult(ref path, loadFullImage);
+                }
+                catch (System.Exception e2)
                 {
-                    /* Directories can also have thumbnails instead of shell icons.
-                     * Generating thumbnails for a bunch of folders while scrolling through
-                     * results from Everything makes a big impact on performance and 
-                     * Flow.Launcher responsibility. 
-                     * - Solution: just load the icon
-                     */
-                    type = ImageType.Folder;
-                    image = WindowsThumbnailProvider.GetThumbnail(path, Constant.ThumbnailSize,
-                        Constant.ThumbnailSize, ThumbnailOptions.IconOnly);
+                    Log.Exception($"|ImageLoader.Load|Failed to get thumbnail for {path} on first try", e);
+                    Log.Exception($"|ImageLoader.Load|Failed to get thumbnail for {path} on second try", e2);
 
+                    ImageSource image = _imageCache[Constant.ErrorIcon];
+                    _imageCache[path] = image;
+                    imageResult = new ImageResult(image, ImageType.Error);
                 }
-                else if (File.Exists(path))
+            }
+
+            return imageResult;
+        }
+
+        private static ImageResult GetThumbnailResult(ref string path, bool loadFullImage = false)
+        {
+            ImageSource image;
+            ImageType type = ImageType.Error;
+
+            if (Directory.Exists(path))
+            {
+                /* Directories can also have thumbnails instead of shell icons.
+                 * Generating thumbnails for a bunch of folders while scrolling through
+                 * results from Everything makes a big impact on performance and 
+                 * Flow.Launcher responsibility. 
+                 * - Solution: just load the icon
+                 */
+                type = ImageType.Folder;
+                image = GetThumbnail(path, ThumbnailOptions.IconOnly);
+            }
+            else if (File.Exists(path))
+            {
+                var extension = Path.GetExtension(path).ToLower();
+                if (ImageExtensions.Contains(extension))
                 {
-                    var extension = Path.GetExtension(path).ToLower();
-                    if (ImageExtensions.Contains(extension))
+                    type = ImageType.ImageFile;
+                    if (loadFullImage)
                     {
-                        type = ImageType.ImageFile;
-                        if (loadFullImage)
-                        {
-                            image = LoadFullImage(path);
-                        }
-                        else
-                        {
-                            /* Although the documentation for GetImage on MSDN indicates that 
-                             * if a thumbnail is available it will return one, this has proved to not
-                             * be the case in many situations while testing. 
-                             * - Solution: explicitly pass the ThumbnailOnly flag
-                             */
-                            image = WindowsThumbnailProvider.GetThumbnail(path, Constant.ThumbnailSize,
-                                Constant.ThumbnailSize, ThumbnailOptions.ThumbnailOnly);
-                        }
+                        image = LoadFullImage(path);
                     }
                     else
                     {
-                        type = ImageType.File;
-                        image = WindowsThumbnailProvider.GetThumbnail(path, Constant.ThumbnailSize,
-                            Constant.ThumbnailSize, ThumbnailOptions.None);
+                        /* Although the documentation for GetImage on MSDN indicates that 
+                         * if a thumbnail is available it will return one, this has proved to not
+                         * be the case in many situations while testing. 
+                         * - Solution: explicitly pass the ThumbnailOnly flag
+                         */
+                        image = GetThumbnail(path, ThumbnailOptions.ThumbnailOnly);
                     }
                 }
                 else
                 {
-                    image = ImageCache[Constant.ErrorIcon];
-                    path = Constant.ErrorIcon;
-                }
-
-                if (type != ImageType.Error)
-                {
-                    image.Freeze();
+                    type = ImageType.File;
+                    image = GetThumbnail(path, ThumbnailOptions.None);
                 }
             }
-            catch (System.Exception e)
+            else
+            {
+                image = _imageCache[Constant.ErrorIcon];
+                path = Constant.ErrorIcon;
+            }
+
+            if (type != ImageType.Error)
             {
-                Log.Exception($"|ImageLoader.Load|Failed to get thumbnail for {path}", e);
-                type = ImageType.Error;
-                image = ImageCache[Constant.ErrorIcon];
-                ImageCache[path] = image;
+                image.Freeze();
             }
+
             return new ImageResult(image, type);
         }
 
-        private static bool EnableImageHash = true;
+        private static BitmapSource GetThumbnail(string path, ThumbnailOptions option = ThumbnailOptions.ThumbnailOnly)
+        {
+            return WindowsThumbnailProvider.GetThumbnail(
+                path,
+                Constant.ThumbnailSize,
+                Constant.ThumbnailSize,
+                option);
+        }
 
         public static ImageSource Load(string path, bool loadFullImage = false)
         {
             var imageResult = LoadInternal(path, loadFullImage);
 
             var img = imageResult.ImageSource;
             if (imageResult.ImageType != ImageType.Error && imageResult.ImageType != ImageType.Cache)
-            { // we need to get image hash
-                string hash = EnableImageHash ? _hashGenerator.GetHashFromImage(img) : null;
+            { 
+                // we need to get image hash
+                string hash = _enableHashImage ? _hashGenerator.GetHashFromImage(img) : null;
                 if (hash != null)
                 {
-                    if (GuidToKey.TryGetValue(hash, out string key))
-                    { // image already exists
-                        img = ImageCache[key];
+                    if (_guidToKey.TryGetValue(hash, out string key))
+                    { 
+                        // image already exists
+                        img = _imageCache[key];
                     }
                     else
-                    { // new guid
-                        GuidToKey[hash] = path;
+                    { 
+                        // new guid
+                        _guidToKey[hash] = path;
                     }
                 }
 
                 // update cache
-                ImageCache[path] = img;
+                _imageCache[path] = img;
             }
 
-
             return img;
         }
 

Doc/app_error.png

@@ -0,0 +1,9 @@
+namespace Flow.Launcher.Infrastructure
+{
+    public static class KeyConstant
+    {
+        public const string Ctrl = nameof(Ctrl);
+        public const string Alt = nameof(Alt);
+        public const string Space = nameof(Space);
+    }
+}