Merge branch 'dev' into quickswitch

Author: Jack251970

Flow.Launcher.Core/Plugin/PluginManager.cs

@@ -220,9 +220,19 @@ public static async Task InitializePluginsAsync()
                 catch (Exception e)
                 {
                     API.LogException(ClassName, $"Fail to Init plugin: {pair.Metadata.Name}", e);
-                    pair.Metadata.Disabled = true;
-                    pair.Metadata.HomeDisabled = true;
-                    failedPlugins.Enqueue(pair);
+                    if (pair.Metadata.Disabled && pair.Metadata.HomeDisabled)
+                    {
+                        // If this plugin is already disabled, do not show error message again
+                        // Or else it will be shown every time
+                        API.LogDebug(ClassName, $"Skipped init for <{pair.Metadata.Name}> due to error");
+                    }
+                    else
+                    {
+                        pair.Metadata.Disabled = true;
+                        pair.Metadata.HomeDisabled = true;
+                        failedPlugins.Enqueue(pair);
+                        API.LogDebug(ClassName, $"Disable plugin <{pair.Metadata.Name}> because init failed");
+                    }
                 }
             }));
 

Flow.Launcher.Infrastructure/Storage/JsonStorage.cs

@@ -45,6 +45,22 @@ public JsonStorage(string filePath)
             FilesFolders.ValidateDirectory(DirectoryPath);
         }
 
+        public bool Exists()
+        {
+            return File.Exists(FilePath);
+        }
+
+        public void Delete()
+        {
+            foreach (var path in new[] { FilePath, BackupFilePath, TempFilePath })
+            {
+                if (File.Exists(path))
+                {
+                    File.Delete(path);
+                }
+            }
+        }
+
         public async Task<T> LoadAsync()
         {
             if (Data != null)

Flow.Launcher.Infrastructure/UserSettings/Settings.cs

@@ -309,6 +309,10 @@ public SearchPrecisionScore QuerySearchPrecision
 
         public double WindowLeft { get; set; }
         public double WindowTop { get; set; }
+        public double PreviousScreenWidth { get; set; }
+        public double PreviousScreenHeight { get; set; }
+        public double PreviousDpiX { get; set; }
+        public double PreviousDpiY { get; set; }
 
         /// <summary>
         /// Custom left position on selected monitor

Flow.Launcher/MainWindow.xaml.cs

@@ -90,7 +90,7 @@ public MainWindow()
 
             InitSoundEffects();
             DataObject.AddPastingHandler(QueryTextBox, QueryTextBox_OnPaste);
-
+            ModernWpf.ThemeManager.Current.ActualApplicationThemeChanged += ThemeManager_ActualApplicationThemeChanged;
             SystemEvents.PowerModeChanged += SystemEvents_PowerModeChanged;
         }
 
@@ -100,6 +100,11 @@ public MainWindow()
 
 #pragma warning disable VSTHRD100 // Avoid async void methods
 
+        private void ThemeManager_ActualApplicationThemeChanged(ModernWpf.ThemeManager sender, object args)
+        {
+            _theme.RefreshFrameAsync();
+        }
+
         private void OnSourceInitialized(object sender, EventArgs e)
         {
             var handle = Win32Helper.GetWindowHandle(this, true);
@@ -740,8 +745,26 @@ void InitializePositionInner()
             {
                 if (_settings.SearchWindowScreen == SearchWindowScreens.RememberLastLaunchLocation)
                 {
-                    Top = _settings.WindowTop;
+                    var previousScreenWidth = _settings.PreviousScreenWidth;
+                    var previousScreenHeight = _settings.PreviousScreenHeight;
+                    GetDpi(out var previousDpiX, out var previousDpiY);
+
+                    _settings.PreviousScreenWidth = SystemParameters.VirtualScreenWidth;
+                    _settings.PreviousScreenHeight = SystemParameters.VirtualScreenHeight;
+                    GetDpi(out var currentDpiX, out var currentDpiY);
+
+                    if (previousScreenWidth != 0 && previousScreenHeight != 0 &&
+                        previousDpiX != 0 && previousDpiY != 0 &&
+                        (previousScreenWidth != SystemParameters.VirtualScreenWidth ||
+                         previousScreenHeight != SystemParameters.VirtualScreenHeight ||
+                         previousDpiX != currentDpiX || previousDpiY != currentDpiY))
+                    {
+                        AdjustPositionForResolutionChange();
+                        return;
+                    }
+
                     Left = _settings.WindowLeft;
+                    Top = _settings.WindowTop;
                 }
                 else
                 {
@@ -754,27 +777,73 @@ void InitializePositionInner()
                             break;
                         case SearchWindowAligns.CenterTop:
                             Left = HorizonCenter(screen);
-                            Top = 10;
+                            Top = VerticalTop(screen);
                             break;
                         case SearchWindowAligns.LeftTop:
                             Left = HorizonLeft(screen);
-                            Top = 10;
+                            Top = VerticalTop(screen);
                             break;
                         case SearchWindowAligns.RightTop:
                             Left = HorizonRight(screen);
-                            Top = 10;
+                            Top = VerticalTop(screen);
                             break;
                         case SearchWindowAligns.Custom:
-                            Left = Win32Helper.TransformPixelsToDIP(this,
-                                screen.WorkingArea.X + _settings.CustomWindowLeft, 0).X;
-                            Top = Win32Helper.TransformPixelsToDIP(this, 0,
-                                screen.WorkingArea.Y + _settings.CustomWindowTop).Y;
+                            var customLeft = Win32Helper.TransformPixelsToDIP(this,
+                                screen.WorkingArea.X + _settings.CustomWindowLeft, 0);
+                            var customTop = Win32Helper.TransformPixelsToDIP(this, 0,
+                                screen.WorkingArea.Y + _settings.CustomWindowTop);
+                            Left = customLeft.X;
+                            Top = customTop.Y;
                             break;
                     }
                 }
             }
         }
 
+        private void AdjustPositionForResolutionChange()
+        {
+            var screenWidth = SystemParameters.VirtualScreenWidth;
+            var screenHeight = SystemParameters.VirtualScreenHeight;
+            GetDpi(out var currentDpiX, out var currentDpiY);
+
+            var previousLeft = _settings.WindowLeft;
+            var previousTop = _settings.WindowTop;
+            GetDpi(out var previousDpiX, out var previousDpiY);
+
+            var widthRatio = screenWidth / _settings.PreviousScreenWidth;
+            var heightRatio = screenHeight / _settings.PreviousScreenHeight;
+            var dpiXRatio = currentDpiX / previousDpiX;
+            var dpiYRatio = currentDpiY / previousDpiY;
+
+            var newLeft = previousLeft * widthRatio * dpiXRatio;
+            var newTop = previousTop * heightRatio * dpiYRatio;
+
+            var screenLeft = SystemParameters.VirtualScreenLeft;
+            var screenTop = SystemParameters.VirtualScreenTop;
+
+            var maxX = screenLeft + screenWidth - ActualWidth;
+            var maxY = screenTop + screenHeight - ActualHeight;
+
+            Left = Math.Max(screenLeft, Math.Min(newLeft, maxX));
+            Top = Math.Max(screenTop, Math.Min(newTop, maxY));
+        }
+
+        private void GetDpi(out double dpiX, out double dpiY)
+        {
+            var source = PresentationSource.FromVisual(this);
+            if (source != null && source.CompositionTarget != null)
+            {
+                var matrix = source.CompositionTarget.TransformToDevice;
+                dpiX = 96 * matrix.M11;
+                dpiY = 96 * matrix.M22;
+            }
+            else
+            {
+                dpiX = 96;
+                dpiY = 96;
+            }
+        }
+
         private Screen SelectedScreen()
         {
             Screen screen;
@@ -835,6 +904,13 @@ private double HorizonLeft(Screen screen)
             return left;
         }
 
+        public double VerticalTop(Screen screen)
+        {
+            var dip1 = Win32Helper.TransformPixelsToDIP(this, 0, screen.WorkingArea.Y);
+            var top = dip1.Y + 10;
+            return top;
+        }
+
         #endregion
 
         #region Window Animation
@@ -1249,6 +1325,7 @@ protected virtual void Dispose(bool disposing)
                     _notifyIcon?.Dispose();
                     animationSoundWMP?.Close();
                     animationSoundWPF?.Dispose();
+                    ModernWpf.ThemeManager.Current.ActualApplicationThemeChanged -= ThemeManager_ActualApplicationThemeChanged;
                     SystemEvents.PowerModeChanged -= SystemEvents_PowerModeChanged;
                 }
 

Flow.Launcher/SettingPages/ViewModels/SettingsPaneThemeViewModel.cs

@@ -479,7 +479,8 @@ public SettingsPaneThemeViewModel(Settings settings, Theme theme)
                     )
                 }
             };
-        var vm = new ResultsViewModel(Settings);
+        // Set main view model to null because the results are for preview only
+        var vm = new ResultsViewModel(Settings, null);
         vm.AddResults(results, "PREVIEW");
         PreviewResults = vm;
     }

Flow.Launcher/SettingWindow.xaml.cs

@@ -137,18 +137,40 @@ public void UpdatePositionAndState()
 
         if (previousTop == null || previousLeft == null || !IsPositionValid(previousTop.Value, previousLeft.Value))
         {
-            Top = WindowTop();
-            Left = WindowLeft();
+            SetWindowPosition(WindowTop(), WindowLeft());
         }
         else
         {
-            Top = previousTop.Value;
-            Left = previousLeft.Value;
+            var left = _settings.SettingWindowLeft.Value;
+            var top = _settings.SettingWindowTop.Value;
+            AdjustWindowPosition(ref top, ref left);
+            SetWindowPosition(top, left);
         }
 
         WindowState = _settings.SettingWindowState;
     }
 
+    private void SetWindowPosition(double top, double left)
+    {
+        // Ensure window does not exceed screen boundaries
+        top = Math.Max(top, SystemParameters.VirtualScreenTop);
+        left = Math.Max(left, SystemParameters.VirtualScreenLeft);
+        top = Math.Min(top, SystemParameters.VirtualScreenHeight - ActualHeight);
+        left = Math.Min(left, SystemParameters.VirtualScreenWidth - ActualWidth);
+
+        Top = top;
+        Left = left;
+    }
+
+    private void AdjustWindowPosition(ref double top, ref double left)
+    {
+        // Adjust window position if it exceeds screen boundaries
+        top = Math.Max(top, SystemParameters.VirtualScreenTop);
+        left = Math.Max(left, SystemParameters.VirtualScreenLeft);
+        top = Math.Min(top, SystemParameters.VirtualScreenHeight - ActualHeight);
+        left = Math.Min(left, SystemParameters.VirtualScreenWidth - ActualWidth);
+    }
+
     private static bool IsPositionValid(double top, double left)
     {
         foreach (var screen in Screen.AllScreens)