CentralizedControl/HandyControl/Microsoft.Windows.Shell/SystemParameters2.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Runtime.InteropServices;
using System.Windows;
using System.Windows.Media;
using Standard;

namespace Microsoft.Windows.Shell;

[SuppressMessage("Microsoft.Design", "CA1001:TypesThatOwnDisposableFieldsShouldBeDisposable")]
public class SystemParameters2 : INotifyPropertyChanged
{
    private void _InitializeIsGlassEnabled()
    {
        this.IsGlassEnabled = NativeMethods.DwmIsCompositionEnabled();
    }

    private void _UpdateIsGlassEnabled(IntPtr wParam, IntPtr lParam)
    {
        this._InitializeIsGlassEnabled();
    }

    private void _InitializeGlassColor()
    {
        uint num;
        bool flag;
        NativeMethods.DwmGetColorizationColor(out num, out flag);
        num |= (flag ? 4278190080u : 0u);
        this.WindowGlassColor = Utility.ColorFromArgbDword(num);
        SolidColorBrush solidColorBrush = new SolidColorBrush(this.WindowGlassColor);
        solidColorBrush.Freeze();
        this.WindowGlassBrush = solidColorBrush;
    }

    private void _UpdateGlassColor(IntPtr wParam, IntPtr lParam)
    {
        bool flag = lParam != IntPtr.Zero;
        uint num = (uint) ((int) wParam.ToInt64());
        num |= (flag ? 4278190080u : 0u);
        this.WindowGlassColor = Utility.ColorFromArgbDword(num);
        SolidColorBrush solidColorBrush = new SolidColorBrush(this.WindowGlassColor);
        solidColorBrush.Freeze();
        this.WindowGlassBrush = solidColorBrush;
    }

    private void _InitializeCaptionHeight()
    {
        Point devicePoint = new Point(0.0, (double) NativeMethods.GetSystemMetrics(SM.CYCAPTION));
        this.WindowCaptionHeight = DpiHelper.DevicePixelsToLogical(devicePoint).Y;
    }

    private void _UpdateCaptionHeight(IntPtr wParam, IntPtr lParam)
    {
        this._InitializeCaptionHeight();
    }

    private void _InitializeWindowResizeBorderThickness()
    {
        Size deviceSize = new Size((double) NativeMethods.GetSystemMetrics(SM.CXFRAME), (double) NativeMethods.GetSystemMetrics(SM.CYFRAME));
        Size size = DpiHelper.DeviceSizeToLogical(deviceSize);
        this.WindowResizeBorderThickness = new Thickness(size.Width, size.Height, size.Width, size.Height);
    }

    private void _UpdateWindowResizeBorderThickness(IntPtr wParam, IntPtr lParam)
    {
        this._InitializeWindowResizeBorderThickness();
    }

    private void _InitializeWindowNonClientFrameThickness()
    {
        Size deviceSize = new Size((double) NativeMethods.GetSystemMetrics(SM.CXFRAME), (double) NativeMethods.GetSystemMetrics(SM.CYFRAME));
        Size size = DpiHelper.DeviceSizeToLogical(deviceSize);
        int systemMetrics = NativeMethods.GetSystemMetrics(SM.CYCAPTION);
        double y = DpiHelper.DevicePixelsToLogical(new Point(0.0, (double) systemMetrics)).Y;
        this.WindowNonClientFrameThickness = new Thickness(size.Width, size.Height + y, size.Width, size.Height);
    }

    private void _UpdateWindowNonClientFrameThickness(IntPtr wParam, IntPtr lParam)
    {
        this._InitializeWindowNonClientFrameThickness();
    }

    private void _InitializeSmallIconSize()
    {
        this.SmallIconSize = new Size((double) NativeMethods.GetSystemMetrics(SM.CXSMICON), (double) NativeMethods.GetSystemMetrics(SM.CYSMICON));
    }

    private void _UpdateSmallIconSize(IntPtr wParam, IntPtr lParam)
    {
        this._InitializeSmallIconSize();
    }

    private void _LegacyInitializeCaptionButtonLocation()
    {
        int systemMetrics = NativeMethods.GetSystemMetrics(SM.CXSIZE);
        int systemMetrics2 = NativeMethods.GetSystemMetrics(SM.CYSIZE);
        int num = NativeMethods.GetSystemMetrics(SM.CXFRAME) + NativeMethods.GetSystemMetrics(SM.CXEDGE);
        int num2 = NativeMethods.GetSystemMetrics(SM.CYFRAME) + NativeMethods.GetSystemMetrics(SM.CYEDGE);
        Rect windowCaptionButtonsLocation = new Rect(0.0, 0.0, (double) (systemMetrics * 3), (double) systemMetrics2);
        windowCaptionButtonsLocation.Offset((double) (-(double) num) - windowCaptionButtonsLocation.Width, (double) num2);
        this.WindowCaptionButtonsLocation = windowCaptionButtonsLocation;
    }

    [SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands")]
    private void _InitializeCaptionButtonLocation()
    {
        if (!Utility.IsOSVistaOrNewer || !NativeMethods.IsThemeActive())
        {
            this._LegacyInitializeCaptionButtonLocation();
            return;
        }
        TITLEBARINFOEX titlebarinfoex = new TITLEBARINFOEX
        {
            cbSize = Marshal.SizeOf(typeof(TITLEBARINFOEX))
        };
        IntPtr intPtr = Marshal.AllocHGlobal(titlebarinfoex.cbSize);
        try
        {
            Marshal.StructureToPtr(titlebarinfoex, intPtr, false);
            NativeMethods.ShowWindow(this._messageHwnd.Handle, SW.SHOW);
            NativeMethods.SendMessage(this._messageHwnd.Handle, WM.GETTITLEBARINFOEX, IntPtr.Zero, intPtr);
            titlebarinfoex = (TITLEBARINFOEX) Marshal.PtrToStructure(intPtr, typeof(TITLEBARINFOEX));
        }
        finally
        {
            NativeMethods.ShowWindow(this._messageHwnd.Handle, SW.HIDE);
            Utility.SafeFreeHGlobal(ref intPtr);
        }
        RECT rect = RECT.Union(titlebarinfoex.rgrect_CloseButton, titlebarinfoex.rgrect_MinimizeButton);
        RECT windowRect = NativeMethods.GetWindowRect(this._messageHwnd.Handle);
        Rect deviceRectangle = new Rect((double) (rect.Left - windowRect.Width - windowRect.Left), (double) (rect.Top - windowRect.Top), (double) rect.Width, (double) rect.Height);
        Rect windowCaptionButtonsLocation = DpiHelper.DeviceRectToLogical(deviceRectangle);
        this.WindowCaptionButtonsLocation = windowCaptionButtonsLocation;
    }

    private void _UpdateCaptionButtonLocation(IntPtr wParam, IntPtr lParam)
    {
        this._InitializeCaptionButtonLocation();
    }

    private void _InitializeHighContrast()
    {
        this.HighContrast = ((NativeMethods.SystemParameterInfo_GetHIGHCONTRAST().dwFlags & HCF.HIGHCONTRASTON) != (HCF) 0);
    }

    private void _UpdateHighContrast(IntPtr wParam, IntPtr lParam)
    {
        this._InitializeHighContrast();
    }

    private void _InitializeThemeInfo()
    {
        if (!NativeMethods.IsThemeActive())
        {
            this.UxThemeName = "Classic";
            this.UxThemeColor = "";
            return;
        }
        string path;
        string uxThemeColor;
        string text;
        NativeMethods.GetCurrentThemeName(out path, out uxThemeColor, out text);
        this.UxThemeName = Path.GetFileNameWithoutExtension(path);
        this.UxThemeColor = uxThemeColor;
    }

    private void _UpdateThemeInfo(IntPtr wParam, IntPtr lParam)
    {
        this._InitializeThemeInfo();
    }

    private void _InitializeWindowCornerRadius()
    {
        CornerRadius windowCornerRadius = default(CornerRadius);
        string a;
        if ((a = this.UxThemeName.ToUpperInvariant()) != null)
        {
            if (a == "LUNA")
            {
                windowCornerRadius = new CornerRadius(6.0, 6.0, 0.0, 0.0);
                goto IL_E6;
            }
            if (!(a == "AERO"))
            {
                if (!(a == "CLASSIC") && !(a == "ZUNE") && !(a == "ROYALE"))
                {
                }
            }
            else
            {
                if (NativeMethods.DwmIsCompositionEnabled())
                {
                    windowCornerRadius = new CornerRadius(8.0);
                    goto IL_E6;
                }
                windowCornerRadius = new CornerRadius(6.0, 6.0, 0.0, 0.0);
                goto IL_E6;
            }
        }
        windowCornerRadius = new CornerRadius(0.0);
IL_E6:
        this.WindowCornerRadius = windowCornerRadius;
    }

    private void _UpdateWindowCornerRadius(IntPtr wParam, IntPtr lParam)
    {
        this._InitializeWindowCornerRadius();
    }

    private SystemParameters2()
    {
        this._messageHwnd = new MessageWindow((CS) 0u, WS.DISABLED | WS.BORDER | WS.DLGFRAME | WS.SYSMENU | WS.THICKFRAME | WS.GROUP | WS.TABSTOP, WS_EX.None, new Rect(-16000.0, -16000.0, 100.0, 100.0), "", new WndProc(this._WndProc));
        this._messageHwnd.Dispatcher.ShutdownStarted += delegate (object sender, EventArgs e)
        {
            Utility.SafeDispose<MessageWindow>(ref this._messageHwnd);
        };
        this._InitializeIsGlassEnabled();
        this._InitializeGlassColor();
        this._InitializeCaptionHeight();
        this._InitializeWindowNonClientFrameThickness();
        this._InitializeWindowResizeBorderThickness();
        this._InitializeCaptionButtonLocation();
        this._InitializeSmallIconSize();
        this._InitializeHighContrast();
        this._InitializeThemeInfo();
        this._InitializeWindowCornerRadius();
        this._UpdateTable = new Dictionary<WM, List<SystemParameters2._SystemMetricUpdate>>
        {
            {
                WM.THEMECHANGED,
                new List<SystemParameters2._SystemMetricUpdate>
                {
                    new SystemParameters2._SystemMetricUpdate(this._UpdateThemeInfo),
                    new SystemParameters2._SystemMetricUpdate(this._UpdateHighContrast),
                    new SystemParameters2._SystemMetricUpdate(this._UpdateWindowCornerRadius),
                    new SystemParameters2._SystemMetricUpdate(this._UpdateCaptionButtonLocation)
                }
            },
            {
                WM.WININICHANGE,
                new List<SystemParameters2._SystemMetricUpdate>
                {
                    new SystemParameters2._SystemMetricUpdate(this._UpdateCaptionHeight),
                    new SystemParameters2._SystemMetricUpdate(this._UpdateWindowResizeBorderThickness),
                    new SystemParameters2._SystemMetricUpdate(this._UpdateSmallIconSize),
                    new SystemParameters2._SystemMetricUpdate(this._UpdateHighContrast),
                    new SystemParameters2._SystemMetricUpdate(this._UpdateWindowNonClientFrameThickness),
                    new SystemParameters2._SystemMetricUpdate(this._UpdateCaptionButtonLocation)
                }
            },
            {
                WM.DWMNCRENDERINGCHANGED,
                new List<SystemParameters2._SystemMetricUpdate>
                {
                    new SystemParameters2._SystemMetricUpdate(this._UpdateIsGlassEnabled)
                }
            },
            {
                WM.DWMCOMPOSITIONCHANGED,
                new List<SystemParameters2._SystemMetricUpdate>
                {
                    new SystemParameters2._SystemMetricUpdate(this._UpdateIsGlassEnabled)
                }
            },
            {
                WM.DWMCOLORIZATIONCOLORCHANGED,
                new List<SystemParameters2._SystemMetricUpdate>
                {
                    new SystemParameters2._SystemMetricUpdate(this._UpdateGlassColor)
                }
            }
        };
    }

    public static SystemParameters2 Current
    {
        get
        {
            if (SystemParameters2._threadLocalSingleton == null)
            {
                SystemParameters2._threadLocalSingleton = new SystemParameters2();
            }
            return SystemParameters2._threadLocalSingleton;
        }
    }

    private IntPtr _WndProc(IntPtr hwnd, WM msg, IntPtr wParam, IntPtr lParam)
    {
        List<SystemParameters2._SystemMetricUpdate> list;
        if (this._UpdateTable != null && this._UpdateTable.TryGetValue(msg, out list))
        {
            foreach (SystemParameters2._SystemMetricUpdate systemMetricUpdate in list)
            {
                systemMetricUpdate(wParam, lParam);
            }
        }
        return NativeMethods.DefWindowProc(hwnd, msg, wParam, lParam);
    }

    public bool IsGlassEnabled
    {
        get
        {
            return NativeMethods.DwmIsCompositionEnabled();
        }
        private set
        {
            if (value != this._isGlassEnabled)
            {
                this._isGlassEnabled = value;
                this._NotifyPropertyChanged("IsGlassEnabled");
            }
        }
    }

    public Color WindowGlassColor
    {
        get
        {
            return this._glassColor;
        }
        private set
        {
            if (value != this._glassColor)
            {
                this._glassColor = value;
                this._NotifyPropertyChanged("WindowGlassColor");
            }
        }
    }

    public SolidColorBrush WindowGlassBrush
    {
        get
        {
            return this._glassColorBrush;
        }
        private set
        {
            if (this._glassColorBrush == null || value.Color != this._glassColorBrush.Color)
            {
                this._glassColorBrush = value;
                this._NotifyPropertyChanged("WindowGlassBrush");
            }
        }
    }

    public Thickness WindowResizeBorderThickness
    {
        get
        {
            return this._windowResizeBorderThickness;
        }
        private set
        {
            if (value != this._windowResizeBorderThickness)
            {
                this._windowResizeBorderThickness = value;
                this._NotifyPropertyChanged("WindowResizeBorderThickness");
            }
        }
    }

    public Thickness WindowNonClientFrameThickness
    {
        get
        {
            return this._windowNonClientFrameThickness;
        }
        private set
        {
            if (value != this._windowNonClientFrameThickness)
            {
                this._windowNonClientFrameThickness = value;
                this._NotifyPropertyChanged("WindowNonClientFrameThickness");
            }
        }
    }

    public double WindowCaptionHeight
    {
        get
        {
            return this._captionHeight;
        }
        private set
        {
            if (value != this._captionHeight)
            {
                this._captionHeight = value;
                this._NotifyPropertyChanged("WindowCaptionHeight");
            }
        }
    }

    public Size SmallIconSize
    {
        get
        {
            return new Size(this._smallIconSize.Width, this._smallIconSize.Height);
        }
        private set
        {
            if (value != this._smallIconSize)
            {
                this._smallIconSize = value;
                this._NotifyPropertyChanged("SmallIconSize");
            }
        }
    }

    [SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "Ux")]
    [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Ux")]
    public string UxThemeName
    {
        get
        {
            return this._uxThemeName;
        }
        private set
        {
            if (value != this._uxThemeName)
            {
                this._uxThemeName = value;
                this._NotifyPropertyChanged("UxThemeName");
            }
        }
    }

    [SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "Ux")]
    [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Ux")]
    public string UxThemeColor
    {
        get
        {
            return this._uxThemeColor;
        }
        private set
        {
            if (value != this._uxThemeColor)
            {
                this._uxThemeColor = value;
                this._NotifyPropertyChanged("UxThemeColor");
            }
        }
    }

    public bool HighContrast
    {
        get
        {
            return this._isHighContrast;
        }
        private set
        {
            if (value != this._isHighContrast)
            {
                this._isHighContrast = value;
                this._NotifyPropertyChanged("HighContrast");
            }
        }
    }

    public CornerRadius WindowCornerRadius
    {
        get
        {
            return this._windowCornerRadius;
        }
        private set
        {
            if (value != this._windowCornerRadius)
            {
                this._windowCornerRadius = value;
                this._NotifyPropertyChanged("WindowCornerRadius");
            }
        }
    }

    public Rect WindowCaptionButtonsLocation
    {
        get
        {
            return this._captionButtonLocation;
        }
        private set
        {
            if (value != this._captionButtonLocation)
            {
                this._captionButtonLocation = value;
                this._NotifyPropertyChanged("WindowCaptionButtonsLocation");
            }
        }
    }

    private void _NotifyPropertyChanged(string propertyName)
    {
        PropertyChangedEventHandler propertyChanged = this.PropertyChanged;
        if (propertyChanged != null)
        {
            propertyChanged(this, new PropertyChangedEventArgs(propertyName));
        }
    }

    public event PropertyChangedEventHandler PropertyChanged;

    [ThreadStatic]
    private static SystemParameters2 _threadLocalSingleton;

    private MessageWindow _messageHwnd;

    private bool _isGlassEnabled;

    private Color _glassColor;

    private SolidColorBrush _glassColorBrush;

    private Thickness _windowResizeBorderThickness;

    private Thickness _windowNonClientFrameThickness;

    private double _captionHeight;

    private Size _smallIconSize;

    private string _uxThemeName;

    private string _uxThemeColor;

    private bool _isHighContrast;

    private CornerRadius _windowCornerRadius;

    private Rect _captionButtonLocation;

    private readonly Dictionary<WM, List<SystemParameters2._SystemMetricUpdate>> _UpdateTable;

    private delegate void _SystemMetricUpdate(IntPtr wParam, IntPtr lParam);
}