dorisoy_HardwareMonitor/LibreHardwareMonitor/UI/GadgetWindow.cs
// This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
// If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
// Copyright (C) LibreHardwareMonitor and Contributors.
// Partial Copyright (C) Michael Möller <mmoeller@openhardwaremonitor.org> and Contributors.
// All Rights Reserved.

using System;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Text;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Windows.Forms;

namespace LibreHardwareMonitor.UI
{
    public sealed class GadgetWindow : NativeWindow, IDisposable
    {
        private bool _visible;
        private bool _alwaysOnTop;
        private byte _opacity = 255;
        private Point _location = new Point(100, 100);
        private Size _size = new Size(130, 84);
        private readonly MethodInfo _commandDispatch;
        private IntPtr _handleBitmapDC;
        private Size _bufferSize;
        private Graphics _graphics;

        public event EventHandler SizeChanged;
        public event EventHandler LocationChanged;
        public event HitTestEventHandler HitTest;
        public event MouseEventHandler MouseDoubleClick;

        public GadgetWindow()
        {
            Type commandType = typeof(Form).Assembly.GetType("System.Windows.Forms.Command");
            _commandDispatch = commandType.GetMethod("DispatchID",
              BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public,
              null, new[] { typeof(int) }, null);

            CreateHandle(CreateParams);

            // move window to the bottom
            MoveToBottom(Handle);

            // prevent window from fading to a glass sheet when peek is invoked
            try
            {
                bool value = true;
                NativeMethods.DwmSetWindowAttribute(Handle, WindowAttribute.DWMWA_EXCLUDED_FROM_PEEK, ref value, Marshal.SizeOf(true));
            }
            catch (DllNotFoundException) { }
            catch (EntryPointNotFoundException) { }

            CreateBuffer();
        }

        private void ShowDesktopChanged(bool showDesktop)
        {
            if (showDesktop)
                MoveToTopMost(Handle);
            else
                MoveToBottom(Handle);
        }

        private void MoveToBottom(IntPtr handle)
        {
            NativeMethods.SetWindowPos(handle, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOSENDCHANGING);
        }

        private void MoveToTopMost(IntPtr handle)
        {
            NativeMethods.SetWindowPos(handle, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOSENDCHANGING);
        }

        private CreateParams CreateParams
        {
            get
            {
                CreateParams cp = new CreateParams
                {
                    Width = 4096,
                    Height = 4096,
                    X = _location.X,
                    Y = _location.Y,
                    ExStyle = WS_EX_LAYERED | WS_EX_TOOLWINDOW
                };

                return cp;
            }
        }

        protected override void WndProc(ref Message message)
        {
            switch (message.Msg)
            {
                case WM_COMMAND:
                    {
                        // need to dispatch the message for the context menu
                        if (message.LParam == IntPtr.Zero)
                            _commandDispatch.Invoke(null, new object[] {message.WParam.ToInt32() & 0xFFFF });
                    }
                    break;
                case WM_NCHITTEST:
                    {
                        message.Result = (IntPtr)HitResult.Caption;
                        if (HitTest != null)
                        {
                            Point p = new Point(
                              Macros.GET_X_LPARAM(message.LParam) - _location.X,
                              Macros.GET_Y_LPARAM(message.LParam) - _location.Y
                            );
                            HitTestEventArgs e = new HitTestEventArgs(p, HitResult.Caption);
                            HitTest(this, e);
                            message.Result = (IntPtr)e.HitResult;
                        }
                    }
                    break;
                case WM_NCLBUTTONDBLCLK:
                    {
                        MouseDoubleClick?.Invoke(this, new MouseEventArgs(MouseButtons.Left, 2, Macros.GET_X_LPARAM(message.LParam) - _location.X, Macros.GET_Y_LPARAM(message.LParam) - _location.Y, 0));
                        message.Result = IntPtr.Zero;
                    }
                    break;
                case WM_NCRBUTTONDOWN:
                    {
                        message.Result = IntPtr.Zero;
                    }
                    break;
                case WM_NCRBUTTONUP:
                    {
                        ContextMenuStrip?.Show(new Point(Macros.GET_X_LPARAM(message.LParam), Macros.GET_Y_LPARAM(message.LParam)));
                        message.Result = IntPtr.Zero;
                    }
                    break;
                case WM_WINDOWPOSCHANGING:
                    {
                        WINDOWPOS wp = (WINDOWPOS)Marshal.PtrToStructure(message.LParam, typeof(WINDOWPOS));
                        if (!LockPositionAndSize)
                        {
                            // prevent the window from leaving the screen
                            if ((wp.flags & SWP_NOMOVE) == 0)
                            {
                                Rectangle rect = Screen.GetWorkingArea(new Rectangle(wp.x, wp.y, wp.cx, wp.cy));
                                const int margin = 16;
                                wp.x = Math.Max(wp.x, rect.Left - wp.cx + margin);
                                wp.x = Math.Min(wp.x, rect.Right - margin);
                                wp.y = Math.Max(wp.y, rect.Top - wp.cy + margin);
                                wp.y = Math.Min(wp.y, rect.Bottom - margin);
                            }

                            // update location and fire event
                            if ((wp.flags & SWP_NOMOVE) == 0)
                            {
                                if (_location.X != wp.x || _location.Y != wp.y)
                                {
                                    _location = new Point(wp.x, wp.y);
                                    LocationChanged?.Invoke(this, EventArgs.Empty);
                                }
                            }

                            // update size and fire event
                            if ((wp.flags & SWP_NOSIZE) == 0)
                            {
                                if (_size.Width != wp.cx || _size.Height != wp.cy)
                                {
                                    _size = new Size(wp.cx, wp.cy);
                                    SizeChanged?.Invoke(this, EventArgs.Empty);
                                }
                            }

                            // update the size of the layered window
                            if ((wp.flags & SWP_NOSIZE) == 0)
                                NativeMethods.UpdateLayeredWindow(Handle, IntPtr.Zero, IntPtr.Zero, ref _size, IntPtr.Zero, IntPtr.Zero, 0, IntPtr.Zero, 0);

                            // update the position of the layered window
                            if ((wp.flags & SWP_NOMOVE) == 0)
                                NativeMethods.SetWindowPos(Handle, IntPtr.Zero, _location.X, _location.Y, 0, 0, SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOSENDCHANGING);
                        }

                        // do not forward any move or size messages
                        wp.flags |= SWP_NOSIZE | SWP_NOMOVE;

                        // suppress any frame changed events
                        wp.flags &= ~SWP_FRAMECHANGED;

                        Marshal.StructureToPtr(wp, message.LParam, false);
                        message.Result = IntPtr.Zero;
                    }
                    break;
                default:
                    {
                        base.WndProc(ref message);
                    }
                    break;
            }
        }

        private BlendFunction CreateBlendFunction()
        {
            return new BlendFunction { BlendOp = AC_SRC_OVER, BlendFlags = 0, SourceConstantAlpha = _opacity, AlphaFormat = AC_SRC_ALPHA };
        }

        private void CreateBuffer()
        {
            IntPtr handleScreenDC = NativeMethods.GetDC(IntPtr.Zero);
            _handleBitmapDC = NativeMethods.CreateCompatibleDC(handleScreenDC);
            NativeMethods.ReleaseDC(IntPtr.Zero, handleScreenDC);
            _bufferSize = _size;

            BITMAPINFO info = new BITMAPINFO();
            info.Size = Marshal.SizeOf(info);
            info.Width = _size.Width;
            info.Height = -_size.Height;
            info.BitCount = 32;
            info.Planes = 1;

            IntPtr hBmp = NativeMethods.CreateDIBSection(_handleBitmapDC, ref info, 0, out IntPtr _, IntPtr.Zero, 0);
            IntPtr hBmpOld = NativeMethods.SelectObject(_handleBitmapDC, hBmp);
            NativeMethods.DeleteObject(hBmpOld);

            _graphics = Graphics.FromHdc(_handleBitmapDC);

            if (Environment.OSVersion.Version.Major > 5)
            {
                _graphics.TextRenderingHint = TextRenderingHint.SystemDefault;
                _graphics.SmoothingMode = SmoothingMode.HighQuality;
            }
        }

        private void DisposeBuffer()
        {
            _graphics.Dispose();
            NativeMethods.DeleteDC(_handleBitmapDC);
        }

        public void Dispose()
        {
            DisposeBuffer();
        }

        public PaintEventHandler Paint;

        public void Redraw()
        {
            if (!_visible || Paint == null)
                return;

            if (_size != _bufferSize)
            {
                DisposeBuffer();
                CreateBuffer();
            }

            Paint(this, new PaintEventArgs(_graphics, new Rectangle(Point.Empty, _size)));
            Point pointSource = Point.Empty;
            BlendFunction blend = CreateBlendFunction();
            NativeMethods.UpdateLayeredWindow(Handle, IntPtr.Zero, IntPtr.Zero, ref _size, _handleBitmapDC, ref pointSource, 0, ref blend, ULW_ALPHA);
            // make sure the window is at the right location
            NativeMethods.SetWindowPos(Handle, IntPtr.Zero, _location.X, _location.Y, 0, 0, SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOSENDCHANGING);
        }

        public byte Opacity
        {
            get
            {
                return _opacity;
            }
            set
            {
                if (_opacity != value)
                {
                    _opacity = value;
                    BlendFunction blend = CreateBlendFunction();
                    NativeMethods.UpdateLayeredWindow(Handle, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, 0, ref blend, ULW_ALPHA);
                }
            }
        }

        public bool Visible
        {
            get
            {
                return _visible;
            }
            set
            {
                if (_visible != value)
                {
                    _visible = value;
                    NativeMethods.SetWindowPos(Handle, IntPtr.Zero, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOZORDER | (value ? SWP_SHOWWINDOW : SWP_HIDEWINDOW));

                    if (value)
                    {
                        if (!_alwaysOnTop)
                            ShowDesktop.Instance.ShowDesktopChanged += ShowDesktopChanged;
                    }
                    else
                    {
                        if (!_alwaysOnTop)
                            ShowDesktop.Instance.ShowDesktopChanged -= ShowDesktopChanged;
                    }
                }
            }
        }

        // if locked, the window can not be moved or resized
        public bool LockPositionAndSize { get; set; }

        public bool AlwaysOnTop
        {
            get
            {
                return _alwaysOnTop;
            }
            set
            {
                if (value != _alwaysOnTop)
                {
                    _alwaysOnTop = value;

                    if (_alwaysOnTop)
                    {
                        if (_visible)
                            ShowDesktop.Instance.ShowDesktopChanged -= ShowDesktopChanged;

                        MoveToTopMost(Handle);
                    }
                    else
                    {
                        MoveToBottom(Handle);

                        if (_visible)
                            ShowDesktop.Instance.ShowDesktopChanged += ShowDesktopChanged;
                    }
                }
            }
        }

        public Size Size
        {
            get
            {
                return _size;
            }
            set
            {
                if (_size != value)
                {
                    _size = value;
                    NativeMethods.UpdateLayeredWindow(Handle, IntPtr.Zero, IntPtr.Zero, ref _size, IntPtr.Zero, IntPtr.Zero, 0, IntPtr.Zero, 0);
                    SizeChanged?.Invoke(this, EventArgs.Empty);
                }
            }
        }

        public Point Location
        {
            get
            {
                return _location;
            }
            set
            {
                if (_location != value)
                {
                    _location = value;
                    NativeMethods.SetWindowPos(Handle, IntPtr.Zero, _location.X, _location.Y, 0, 0, SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOSENDCHANGING);
                    LocationChanged?.Invoke(this, EventArgs.Empty);
                }
            }
        }

        public ContextMenuStrip ContextMenuStrip { get; set; }

        [StructLayout(LayoutKind.Sequential, Pack = 1)]
        private struct BlendFunction
        {
            public byte BlendOp;
            public byte BlendFlags;
            public byte SourceConstantAlpha;
            public byte AlphaFormat;
        }

        [StructLayout(LayoutKind.Sequential, Pack = 1)]
        private struct WINDOWPOS
        {
            public readonly IntPtr hwnd;
            public readonly IntPtr hwndInsertAfter;
            public int x;
            public int y;
            public readonly int cx;
            public readonly int cy;
            public uint flags;
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct BITMAPINFO
        {
            public int Size;
            public int Width;
            public int Height;
            public short Planes;
            public short BitCount;
            public int Compression;
            public int SizeImage;
            public int XPelsPerMeter;
            public int YPelsPerMeter;
            public int ClrUsed;
            public int ClrImportant;
            public int Colors;
        }

        public static readonly IntPtr HWND_BOTTOM = (IntPtr)1;
        public static readonly IntPtr HWND_TOPMOST = (IntPtr)(-1);

        public const int WS_EX_LAYERED = 0x00080000;
        public const int WS_EX_TOOLWINDOW = 0x00000080;

        public const uint SWP_NOSIZE = 0x0001;
        public const uint SWP_NOMOVE = 0x0002;
        public const uint SWP_NOACTIVATE = 0x0010;
        public const uint SWP_FRAMECHANGED = 0x0020;
        public const uint SWP_HIDEWINDOW = 0x0080;
        public const uint SWP_SHOWWINDOW = 0x0040;
        public const uint SWP_NOZORDER = 0x0004;
        public const uint SWP_NOSENDCHANGING = 0x0400;

        public const int ULW_COLORKEY = 0x00000001;
        public const int ULW_ALPHA = 0x00000002;
        public const int ULW_OPAQUE = 0x00000004;

        public const byte AC_SRC_OVER = 0x00;
        public const byte AC_SRC_ALPHA = 0x01;

        public const int WM_NCHITTEST = 0x0084;
        public const int WM_NCLBUTTONDBLCLK = 0x00A3;
        public const int WM_NCLBUTTONDOWN = 0x00A1;
        public const int WM_NCLBUTTONUP = 0x00A2;
        public const int WM_NCRBUTTONDOWN = 0x00A4;
        public const int WM_NCRBUTTONUP = 0x00A5;
        public const int WM_WINDOWPOSCHANGING = 0x0046;
        public const int WM_COMMAND = 0x0111;

        public const int TPM_RIGHTBUTTON = 0x0002;
        public const int TPM_VERTICAL = 0x0040;

        private enum WindowAttribute : int
        {
            DWMWA_NCRENDERING_ENABLED = 1,
            DWMWA_NCRENDERING_POLICY,
            DWMWA_TRANSITIONS_FORCEDISABLED,
            DWMWA_ALLOW_NCPAINT,
            DWMWA_CAPTION_BUTTON_BOUNDS,
            DWMWA_NONCLIENT_RTL_LAYOUT,
            DWMWA_FORCE_ICONIC_REPRESENTATION,
            DWMWA_FLIP3D_POLICY,
            DWMWA_EXTENDED_FRAME_BOUNDS,
            DWMWA_HAS_ICONIC_BITMAP,
            DWMWA_DISALLOW_PEEK,
            DWMWA_EXCLUDED_FROM_PEEK,
            DWMWA_LAST
        }

        /// <summary>
        /// Some macros imported and converted from the Windows SDK
        /// </summary>
        private static class Macros
        {
            public static ushort LOWORD(IntPtr l)
            {
                return (ushort)((ulong)l & 0xFFFF);
            }

            public static ushort HIWORD(IntPtr l)
            {
                return (ushort)(((ulong)l >> 16) & 0xFFFF);
            }

            public static int GET_X_LPARAM(IntPtr lp)
            {
                return (short)LOWORD(lp);
            }

            public static int GET_Y_LPARAM(IntPtr lp)
            {
                return (short)HIWORD(lp);
            }
        }

        /// <summary>
        /// Imported native methods
        /// </summary>
        private static class NativeMethods
        {
            private const string USER = "user32.dll";
            private const string GDI = "gdi32.dll";
            private const string DWMAPI = "dwmapi.dll";

            [DllImport(USER, CallingConvention = CallingConvention.Winapi)]
            [return: MarshalAs(UnmanagedType.Bool)]
            public static extern bool UpdateLayeredWindow(IntPtr hwnd, IntPtr hdcDst, IntPtr pptDst, ref Size psize, IntPtr hdcSrc, IntPtr pprSrc, int crKey, IntPtr pblend, int dwFlags);

            [DllImport(USER, CallingConvention = CallingConvention.Winapi)]
            [return: MarshalAs(UnmanagedType.Bool)]
            public static extern bool UpdateLayeredWindow(IntPtr hwnd, IntPtr hdcDst, IntPtr pptDst, ref Size psize, IntPtr hdcSrc, ref Point pprSrc, int crKey, ref BlendFunction pblend, int dwFlags);

            [DllImport(USER, CallingConvention = CallingConvention.Winapi)]
            [return: MarshalAs(UnmanagedType.Bool)]
            public static extern bool UpdateLayeredWindow(IntPtr hwnd, IntPtr hdcDst, IntPtr pptDst, IntPtr psize, IntPtr hdcSrc, IntPtr pprSrc, int crKey, ref BlendFunction pblend, int dwFlags);

            [DllImport(USER, CallingConvention = CallingConvention.Winapi)]
            public static extern IntPtr GetDC(IntPtr hWnd);

            [DllImport(USER, CallingConvention = CallingConvention.Winapi)]
            public static extern int ReleaseDC(IntPtr hWnd, IntPtr hDC);

            [DllImport(USER, CallingConvention = CallingConvention.Winapi)]
            public static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int X, int Y, int cx, int cy, uint uFlags);

            [DllImport(USER, CallingConvention = CallingConvention.Winapi)]
            public static extern bool TrackPopupMenuEx(IntPtr hMenu, uint uFlags, int x, int y, IntPtr hWnd, IntPtr tpmParams);

            [DllImport(GDI, CallingConvention = CallingConvention.Winapi)]
            public static extern IntPtr CreateCompatibleDC(IntPtr hDC);

            [DllImport(GDI, CallingConvention = CallingConvention.Winapi)]
            public static extern IntPtr CreateDIBSection(IntPtr hdc, [In] ref BITMAPINFO pbmi, uint pila, out IntPtr ppvBits, IntPtr hSection, uint dwOffset);

            [DllImport(GDI, CallingConvention = CallingConvention.Winapi)]
            [return: MarshalAs(UnmanagedType.Bool)]
            public static extern bool DeleteDC(IntPtr hdc);

            [DllImport(GDI, CallingConvention = CallingConvention.Winapi)]
            public static extern IntPtr SelectObject(IntPtr hDC, IntPtr hObject);

            [DllImport(GDI, CallingConvention = CallingConvention.Winapi)]
            [return: MarshalAs(UnmanagedType.Bool)]
            public static extern bool DeleteObject(IntPtr hObject);

            [DllImport(DWMAPI, CallingConvention = CallingConvention.Winapi)]
            public static extern int DwmSetWindowAttribute(IntPtr hwnd, WindowAttribute dwAttribute, ref bool pvAttribute, int cbAttribute);
        }
    }

    public delegate void HitTestEventHandler(object sender, HitTestEventArgs e);

    public enum HitResult
    {
        Transparent = -1,
        Nowhere = 0,
        Client = 1,
        Caption = 2,
        Left = 10,
        Right = 11,
        Top = 12,
        TopLeft = 13,
        TopRight = 14,
        Bottom = 15,
        BottomLeft = 16,
        BottomRight = 17,
        Border = 18
    }

    public class HitTestEventArgs : EventArgs
    {
        public HitTestEventArgs(Point location, HitResult hitResult)
        {
            Location = location;
            HitResult = hitResult;
        }
        public Point Location { get; }
        public HitResult HitResult { get; set; }
    }
}
