Fix Setting Window Designs

Flow.Launcher.Core/ExternalPlugins/UserPlugin.cs

@@ -1,4 +1,6 @@
-namespace Flow.Launcher.Core.ExternalPlugins
+using System;
+
+namespace Flow.Launcher.Core.ExternalPlugins
 {
     public record UserPlugin
     {
@@ -12,5 +14,8 @@ public record UserPlugin
         public string UrlDownload { get; set; }
         public string UrlSourceCode { get; set; }
         public string IcoPath { get; set; }
+        public DateTime LatestReleaseDate { get; set; }
+        public DateTime DateAdded { get; set; }
+
     }
 }

Flow.Launcher.Infrastructure/Logger/Log.cs

@@ -1,4 +1,4 @@
-using System.Diagnostics;
+using System.Diagnostics;
 using System.IO;
 using System.Runtime.CompilerServices;
 using NLog;

Flow.Launcher.Infrastructure/StringMatcher.cs

@@ -202,7 +202,11 @@ public MatchResult FuzzyMatch(string query, string stringToCompare, MatchOption
             if (allQuerySubstringsMatched)
             {
                 var nearestSpaceIndex = CalculateClosestSpaceIndex(spaceIndices, firstMatchIndex);
-                var score = CalculateSearchScore(query, stringToCompare, firstMatchIndex - nearestSpaceIndex - 1,
+
+                // firstMatchIndex - nearestSpaceIndex - 1 is to set the firstIndex as the index of the first matched char
+                // preceded by a space e.g. 'world' matching 'hello world' firstIndex would be 0 not 6 
+                // giving more weight than 'we or donald' by allowing the distance calculation to treat the starting position at after the space.
+                var score = CalculateSearchScore(query, stringToCompare, firstMatchIndex - nearestSpaceIndex - 1, spaceIndices,
                     lastMatchIndex - firstMatchIndex, allSubstringsContainedInCompareString);
 
                 var resultList = indexList.Select(x => translationMapping?.MapToOriginalIndex(x) ?? x).Distinct().ToList();
@@ -296,14 +300,22 @@ private static bool AllQuerySubstringsMatched(int currentQuerySubstringIndex, in
             return currentQuerySubstringIndex >= querySubstringsLength;
         }
 
-        private static int CalculateSearchScore(string query, string stringToCompare, int firstIndex, int matchLen,
+        private static int CalculateSearchScore(string query, string stringToCompare, int firstIndex, List<int> spaceIndices, int matchLen,
             bool allSubstringsContainedInCompareString)
         {
             // A match found near the beginning of a string is scored more than a match found near the end
             // A match is scored more if the characters in the patterns are closer to each other, 
             // while the score is lower if they are more spread out
             var score = 100 * (query.Length + 1) / ((1 + firstIndex) + (matchLen + 1));
 
+            // Give more weight to a match that is closer to the start of the string. 
+            // if the first matched char is immediately before space and all strings are contained in the compare string e.g. 'world' matching 'hello world'
+            // and 'world hello', because both have 'world' immediately preceded by space, their firstIndex will be 0 when distance is calculated,
+            // to prevent them scoring the same, we adjust the score by deducting the number of spaces it has from the start of the string, so 'world hello'
+            // will score slightly higher than 'hello world' because 'hello world' has one additional space.
+            if (firstIndex == 0 && allSubstringsContainedInCompareString)
+                score -= spaceIndices.Count;
+
             // A match with less characters assigning more weights
             if (stringToCompare.Length - query.Length < 5)
             {

Flow.Launcher.Infrastructure/UserSettings/CustomShortcutModel.cs

@@ -0,0 +1,65 @@
+using System;
+using System.Text.Json.Serialization;
+
+namespace Flow.Launcher.Infrastructure.UserSettings
+{
+    public abstract class ShortcutBaseModel
+    {
+        public string Key { get; set; }
+
+        [JsonIgnore]
+        public Func<string> Expand { get; set; } = () => { return ""; };
+
+        public override bool Equals(object obj)
+        {
+            return obj is ShortcutBaseModel other &&
+                   Key == other.Key;
+        }
+
+        public override int GetHashCode()
+        {
+            return Key.GetHashCode();
+        }
+    }
+
+    public class CustomShortcutModel : ShortcutBaseModel
+    {
+        public string Value { get; set; }
+
+        [JsonConstructorAttribute]
+        public CustomShortcutModel(string key, string value)
+        {
+            Key = key;
+            Value = value;
+            Expand = () => { return Value; };
+        }
+
+        public void Deconstruct(out string key, out string value)
+        {
+            key = Key;
+            value = Value;
+        }
+
+        public static implicit operator (string Key, string Value)(CustomShortcutModel shortcut)
+        {
+            return (shortcut.Key, shortcut.Value);
+        }
+
+        public static implicit operator CustomShortcutModel((string Key, string Value) shortcut)
+        {
+            return new CustomShortcutModel(shortcut.Key, shortcut.Value);
+        }
+    }
+
+    public class BuiltinShortcutModel : ShortcutBaseModel
+    {
+        public string Description { get; set; }
+
+        public BuiltinShortcutModel(string key, string description, Func<string> expand)
+        {
+            Key = key;
+            Description = description;
+            Expand = expand ?? (() => { return ""; });
+        }
+    }
+}

Flow.Launcher.Infrastructure/UserSettings/Settings.cs

@@ -3,6 +3,7 @@
 using System.Collections.ObjectModel;
 using System.Drawing;
 using System.Text.Json.Serialization;
+using System.Windows;
 using Flow.Launcher.Plugin;
 using Flow.Launcher.Plugin.SharedModels;
 using Flow.Launcher;
@@ -41,6 +42,10 @@ public string Language
         public bool UseGlyphIcons { get; set; } = true;
         public bool UseAnimation { get; set; } = true;
         public bool UseSound { get; set; } = true;
+        public bool UseClock { get; set; } = true;
+        public bool UseDate { get; set; } = false;
+        public string TimeFormat { get; set; } = "hh:mm tt";
+        public string DateFormat { get; set; } = "MM'/'dd ddd";
         public bool FirstLaunch { get; set; } = true;
 
         public double SettingWindowWidth { get; set; } = 1000;
@@ -125,8 +130,7 @@ public CustomBrowserViewModel CustomBrowser
                 PrivateArg = "-private",
                 EnablePrivate = false,
                 Editable = false
-            }
-            ,
+            },
             new()
             {
                 Name = "MS Edge",
@@ -182,6 +186,13 @@ public string QuerySearchPrecisionString
 
         public ObservableCollection<CustomPluginHotkey> CustomPluginHotkeys { get; set; } = new ObservableCollection<CustomPluginHotkey>();
 
+        public ObservableCollection<CustomShortcutModel> CustomShortcuts { get; set; } = new ObservableCollection<CustomShortcutModel>();
+
+        [JsonIgnore]
+        public ObservableCollection<BuiltinShortcutModel> BuiltinShortcuts { get; set; } = new ObservableCollection<BuiltinShortcutModel>() { 
+            new BuiltinShortcutModel("{clipboard}", "shortcut_clipboard_description", Clipboard.GetText)
+        };
+
         public bool DontPromptUpdateMsg { get; set; }
         public bool EnableUpdateLog { get; set; }
 
@@ -199,7 +210,7 @@ public bool HideNotifyIcon
         }
         public bool LeaveCmdOpen { get; set; }
         public bool HideWhenDeactive { get; set; } = true;
-        public bool RememberLastLaunchLocation { get; set; }
+        public SearchWindowPositions SearchWindowPosition { get; set; } = SearchWindowPositions.MouseScreenCenter;
         public bool IgnoreHotkeysOnFullscreen { get; set; }
 
         public HttpProxy Proxy { get; set; } = new HttpProxy();
@@ -225,4 +236,12 @@ public enum ColorSchemes
         Light,
         Dark
     }
+    public enum SearchWindowPositions
+    {
+        RememberLastLaunchLocation,
+        MouseScreenCenter,
+        MouseScreenCenterTop,
+        MouseScreenLeftTop,
+        MouseScreenRightTop
+    }
 }

Flow.Launcher.Plugin/Result.cs

@@ -37,7 +37,11 @@ public class Result
         /// user's clipboard when Ctrl + C is pressed on a result. If the text is a file/directory path
         /// flow will copy the actual file/folder instead of just the path text.
         /// </summary>
-        public string CopyText { get; set; } = string.Empty;
+        public string CopyText
+        {
+            get => string.IsNullOrEmpty(_copyText) ? SubTitle : _copyText;
+            set => _copyText = value;
+        }
 
         /// <summary>
         /// This holds the text which can be provided by plugin to help Flow autocomplete text
@@ -81,6 +85,7 @@ public string IcoPath
         /// Delegate to Get Image Source
         /// </summary>
         public IconDelegate Icon;
+        private string _copyText = string.Empty;
 
         /// <summary>
         /// Information for Glyph Icon (Prioritized than IcoPath/Icon if user enable Glyph Icons)

Flow.Launcher.Test/FuzzyMatcherTest.cs

@@ -129,14 +129,20 @@ public void GivenQueryString_WhenAppliedPrecisionFiltering_ThenShouldReturnGreat
             }
         }
 
+
+        /// <summary>
+        /// These are standard match scenarios
+        /// The intention of this test is provide a bench mark for how much the score has increased from a change.
+        /// Usually the increase in scoring should not be drastic, increase of less than 10 is acceptable.
+        /// </summary>
         [TestCase(Chrome, Chrome, 157)]
-        [TestCase(Chrome, LastIsChrome, 147)]
+        [TestCase(Chrome, LastIsChrome, 145)]
         [TestCase("chro", HelpCureHopeRaiseOnMindEntityChrome, 50)]
         [TestCase("chr", HelpCureHopeRaiseOnMindEntityChrome, 30)]
         [TestCase(Chrome, UninstallOrChangeProgramsOnYourComputer, 21)]
         [TestCase(Chrome, CandyCrushSagaFromKing, 0)]
-        [TestCase("sql", MicrosoftSqlServerManagementStudio, 110)]
-        [TestCase("sql  manag", MicrosoftSqlServerManagementStudio, 121)] //double spacing intended
+        [TestCase("sql", MicrosoftSqlServerManagementStudio, 109)]
+        [TestCase("sql  manag", MicrosoftSqlServerManagementStudio, 120)] //double spacing intended
         public void WhenGivenQueryString_ThenShouldReturn_TheDesiredScoring(
             string queryString, string compareString, int expectedScore)
         {
@@ -275,7 +281,40 @@ public void WhenGivenAQuery_Scoring_ShouldGiveMoreWeightToStartOfNewWord(
                 $"Query: \"{queryString}\"{Environment.NewLine} " +
                 $"CompareString1: \"{compareString1}\", Score: {compareString1Result.Score}{Environment.NewLine}" +
                 $"Should be greater than{Environment.NewLine}" +
-                $"CompareString2: \"{compareString2}\", Score: {compareString1Result.Score}{Environment.NewLine}");
+                $"CompareString2: \"{compareString2}\", Score: {compareString2Result.Score}{Environment.NewLine}");
+        }
+
+        [TestCase("red", "red colour", "metro red")]
+        [TestCase("red", "this red colour", "this colour red")]
+        [TestCase("red", "this red colour", "this colour is very red")]
+        [TestCase("red", "this red colour", "this colour is surprisingly super awesome red and cool")]
+        [TestCase("red", "this colour is surprisingly super red very and cool", "this colour is surprisingly super very red and cool")]
+        public void WhenGivenTwoStrings_Scoring_ShouldGiveMoreWeightToTheStringCloserToIndexZero(
+            string queryString, string compareString1, string compareString2)
+        {
+            // When
+            var matcher = new StringMatcher { UserSettingSearchPrecision = SearchPrecisionScore.Regular };
+
+            // Given
+            var compareString1Result = matcher.FuzzyMatch(queryString, compareString1);
+            var compareString2Result = matcher.FuzzyMatch(queryString, compareString2);
+
+            Debug.WriteLine("");
+            Debug.WriteLine("###############################################");
+            Debug.WriteLine($"QueryString: \"{queryString}\"{Environment.NewLine}");
+            Debug.WriteLine(
+                $"CompareString1: \"{compareString1}\", Score: {compareString1Result.Score}{Environment.NewLine}");
+            Debug.WriteLine(
+                $"CompareString2: \"{compareString2}\", Score: {compareString2Result.Score}{Environment.NewLine}");
+            Debug.WriteLine("###############################################");
+            Debug.WriteLine("");
+
+            // Should
+            Assert.True(compareString1Result.Score > compareString2Result.Score,
+                $"Query: \"{queryString}\"{Environment.NewLine} " +
+                $"CompareString1: \"{compareString1}\", Score: {compareString1Result.Score}{Environment.NewLine}" +
+                $"Should be greater than{Environment.NewLine}" +
+                $"CompareString2: \"{compareString2}\", Score: {compareString2Result.Score}{Environment.NewLine}");
         }
 
         [TestCase("vim", "Vim", "ignoreDescription", "ignore.exe", "Vim Diff", "ignoreDescription", "ignore.exe")]

Flow.Launcher/Converters/BoolToVisibilityConverter.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Data;
+
+namespace Flow.Launcher.Converters
+{
+    public class BoolToVisibilityConverter : IValueConverter
+    {
+        public object Convert(object value, System.Type targetType, object parameter, CultureInfo culture)
+        {
+            if (parameter != null)
+            {
+                if (value is true)
+                {
+                    return Visibility.Collapsed;
+                }
+
+                else
+                {
+                    return Visibility.Visible;
+                }
+            }
+            else { 
+                if (value is true)
+                {
+                    return Visibility.Visible;
+                }
+
+                else { 
+                    return Visibility.Collapsed;
+                }
+            }
+        }
+
+        public object ConvertBack(object value, System.Type targetType, object parameter, CultureInfo culture) => throw new System.InvalidOperationException();
+    }
+}

Flow.Launcher/Converters/TextConverter.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Globalization;
+using System.Windows.Data;
+using Flow.Launcher.Core.Resource;
+using Flow.Launcher.ViewModel;
+
+namespace Flow.Launcher.Converters
+{
+    public class TextConverter : IValueConverter
+    {
+        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            var ID = value.ToString();
+            switch(ID)
+            {
+                case PluginStoreItemViewModel.NewRelease:
+                    return InternationalizationManager.Instance.GetTranslation("pluginStore_NewRelease");
+                case PluginStoreItemViewModel.RecentlyUpdated:
+                    return InternationalizationManager.Instance.GetTranslation("pluginStore_RecentlyUpdated");
+                case PluginStoreItemViewModel.None:
+                    return InternationalizationManager.Instance.GetTranslation("pluginStore_None");
+                case PluginStoreItemViewModel.Installed:
+                    return InternationalizationManager.Instance.GetTranslation("pluginStore_Installed");
+                default:
+                    return ID;
+            }
+
+        }
+
+        public object ConvertBack(object value, System.Type targetType, object parameter, CultureInfo culture) => throw new System.InvalidOperationException();
+    }
+}

Flow.Launcher/Converters/TranslationConverter.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Globalization;
+using System.Windows.Data;
+using Flow.Launcher.Core.Resource;
+
+namespace Flow.Launcher.Converters
+{
+    public class TranlationConverter : IValueConverter
+    {
+        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            var key = value.ToString();
+            if (String.IsNullOrEmpty(key))
+                return key;
+            return InternationalizationManager.Instance.GetTranslation(key);
+        }
+
+        public object ConvertBack(object value, System.Type targetType, object parameter, CultureInfo culture) => throw new System.InvalidOperationException();
+    }
+}