Fluent Window

Flow.Launcher.Core/Resource/Theme.cs

@@ -12,6 +12,10 @@
 using Flow.Launcher.Infrastructure.Logger;
 using Flow.Launcher.Infrastructure.UserSettings;
 using System.Windows.Shell;
+using static Flow.Launcher.Core.Resource.Theme.ParameterTypes;
+using System.Runtime.InteropServices;
+using System.Windows.Interop;
+using System.Diagnostics;
 
 namespace Flow.Launcher.Core.Resource
 {
@@ -59,6 +63,190 @@ public Theme()
             _oldTheme = Path.GetFileNameWithoutExtension(_oldResource.Source.AbsolutePath);
         }
 
+        #region Blur Handling
+        public class ParameterTypes
+        {
+
+            [Flags]
+            public enum DWMWINDOWATTRIBUTE
+            {
+                DWMWA_USE_IMMERSIVE_DARK_MODE = 20,
+                DWMWA_SYSTEMBACKDROP_TYPE = 38,
+                DWMWA_TRANSITIONS_FORCEDISABLED = 3,
+                DWMWA_BORDER_COLOR
+            }
+
+            [StructLayout(LayoutKind.Sequential)]
+            public struct MARGINS
+            {
+                public int cxLeftWidth;      // width of left border that retains its size
+                public int cxRightWidth;     // width of right border that retains its size
+                public int cyTopHeight;      // height of top border that retains its size
+                public int cyBottomHeight;   // height of bottom border that retains its size
+            };
+        }
+
+        public static class Methods
+        {
+            [DllImport("DwmApi.dll")]
+            static extern int DwmExtendFrameIntoClientArea(
+                IntPtr hwnd,
+                ref ParameterTypes.MARGINS pMarInset);
+
+            [DllImport("dwmapi.dll")]
+            static extern int DwmSetWindowAttribute(IntPtr hwnd, ParameterTypes.DWMWINDOWATTRIBUTE dwAttribute, ref int pvAttribute, int cbAttribute);
+
+            public static int ExtendFrame(IntPtr hwnd, ParameterTypes.MARGINS margins)
+                => DwmExtendFrameIntoClientArea(hwnd, ref margins);
+
+            public static int SetWindowAttribute(IntPtr hwnd, ParameterTypes.DWMWINDOWATTRIBUTE attribute, int parameter)
+                => DwmSetWindowAttribute(hwnd, attribute, ref parameter, Marshal.SizeOf<int>());
+        }
+
+        Window mainWindow = Application.Current.MainWindow;
+
+        public void RefreshFrame()
+        {
+            IntPtr mainWindowPtr = new WindowInteropHelper(mainWindow).Handle;
+            if (mainWindowPtr == IntPtr.Zero)
+                return;
+
+            HwndSource mainWindowSrc = HwndSource.FromHwnd(mainWindowPtr);
+            if (mainWindowSrc == null)
+                return;
+            //mainWindowSrc.CompositionTarget.BackgroundColor = Color.FromArgb(0, 255, 181, 178);
+
+            ParameterTypes.MARGINS margins = new ParameterTypes.MARGINS();
+            margins.cxLeftWidth = -1;
+            margins.cxRightWidth = -1;
+            margins.cyTopHeight = -1;
+            margins.cyBottomHeight = -1;
+            Methods.ExtendFrame(mainWindowSrc.Handle, margins);
+
+            // Remove OS minimizing/maximizing animation
+            Methods.SetWindowAttribute(new WindowInteropHelper(mainWindow).Handle, DWMWINDOWATTRIBUTE.DWMWA_TRANSITIONS_FORCEDISABLED, 3);
+
+            //Methods.SetWindowAttribute(new WindowInteropHelper(mainWindow).Handle, DWMWINDOWATTRIBUTE.DWMWA_BORDER_COLOR, 0x00FF0000);
+            //Methods.SetWindowAttribute(new WindowInteropHelper(mainWindow).Handle, DWMWINDOWATTRIBUTE.DWMWA_SYSTEMBACKDROP_TYPE, 3);
+            SetBlurForWindow();
+        }
+
+
+
+        /// <summary>
+        /// Sets the blur for a window via SetWindowCompositionAttribute
+        /// </summary>
+        public void SetBlurForWindow()
+        {
+
+            //SetWindowAccent();
+            var dict = GetThemeResourceDictionary(Settings.Theme);
+            if (dict == null)
+                return; 
+
+            var windowBorderStyle = dict["WindowBorderStyle"] as Style;
+            if (windowBorderStyle == null)
+                return;
+            Methods.SetWindowAttribute(new WindowInteropHelper(mainWindow).Handle, DWMWINDOWATTRIBUTE.DWMWA_SYSTEMBACKDROP_TYPE, 3);
+            if (BlurEnabled)
+            {
+                //mainWindow.WindowStyle = WindowStyle.SingleBorderWindow;
+                BlurColor(BlurMode());
+                windowBorderStyle.Setters.Remove(windowBorderStyle.Setters.OfType<Setter>().FirstOrDefault(x => x.Property.Name == "Background"));
+                windowBorderStyle.Setters.Add(new Setter(Border.BackgroundProperty, new SolidColorBrush(Colors.Transparent)));
+                Methods.SetWindowAttribute(new WindowInteropHelper(mainWindow).Handle, DWMWINDOWATTRIBUTE.DWMWA_SYSTEMBACKDROP_TYPE, 3);
+            }
+            else
+            {
+                //mainWindow.WindowStyle = WindowStyle.None;
+                //if (windowBorderStyle.Setters.OfType<Setter>().FirstOrDefault(x => x.Property.Name == "Background") != null)
+                //{
+                //    windowBorderStyle.Setters.Add(windowBorderStyle.Setters.OfType<Setter>().FirstOrDefault(x => x.Property.Name == "Background"));
+                //}
+                Methods.SetWindowAttribute(new WindowInteropHelper(mainWindow).Handle, DWMWINDOWATTRIBUTE.DWMWA_SYSTEMBACKDROP_TYPE, 1);
+            }
+            UpdateResourceDictionary(dict);
+        }
+
+        public void BlurColor(string Color)
+        {
+
+            if (Color == "Light")
+            {
+                //mainWindow.Background = new SolidColorBrush(defaultBGcolor.Value);
+                Methods.SetWindowAttribute(new WindowInteropHelper(mainWindow).Handle, DWMWINDOWATTRIBUTE.DWMWA_USE_IMMERSIVE_DARK_MODE, 0);
+            }
+            else if (Color == "Dark")
+            {
+                //mainWindow.Background = new SolidColorBrush(darkBGcolor.Value);
+                Methods.SetWindowAttribute(new WindowInteropHelper(mainWindow).Handle, DWMWINDOWATTRIBUTE.DWMWA_USE_IMMERSIVE_DARK_MODE, 1);
+            }
+            else /* Case of "Auto" Blur Type Theme */
+            {
+                //if (_isDarkTheme())
+                //{
+                //    mainWindow.Background = new SolidColorBrush(darkBGcolor.Value);
+                //    Methods.SetWindowAttribute(new WindowInteropHelper(mainWindow).Handle, DWMWINDOWATTRIBUTE.DWMWA_USE_IMMERSIVE_DARK_MODE, 1);
+                //}
+                //else
+                //{
+                //    mainWindow.Background = new SolidColorBrush(defaultBGcolor.Value);
+                //    Methods.SetWindowAttribute(new WindowInteropHelper(mainWindow).Handle, DWMWINDOWATTRIBUTE.DWMWA_USE_IMMERSIVE_DARK_MODE, 0);
+                //}
+                //mainWindow.Background = new SolidColorBrush(Colors.Red);
+                Methods.SetWindowAttribute(new WindowInteropHelper(mainWindow).Handle, DWMWINDOWATTRIBUTE.DWMWA_USE_IMMERSIVE_DARK_MODE, 1);            }
+
+        }
+
+        public bool IsBlurTheme()
+        {
+            if (Environment.OSVersion.Version >= new Version(6, 2))
+            {
+                var resource = Application.Current.TryFindResource("ThemeBlurEnabled");
+
+                if (resource is bool)
+                    return (bool)resource;
+
+                return false;
+            }
+
+            return false;
+        }
+        public string BlurMode()
+        {
+            if (Environment.OSVersion.Version >= new Version(6, 2))
+            {
+                var resource = Application.Current.TryFindResource("BlurMode");
+
+                if (resource is string)
+                    return (string)resource;
+
+                return null;
+            }
+
+            return null;
+        }
+
+        //public SolidColorBrush BGColor(string colorBgKey)
+        //{
+        //    var defaultBG = Application.Current.TryFindResource("DefaultBG");
+        //    var darkBG = Application.Current.TryFindResource("DarkBG");
+
+        //    if (colorBgKey == "")
+        //    {
+        //        var resource = Application.Current.TryFindResource("BlurMode");
+
+        //        if (resource is string)
+        //            return (SolidColorBrush)resource;
+
+        //        return new SolidColorBrush(Colors.DarkGray);
+        //    }
+
+        //    return null;
+        //}
+
+        #endregion
+
         private void MakeSureThemeDirectoriesExist()
         {
             foreach (var dir in _themeDirectories.Where(dir => !Directory.Exists(dir)))
@@ -102,7 +290,8 @@ public bool ChangeTheme(string theme)
                 if (Settings.UseDropShadowEffect && !BlurEnabled)
                     AddDropShadowEffectToCurrentTheme();
 
-                Win32Helper.SetBlurForWindow(Application.Current.MainWindow, BlurEnabled);
+                //Win32Helper.SetBlurForWindow(Application.Current.MainWindow, BlurEnabled);
+                SetBlurForWindow();
             }
             catch (DirectoryNotFoundException)
             {

Flow.Launcher.Infrastructure/Win32Helper.cs

@@ -7,6 +7,28 @@ namespace Flow.Launcher.Infrastructure
 {
     public static class Win32Helper
     {
+        private enum DwmSystemBackdropType
+        {
+            DWMSBT_AUTO = 0,
+            DWMSBT_NONE = 1,
+            DWMSBT_MICA = 2,
+            DWMSBT_ACRYLIC = 3,
+            DWMSBT_TABBED = 4
+        }
+
+        private const int DWMWA_SYSTEMBACKDROP_TYPE = 38;
+
+        [DllImport("dwmapi.dll")]
+        private static extern int DwmSetWindowAttribute(IntPtr hwnd, int dwAttribute, ref DwmSystemBackdropType pvAttribute, int cbAttribute);
+
+        public static void SetMicaForWindow(Window window, bool enableMica)
+        {
+            var windowHelper = new WindowInteropHelper(window);
+            windowHelper.EnsureHandle();
+
+            DwmSystemBackdropType backdropType = enableMica ? DwmSystemBackdropType.DWMSBT_MICA : DwmSystemBackdropType.DWMSBT_NONE;
+            DwmSetWindowAttribute(windowHelper.Handle, DWMWA_SYSTEMBACKDROP_TYPE, ref backdropType, sizeof(int));
+        }
         #region Blur Handling
 
         /*

Flow.Launcher/MainWindow.xaml

@@ -15,12 +15,11 @@
     MinHeight="30"
     d:DataContext="{d:DesignInstance Type=vm:MainViewModel}"
     AllowDrop="True"
-    AllowsTransparency="True"
-    Background="Transparent"
+    AllowsTransparency="False"
+    Background="#E12E2E2E"
     Closing="OnClosing"
     Deactivated="OnDeactivated"
     Icon="Images/app.png"
-    SourceInitialized="OnSourceInitialized"
     Initialized="OnInitialized"
     Left="{Binding Settings.WindowLeft, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
     Loaded="OnLoaded"
@@ -31,10 +30,11 @@
     ResizeMode="CanResize"
     ShowInTaskbar="False"
     SizeToContent="Height"
+    SourceInitialized="OnSourceInitialized"
     Topmost="True"
     Visibility="{Binding MainWindowVisibility, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
     WindowStartupLocation="Manual"
-    WindowStyle="None"
+    WindowStyle="SingleBorderWindow"
     mc:Ignorable="d">
     <!--  WindowChrome  -->
     <WindowChrome.WindowChrome>

Flow.Launcher/MainWindow.xaml.cs

@@ -60,9 +60,7 @@ public MainWindow(Settings settings, MainViewModel mainVM)
             InitializePosition();
 
             InitSoundEffects();
-
             DataObject.AddPastingHandler(QueryTextBox, OnPaste);
-
             this.Loaded += (_, _) =>
             {
                 var handle = new WindowInteropHelper(this).Handle;
@@ -108,6 +106,7 @@ private IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref b
             return IntPtr.Zero;
         }
 
+
         private void OnResizeEnd()
         {
             int shadowMargin = 0;
@@ -182,6 +181,11 @@ private void OnInitialized(object sender, EventArgs e)
 
         private void OnLoaded(object sender, RoutedEventArgs _)
         {
+            Dispatcher.BeginInvoke((Action)(() =>
+            {
+                ThemeManager.Instance.RefreshFrame();
+            }), DispatcherPriority.Background);
+
             // MouseEventHandler
             PreviewMouseMove += MainPreviewMouseMove;
             CheckFirstLaunch();

Flow.Launcher/SettingPages/ViewModels/SettingsPaneThemeViewModel.cs

@@ -39,6 +39,7 @@ public Theme.ThemeData SelectedTheme
 
             if (ThemeManager.Instance.BlurEnabled && Settings.UseDropShadowEffect)
                 DropShadowEffect = false;
+            ThemeManager.Instance.RefreshFrame();
         }
     }
 

Flow.Launcher/Themes/BlurBlack.xaml

@@ -10,8 +10,8 @@
     <ResourceDictionary.MergedDictionaries>
         <ResourceDictionary Source="pack://application:,,,/Themes/Base.xaml" />
     </ResourceDictionary.MergedDictionaries>
-
     <system:Boolean x:Key="ThemeBlurEnabled">True</system:Boolean>
+    <system:String x:Key="BlurMode">Auto</system:String>
     <Style x:Key="WindowRadius" TargetType="{x:Type Border}">
         <Setter Property="CornerRadius" Value="0" />
     </Style>

Flow.Launcher/Themes/Win11Light.xaml

@@ -1,7 +1,7 @@
 <!--
     Name: Windows 11
     IsDark: True
-    HasBlur: False
+    HasBlur: True
 -->
 <ResourceDictionary
     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
@@ -12,6 +12,8 @@
     <ResourceDictionary.MergedDictionaries>
         <ResourceDictionary Source="pack://application:,,,/Themes/Base.xaml" />
     </ResourceDictionary.MergedDictionaries>
+    <system:Boolean x:Key="ThemeBlurEnabled">True</system:Boolean>
+    <system:String x:Key="BlurMode">Auto</system:String>
     <Style
         x:Key="BulletStyle"
         BasedOn="{StaticResource BaseBulletStyle}"

Flow.Launcher/ViewModel/MainViewModel.cs

@@ -1397,6 +1397,7 @@ public void Show()
         public async void Hide()
         {
             lastHistoryIndex = 1;
+
             // Trick for no delay
             MainWindowOpacity = 0;
 
@@ -1408,36 +1409,33 @@ public async void Hide()
                 SelectedResults = Results;
             }
 
+            // 텍스트 초기화 즉시 적용
+            if (Settings.LastQueryMode == LastQueryMode.Empty)
+            {
+                ChangeQueryText(string.Empty);
+                await Task.Yield(); // UI 갱신 보장
+            }
+
             switch (Settings.LastQueryMode)
             {
-                case LastQueryMode.Empty:
-                    ChangeQueryText(string.Empty);
-                    await Task.Delay(100); //Time for change to opacity
-                    break;
                 case LastQueryMode.Preserved:
-                    if (Settings.UseAnimation)
-                        await Task.Delay(100);
-                    LastQuerySelected = true;
-                    break;
                 case LastQueryMode.Selected:
-                    if (Settings.UseAnimation)
-                        await Task.Delay(100);
-                    LastQuerySelected = false;
+                    LastQuerySelected = (Settings.LastQueryMode == LastQueryMode.Preserved);
                     break;
-                case LastQueryMode.ActionKeywordPreserved or LastQueryMode.ActionKeywordSelected:
+
+                case LastQueryMode.ActionKeywordPreserved:
+                case LastQueryMode.ActionKeywordSelected:
                     var newQuery = _lastQuery.ActionKeyword;
                     if (!string.IsNullOrEmpty(newQuery))
                         newQuery += " ";
                     ChangeQueryText(newQuery);
-                    if (Settings.UseAnimation)
-                        await Task.Delay(100);
+
                     if (Settings.LastQueryMode == LastQueryMode.ActionKeywordSelected)
                         LastQuerySelected = false;
                     break;
-                default:
-                    throw new ArgumentException($"wrong LastQueryMode: <{Settings.LastQueryMode}>");
             }
 
+            // 창 숨김 즉시 처리
             MainWindowVisibilityStatus = false;
             MainWindowVisibility = Visibility.Collapsed;
             VisibilityChanged?.Invoke(this, new VisibilityChangedEventArgs { IsVisible = false });