Program.cs

using System;
using System.IO;
using System.Drawing;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using System.Management;

namespace ScreenMagnifier
{
    internal static class Program
    {
        [STAThread]
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new MagnifierForm());
        }
    }

    public class MagnifierForm : Form
    {
        // ===== Win32 P/Invoke 声明 =====
        [DllImport("user32.dll")]
        static extern bool RegisterHotKey(IntPtr hWnd, int id, uint fsModifiers, uint vk);
        [DllImport("user32.dll")]
        static extern bool UnregisterHotKey(IntPtr hWnd, int id);
        [DllImport("user32.dll")]
        static extern bool GetCursorPos(out POINT lpPoint);
        [DllImport("user32.dll", CharSet = CharSet.Auto)]
        static extern IntPtr CreateWindowEx(int dwExStyle, string lpszClassName, string lpszWindowName,
            int style, int x, int y, int width, int height, IntPtr hwndParent, IntPtr hMenu, IntPtr hInst, IntPtr pvParam);
        [DllImport("user32.dll")]
        static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int X, int Y, int cx, int cy, uint uFlags);
        [DllImport("user32.dll")]
        static extern bool UpdateLayeredWindow(IntPtr hwnd, IntPtr hdcDest, ref POINT pptDest, ref SIZE psize,
            IntPtr hdcSrc, ref POINT pptSrc, uint crKey, ref BLENDFUNCTION pblend, uint dwFlags);
        [DllImport("user32.dll")]
        static extern IntPtr GetDC(IntPtr hwnd);
        [DllImport("user32.dll")]
        static extern int ReleaseDC(IntPtr hwnd, IntPtr hdc);
        [DllImport("gdi32.dll")]
        static extern IntPtr CreateCompatibleDC(IntPtr hdc);
        [DllImport("gdi32.dll")]
        static extern bool DeleteDC(IntPtr hdc);
        [DllImport("gdi32.dll")]
        static extern IntPtr SelectObject(IntPtr hdc, IntPtr hgdiobj);
        [DllImport("gdi32.dll")]
        static extern bool DeleteObject(IntPtr hObject);

        [StructLayout(LayoutKind.Sequential)]
        struct SIZE { public int cx, cy; }

        [StructLayout(LayoutKind.Sequential)]
        struct BLENDFUNCTION
        {
            public byte BlendOp;
            public byte BlendFlags;
            public byte SourceConstantAlpha;
            public byte AlphaFormat;
        }

        const int ULW_ALPHA = 0x00000002;
        const int AC_SRC_OVER = 0x00;
        const int AC_SRC_ALPHA = 0x01;

        [DllImport("Magnification.dll", SetLastError = true)]
        static extern bool MagInitialize();
        [DllImport("Magnification.dll")]
        static extern bool MagUninitialize();
        [DllImport("Magnification.dll")]
        static extern bool MagSetWindowSource(IntPtr hwnd, RECT rect);
        [DllImport("Magnification.dll")]
        static extern bool MagSetWindowTransform(IntPtr hwnd, ref MAGTRANSFORM pTransform);

        [DllImport("user32.dll")]
        static extern IntPtr SetWindowsHookEx(int idHook, Delegate lpfn, IntPtr hMod, uint dwThreadId);
        [DllImport("user32.dll")]
        static extern bool UnhookWindowsHookEx(IntPtr hhk);
        [DllImport("user32.dll")]
        static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode, IntPtr wParam, IntPtr lParam);
        [DllImport("kernel32.dll")]
        static extern IntPtr GetModuleHandle(string lpModuleName);
        [DllImport("user32.dll")]
        static extern short GetAsyncKeyState(int vKey);

        delegate IntPtr LowLevelKeyboardProc(int nCode, IntPtr wParam, IntPtr lParam);
        const int WH_KEYBOARD_LL = 13;
        const int WM_KEYDOWN = 0x0100;
        const int VK_ESCAPE = 0x1B;
        const int VK_LWIN = 0x5B;
        const int VK_RWIN = 0x5C;

        [StructLayout(LayoutKind.Sequential)]
        struct POINT { public int X; public int Y; }

        [StructLayout(LayoutKind.Sequential)]
        struct RECT { public int Left, Top, Right, Bottom; }

        [StructLayout(LayoutKind.Sequential)]
        struct MAGTRANSFORM
        {
            public float m00, m01, m02;
            public float m10, m11, m12;
            public float m20, m21, m22;
        }

        const int WS_CHILD = 0x40000000;
        const int WS_VISIBLE = 0x10000000;
        const int HOTKEY_ID = 9000;
        const uint MOD_CONTROL = 0x0002;
        const uint MOD_ALT = 0x0001;
        const uint MOD_SHIFT = 0x0004;
        const uint MOD_WIN = 0x0008;
        const uint VK_M = 0x4D; // 默认快捷键: Ctrl+Alt+M

        IntPtr magHwnd;
        IntPtr keyboardHook = IntPtr.Zero;
        LowLevelKeyboardProc keyboardProc;
        float zoomFactor = 2.0f;            // 当前放大倍数：1.5 / 2.0 / 2.5
        const double RegionHeightCm = 1.6;  // 分两栏/不分栏：鼠标行上下各 0.8cm，共 1.6cm

        int srcHeightPx;
        int srcCenter1SizePx;
        int srcCenter2SizePx;
        int srcFullWidthPx;
        OverlayForm overlay;
        int screenCenterX, screenCenterY;
        bool active = false;
        int mode = 2; // 0=分两栏, 1=不分栏, 2=中心放大1, 3=中心放大2
        System.Windows.Forms.Timer timer;
        NotifyIcon trayIcon;

        uint currentModifiers;
        uint currentVk;
        string settingsDir;
        string settingsPath;
        ToolStripMenuItem menuSplit;
        ToolStripMenuItem menuNoSplit;
        ToolStripMenuItem menuCenter1;
        ToolStripMenuItem menuCenter2;
        ToolStripMenuItem menuZoom15;
        ToolStripMenuItem menuZoom20;
        ToolStripMenuItem menuZoom25;

        public MagnifierForm()
        {
            FormBorderStyle = FormBorderStyle.None;
            TopMost = true;
            ShowInTaskbar = false;
            StartPosition = FormStartPosition.Manual;

            var screen = Screen.PrimaryScreen.Bounds;
            screenCenterX = screen.Width / 2;
            screenCenterY = screen.Height / 2;

            var (ppcmX, ppcmY) = GetPixelsPerCm();
            srcHeightPx = Math.Max(10, (int)(RegionHeightCm * ppcmY));
            srcCenter1SizePx = Math.Max(10, (int)(3.0 * ppcmX));
            srcCenter2SizePx = Math.Max(10, (int)(7.0 * ppcmX));
            srcFullWidthPx = screen.Width;

            // 初始化热键设置路径与默认值
            currentModifiers = MOD_CONTROL | MOD_ALT;
            currentVk = VK_M;
            settingsDir = Path.Combine(
                Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
                "ScreenMagnifier");
            settingsPath = Path.Combine(settingsDir, "settings.ini");
            LoadHotkeySettings();

            ApplyWindowSize();

            Visible = false;
            // 未启用时缩到 1×1，避免启动/关闭后在屏幕左上角残留灰色条，同时保持窗口在屏幕内，防止 Magnifier 黑屏
            Size = new Size(1, 1);
            Opacity = 1.0;

            SetupTrayIcon();

            // 透明覆盖窗口延迟创建，避免启动时异常
            overlay = null;

            Load += MagnifierForm_Load;
            FormClosing += (s, e) =>
            {
                UninstallKeyboardHook();
                UnregisterHotKey(Handle, HOTKEY_ID);
                MagUninitialize();
                trayIcon.Visible = false;
                // overlay 由 Application.Exit 统一关闭，避免在枚举 OpenForms 时修改集合
            };
        }

        void SetupTrayIcon()
        {
            var menu = new ContextMenuStrip();

            // 设置子菜单：分两栏 / 不分栏 / 中心放大1 / 中心放大2（互斥）
            menuSplit = new ToolStripMenuItem("分两栏", null, (s, e) => SetMode(0))
            {
                Checked = false,
                CheckOnClick = false
            };
            menuNoSplit = new ToolStripMenuItem("不分栏", null, (s, e) => SetMode(1))
            {
                Checked = false,
                CheckOnClick = false
            };
            menuCenter1 = new ToolStripMenuItem("中心放大1", null, (s, e) => SetMode(2))
            {
                Checked = true,
                CheckOnClick = false
            };
            menuCenter2 = new ToolStripMenuItem("中心放大2", null, (s, e) => SetMode(3))
            {
                Checked = false,
                CheckOnClick = false
            };

            // 放大倍数子菜单：1.5 / 2.0 / 2.5（互斥）
            menuZoom15 = new ToolStripMenuItem("1.5 倍", null, (s, e) => SetZoomFactor(1.5f))
            {
                Checked = false,
                CheckOnClick = false
            };
            menuZoom20 = new ToolStripMenuItem("2.0 倍", null, (s, e) => SetZoomFactor(2.0f))
            {
                Checked = true,
                CheckOnClick = false
            };
            menuZoom25 = new ToolStripMenuItem("2.5 倍", null, (s, e) => SetZoomFactor(2.5f))
            {
                Checked = false,
                CheckOnClick = false
            };

            var zoomMenu = new ToolStripMenuItem("放大倍数");
            zoomMenu.DropDownItems.Add(menuZoom15);
            zoomMenu.DropDownItems.Add(menuZoom20);
            zoomMenu.DropDownItems.Add(menuZoom25);

            var settingsMenu = new ToolStripMenuItem("设置");
            settingsMenu.DropDownItems.Add(menuSplit);
            settingsMenu.DropDownItems.Add(menuNoSplit);
            settingsMenu.DropDownItems.Add(menuCenter1);
            settingsMenu.DropDownItems.Add(menuCenter2);
            settingsMenu.DropDownItems.Add(new ToolStripSeparator());
            settingsMenu.DropDownItems.Add(zoomMenu);
            settingsMenu.DropDownItems.Add(new ToolStripSeparator());
            settingsMenu.DropDownItems.Add("设置热键...", null, (s, e) => ShowHotkeyDialog());
            menu.Items.Add(settingsMenu);
            menu.Items.Add(new ToolStripSeparator());
            menu.Items.Add("关于", null, (s, e) => ShowAbout());
            menu.Items.Add(new ToolStripSeparator());
            menu.Items.Add("退出", null, (s, e) => BeginInvoke(new Action(() => Application.Exit())));

            // 从程序集嵌入资源加载托盘图标
            Icon icon;
            try
            {
                var stream = System.Reflection.Assembly.GetExecutingAssembly()
                    .GetManifestResourceStream("ScreenMagnifier.放大镜.ico");
                if (stream != null)
                    icon = new Icon(stream);
                else
                    icon = SystemIcons.Application;
            }
            catch
            {
                icon = SystemIcons.Application;
            }

            trayIcon = new NotifyIcon
            {
                Icon = icon,
                Visible = true,
                ContextMenuStrip = menu
            };
            UpdateTrayTooltip();

            // 根据加载的配置设置放大倍数菜单勾选状态
            menuZoom15.Checked = Math.Abs(zoomFactor - 1.5f) < 0.001f;
            menuZoom20.Checked = Math.Abs(zoomFactor - 2.0f) < 0.001f;
            menuZoom25.Checked = Math.Abs(zoomFactor - 2.5f) < 0.001f;
        }

        void SetMode(int newMode)
        {
            mode = newMode;
            menuSplit.Checked = mode == 0;
            menuNoSplit.Checked = mode == 1;
            menuCenter1.Checked = mode == 2;
            menuCenter2.Checked = mode == 3;
            ApplyWindowSize();
            ApplyZoomTransform();
        }

        void SetZoomFactor(float newZoom)
        {
            // 仅允许 1.5 / 2.0 / 2.5 三档
            if (newZoom != 1.5f && newZoom != 2.0f && newZoom != 2.5f) return;
            zoomFactor = newZoom;
            menuZoom15.Checked = Math.Abs(zoomFactor - 1.5f) < 0.001f;
            menuZoom20.Checked = Math.Abs(zoomFactor - 2.0f) < 0.001f;
            menuZoom25.Checked = Math.Abs(zoomFactor - 2.5f) < 0.001f;
            // 仅在放大镜启用时立即调整窗口与变换；关闭时保持 1×1，避免残留遮挡
            if (active)
            {
                ApplyWindowSize();
                ApplyZoomTransform();
            }
        }

        void ShowAbout()
        {
            string aboutText =
                "屏幕放大镜  ver1.5\n\n" +
                "【核心功能】\n" +
                "• 屏幕局部实时放大，支持 1.5 / 2.0 / 2.5 倍三档放大倍数\n" +
                "• 四种显示模式：\n" +
                "  – 分两栏：半屏宽度，以屏幕中线为界分左右显示\n" +
                "  – 不分栏：半屏宽度，统一从屏幕左侧显示\n" +
                "  – 中心放大1：以鼠标为中心，3cm 直径圆形区域原位放大\n" +
                "  – 中心放大2：以鼠标为中心，7cm 直径圆形区域原位放大\n" +
                "• 全局快捷键：Ctrl+Alt+M 显示/隐藏放大镜\n" +
                "• 关闭放大：按 ESC 键或在放大区域点击鼠标右键\n" +
                "• 系统托盘右键菜单可切换模式、调整倍数及设置热键\n\n" +
                "作者：星空缘渡\n" +
                "邮箱：28903262@qq.com\n" +
                "时间：2026年7月\n\n" +
                "本程序为免费软件，可自由使用与传播。";

            MessageBox.Show(this, aboutText, "关于", MessageBoxButtons.OK, MessageBoxIcon.Information);
        }

        void LoadHotkeySettings()
        {
            try
            {
                if (!File.Exists(settingsPath)) return;
                uint mods = 0;
                uint vk = 0;
                foreach (var line in File.ReadAllLines(settingsPath))
                {
                    var kv = line.Split('=');
                    if (kv.Length != 2) continue;
                    var key = kv[0].Trim();
                    var value = kv[1].Trim();
                    if (key == "Modifiers") uint.TryParse(value, out mods);
                    else if (key == "VirtualKey") uint.TryParse(value, out vk);
                }
                if (mods != 0 && vk != 0)
                {
                    currentModifiers = mods;
                    currentVk = vk;
                }
            }
            catch { /* 使用默认值 */ }
        }

        void SaveHotkeySettings()
        {
            try
            {
                Directory.CreateDirectory(settingsDir);
                File.WriteAllLines(settingsPath, new[]
                {
                    $"Modifiers={currentModifiers}",
                    $"VirtualKey={currentVk}"
                });
            }
            catch { /* 忽略写入失败 */ }
        }

        void ApplyHotkey(uint modifiers, uint vk)
        {
            UnregisterHotKey(Handle, HOTKEY_ID);
            currentModifiers = modifiers;
            currentVk = vk;
            if (!RegisterHotKey(Handle, HOTKEY_ID, currentModifiers, currentVk))
            {
                string hotkeyText = FormatHotkey(currentModifiers, currentVk);
                MessageBox.Show($"快捷键 {hotkeyText} 注册失败，可能已被其他程序占用。");
            }
            SaveHotkeySettings();
            UpdateTrayTooltip();
        }

        void UpdateTrayTooltip()
        {
            if (trayIcon == null) return;
            string hotkeyText = FormatHotkey(currentModifiers, currentVk);
            trayIcon.Text = $"屏幕放大镜 ({hotkeyText} 开关)";
        }

        string FormatHotkey(uint modifiers, uint vk)
        {
            var parts = new System.Collections.Generic.List<string>();
            if ((modifiers & MOD_CONTROL) != 0) parts.Add("Ctrl");
            if ((modifiers & MOD_ALT) != 0) parts.Add("Alt");
            if ((modifiers & MOD_SHIFT) != 0) parts.Add("Shift");
            if ((modifiers & MOD_WIN) != 0) parts.Add("Win");

            string keyName;
            switch (vk)
            {
                case 0x41: keyName = "A"; break;
                case 0x42: keyName = "B"; break;
                case 0x43: keyName = "C"; break;
                case 0x44: keyName = "D"; break;
                case 0x45: keyName = "E"; break;
                case 0x46: keyName = "F"; break;
                case 0x47: keyName = "G"; break;
                case 0x48: keyName = "H"; break;
                case 0x49: keyName = "I"; break;
                case 0x4A: keyName = "J"; break;
                case 0x4B: keyName = "K"; break;
                case 0x4C: keyName = "L"; break;
                case 0x4D: keyName = "M"; break;
                case 0x4E: keyName = "N"; break;
                case 0x4F: keyName = "O"; break;
                case 0x50: keyName = "P"; break;
                case 0x51: keyName = "Q"; break;
                case 0x52: keyName = "R"; break;
                case 0x53: keyName = "S"; break;
                case 0x54: keyName = "T"; break;
                case 0x55: keyName = "U"; break;
                case 0x56: keyName = "V"; break;
                case 0x57: keyName = "W"; break;
                case 0x58: keyName = "X"; break;
                case 0x59: keyName = "Y"; break;
                case 0x5A: keyName = "Z"; break;
                case 0x30: keyName = "0"; break;
                case 0x31: keyName = "1"; break;
                case 0x32: keyName = "2"; break;
                case 0x33: keyName = "3"; break;
                case 0x34: keyName = "4"; break;
                case 0x35: keyName = "5"; break;
                case 0x36: keyName = "6"; break;
                case 0x37: keyName = "7"; break;
                case 0x38: keyName = "8"; break;
                case 0x39: keyName = "9"; break;
                case 0x70: keyName = "F1"; break;
                case 0x71: keyName = "F2"; break;
                case 0x72: keyName = "F3"; break;
                case 0x73: keyName = "F4"; break;
                case 0x74: keyName = "F5"; break;
                case 0x75: keyName = "F6"; break;
                case 0x76: keyName = "F7"; break;
                case 0x77: keyName = "F8"; break;
                case 0x78: keyName = "F9"; break;
                case 0x79: keyName = "F10"; break;
                case 0x7A: keyName = "F11"; break;
                case 0x7B: keyName = "F12"; break;
                default: keyName = ((Keys)vk).ToString(); break;
            }

            parts.Add(keyName);
            return string.Join("+", parts);
        }

        void ShowHotkeyDialog()
        {
            using var dlg = new HotkeyInputForm(currentModifiers, currentVk);
            if (dlg.ShowDialog(this) == DialogResult.OK)
            {
                ApplyHotkey(dlg.Modifiers, dlg.VirtualKey);
            }
        }

        void EnsureOverlay()
        {
            if (overlay == null)
            {
                overlay = new OverlayForm();
                overlay.CreateWindowHandle();
                overlay.DrawOverlay();
            }
        }

        void ApplyWindowSize()
        {
            int srcWidthPx, srcHeight;
            float zoom;
            if (mode == 0)
            {
                srcWidthPx = screenCenterX;
                srcHeight = srcHeightPx;
                zoom = zoomFactor;
            }
            else if (mode == 1)
            {
                srcWidthPx = screenCenterX;
                srcHeight = srcHeightPx;
                zoom = zoomFactor;
            }
            else if (mode == 2)
            {
                srcWidthPx = srcCenter1SizePx;
                srcHeight = srcCenter1SizePx;
                zoom = zoomFactor;
            }
            else
            {
                srcWidthPx = srcCenter2SizePx;
                srcHeight = srcCenter2SizePx;
                zoom = zoomFactor;
            }
            Width = (int)(srcWidthPx * zoom);
            Height = (int)(srcHeight * zoom);

            // 关键：同步更新 Magnifier 子窗口的大小，否则切换模式后多出的区域会显示为黑条
            if (magHwnd != IntPtr.Zero)
            {
                SetWindowPos(magHwnd, IntPtr.Zero, 0, 0, ClientSize.Width, ClientSize.Height, 0);
            }

            // 中心放大 1/2 模式下显示覆盖窗口，其他模式隐藏
            if (active && (mode == 2 || mode == 3))
            {
                EnsureOverlay();
                overlay.Visible = true;
            }
            else if (overlay != null)
            {
                overlay.Visible = false;
            }
        }

        void ApplyZoomTransform()
        {
            if (magHwnd == IntPtr.Zero) return;
            SetTransform(zoomFactor);
        }

        void MagnifierForm_Load(object sender, EventArgs e)
        {
            if (!MagInitialize())
            {
                MessageBox.Show("放大镜API初始化失败，请确认系统支持Magnification API。");
                Application.Exit();
                return;
            }

            magHwnd = CreateWindowEx(0, "Magnifier", "MagnifierWindow",
                WS_CHILD | WS_VISIBLE, 0, 0, ClientSize.Width, ClientSize.Height,
                Handle, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);

            SetWindowPos(magHwnd, IntPtr.Zero, 0, 0, ClientSize.Width, ClientSize.Height, 0);

            ApplyZoomTransform();

            // 创建 magHwnd 后重新应用窗口大小，确保 Magnifier 子窗口与窗体尺寸一致
            ApplyWindowSize();

            if (!RegisterHotKey(Handle, HOTKEY_ID, currentModifiers, currentVk))
            {
                string hotkeyText = FormatHotkey(currentModifiers, currentVk);
                MessageBox.Show($"快捷键 {hotkeyText} 注册失败，可能已被其他程序占用。");
            }

            timer = new System.Windows.Forms.Timer { Interval = 15 }; // ~60fps
            timer.Tick += Timer_Tick;

            // 启动时默认开启放大功能，避免未启用时左上角出现灰色块
            ToggleMagnifier();
        }

        void SetTransform(float scale)
        {
            var t = new MAGTRANSFORM { m00 = scale, m11 = scale, m22 = 1.0f };
            MagSetWindowTransform(magHwnd, ref t);
        }

        void Timer_Tick(object sender, EventArgs e)
        {
            GetCursorPos(out POINT p);

            if (mode == 0)
            {
                UpdateSplitMode(p);
            }
            else if (mode == 1)
            {
                UpdateNoSplitMode(p);
            }
            else
            {
                UpdateCenterMode(p);
            }
        }

        void UpdateSplitMode(POINT p)
        {
            // 放大区域：以屏幕正中间为分割线
            // 以鼠标所在行为中心线，上下各 0.8cm（共 1.6cm）
            int top = p.Y - srcHeightPx / 2;

            RECT rect;
            if (p.X < screenCenterX)
            {
                // 鼠标在左侧：放大显示屏幕中线至最左侧
                rect = new RECT
                {
                    Left = 0,
                    Top = top,
                    Right = screenCenterX,
                    Bottom = top + srcHeightPx
                };
            }
            else
            {
                // 鼠标在右侧：放大显示屏幕中线至最右侧
                rect = new RECT
                {
                    Left = screenCenterX,
                    Top = top,
                    Right = srcFullWidthPx,
                    Bottom = top + srcHeightPx
                };
            }
            MagSetWindowSource(magHwnd, rect);

            // 根据鼠标所在象限决定放大镜显示位置
            // 以屏幕正中心为原点：
            // 第1、2象限（上方区域）：显示位置在鼠标下方
            // 第3、4象限（下方区域）：显示位置在鼠标上方
            // 显示窗口均以屏幕最左侧为起点
            int formX = 0;
            int formY;
            if (p.Y < screenCenterY)
            {
                // 第1、2象限：鼠标下方
                formY = p.Y + 20;
            }
            else
            {
                // 第3、4象限：鼠标上方
                formY = p.Y - Height - 20;
            }

            SetWindowPos(Handle, new IntPtr(-1) /* HWND_TOPMOST */, formX, formY, Width, Height, 0);

            // 非单字放大模式下隐藏覆盖窗口
            if (overlay != null && overlay.Visible)
            {
                overlay.Visible = false;
            }
        }

        void UpdateNoSplitMode(POINT p)
        {
            // 放大区域：半屏宽度
            // 以鼠标所在行为中心线，上下各 0.8cm（共 1.6cm）
            int top = p.Y - srcHeightPx / 2;

            RECT rect;
            if (p.X < screenCenterX)
            {
                // 鼠标在左侧：放大显示屏幕中线至最左侧
                rect = new RECT
                {
                    Left = 0,
                    Top = top,
                    Right = screenCenterX,
                    Bottom = top + srcHeightPx
                };
            }
            else
            {
                // 鼠标在右侧：放大显示屏幕中线至最右侧
                rect = new RECT
                {
                    Left = screenCenterX,
                    Top = top,
                    Right = srcFullWidthPx,
                    Bottom = top + srcHeightPx
                };
            }
            MagSetWindowSource(magHwnd, rect);

            // 显示位置：
            // 当鼠标位于屏幕左侧时，放大显示屏幕中线至最左侧的内容
            // 当鼠标位于屏幕右侧时，放大显示中线至屏幕右侧的内容
            // 显示位置均从屏幕最左侧开始
            int formX = 0;

            int formY;
            if (p.Y < screenCenterY)
            {
                // 上半部：鼠标下方
                formY = p.Y + 20;
            }
            else
            {
                // 下半部：鼠标上方
                formY = p.Y - Height - 20;
            }

            SetWindowPos(Handle, new IntPtr(-1) /* HWND_TOPMOST */, formX, formY, Width, Height, 0);

            // 非单字放大模式下隐藏覆盖窗口
            if (overlay != null && overlay.Visible)
            {
                overlay.Visible = false;
            }
        }

        void UpdateCenterMode(POINT p)
        {
            // 中心放大：以鼠标位置为中心，根据当前模式使用 3cm 或 6.5cm 直径圆形区域，原位放大 zoomFactor 倍
            int srcSize = (mode == 2) ? srcCenter1SizePx : srcCenter2SizePx;
            int half = srcSize / 2;
            var rect = new RECT
            {
                Left = p.X - half,
                Top = p.Y - half,
                Right = p.X + half,
                Bottom = p.Y + half
            };
            MagSetWindowSource(magHwnd, rect);

            // 原位放大：放大镜窗口中心与源区域中心重合
            int formX = p.X - Width / 2;
            int formY = p.Y - Height / 2;

            SetWindowPos(Handle, new IntPtr(-1) /* HWND_TOPMOST */, formX, formY, Width, Height, 0);

            // 同步覆盖窗口位置和大小，并将其置于放大镜窗口之上
            EnsureOverlay();
            overlay.Visible = true;
            SetWindowPos(overlay.Handle, new IntPtr(-1) /* HWND_TOPMOST */, formX, formY, Width, Height, 0);
            overlay.DrawOverlay();
        }

        protected override void WndProc(ref Message m)
        {
            const int WM_HOTKEY = 0x0312;
            const int WM_RBUTTONDOWN = 0x0204;
            if (m.Msg == WM_HOTKEY && m.WParam.ToInt32() == HOTKEY_ID)
            {
                ToggleMagnifier();
            }
            else if (m.Msg == WM_RBUTTONDOWN && active)
            {
                ToggleMagnifier();
                return;
            }
            base.WndProc(ref m);
        }

        void ToggleMagnifier()
        {
            active = !active;
            if (active)
            {
                // 启用前恢复窗口尺寸，否则 Magnifier 子窗口仍为 1×1，会显示黑块
                ApplyWindowSize();
                // 先定位到鼠标位置再显示，避免在 (0,0) 闪现
                Timer_Tick(this, EventArgs.Empty);
                // 启用时安装 ESC 全局钩子
                InstallKeyboardHook();
            }
            else
            {
                // 关闭时卸载 ESC 全局钩子
                UninstallKeyboardHook();
            }
            Visible = active;
            if (!active)
            {
                // 关闭后缩到 1×1，避免残留灰色遮挡条
                Size = new Size(1, 1);
            }
            if (active && (mode == 2 || mode == 3))
            {
                EnsureOverlay();
                overlay.Visible = true;
            }
            else if (overlay != null)
            {
                overlay.Visible = false;
            }
            timer.Enabled = active;
        }

        void InstallKeyboardHook()
        {
            if (keyboardHook != IntPtr.Zero) return;
            keyboardProc = new LowLevelKeyboardProc(KeyboardHookCallback);
            keyboardHook = SetWindowsHookEx(WH_KEYBOARD_LL, keyboardProc, GetModuleHandle(null), 0);
        }

        void UninstallKeyboardHook()
        {
            if (keyboardHook != IntPtr.Zero)
            {
                UnhookWindowsHookEx(keyboardHook);
                keyboardHook = IntPtr.Zero;
                keyboardProc = null;
            }
        }

        IntPtr KeyboardHookCallback(int nCode, IntPtr wParam, IntPtr lParam)
        {
            if (nCode >= 0 && wParam == (IntPtr)WM_KEYDOWN)
            {
                int vkCode = Marshal.ReadInt32(lParam);
                if (vkCode == VK_ESCAPE && active)
                {
                    BeginInvoke(new Action(() => ToggleMagnifier()));
                    return (IntPtr)1; // 阻止 ESC 继续传递
                }
            }
            return CallNextHookEx(keyboardHook, nCode, wParam, lParam);
        }

        // 热键输入对话框，用于捕获用户自定义全局热键
        class HotkeyInputForm : Form
        {
            public uint Modifiers { get; private set; }
            public uint VirtualKey { get; private set; }

            TextBox inputBox;
            Button okButton;
            Button cancelButton;

            public HotkeyInputForm(uint currentModifiers, uint currentVk)
            {
                Text = "设置热键";
                FormBorderStyle = FormBorderStyle.FixedDialog;
                MaximizeBox = false;
                MinimizeBox = false;
                StartPosition = FormStartPosition.CenterScreen;
                Width = 360;
                Height = 180;

                var label = new Label
                {
                    Text = "请按下新的全局热键组合（必须包含 Ctrl/Alt/Shift/Win 之一）：",
                    Left = 20,
                    Top = 18,
                    Width = 320,
                    AutoSize = true
                };

                inputBox = new TextBox
                {
                    Left = 20,
                    Top = 50,
                    Width = 300,
                    ReadOnly = true,
                    TabStop = false
                };
                inputBox.KeyDown += InputBox_KeyDown;

                okButton = new Button
                {
                    Text = "确定",
                    Left = 60,
                    Top = 95,
                    Width = 80,
                    DialogResult = DialogResult.OK
                };
                okButton.Click += OkButton_Click;

                cancelButton = new Button
                {
                    Text = "取消",
                    Left = 200,
                    Top = 95,
                    Width = 80,
                    DialogResult = DialogResult.Cancel
                };

                Controls.Add(label);
                Controls.Add(inputBox);
                Controls.Add(okButton);
                Controls.Add(cancelButton);
                AcceptButton = okButton;
                CancelButton = cancelButton;

                Modifiers = currentModifiers;
                VirtualKey = currentVk;
                inputBox.Text = FormatInput(currentModifiers, currentVk);
            }

            void InputBox_KeyDown(object sender, KeyEventArgs e)
            {
                e.SuppressKeyPress = true;

                // 忽略单独的修饰键
                if (e.KeyCode == Keys.ControlKey || e.KeyCode == Keys.ShiftKey ||
                    e.KeyCode == Keys.Menu || e.KeyCode == Keys.LWin || e.KeyCode == Keys.RWin)
                {
                    return;
                }

                uint mods = 0;
                if (e.Control) mods |= MOD_CONTROL;
                if (e.Alt) mods |= MOD_ALT;
                if (e.Shift) mods |= MOD_SHIFT;
                if (((ushort)GetAsyncKeyState(VK_LWIN) & 0x8000) != 0 ||
                    ((ushort)GetAsyncKeyState(VK_RWIN) & 0x8000) != 0)
                {
                    mods |= MOD_WIN;
                }

                if (mods == 0)
                {
                    MessageBox.Show("必须至少包含 Ctrl、Alt、Shift 或 Win 键中的一个。", "提示", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    return;
                }

                Modifiers = mods;
                VirtualKey = (uint)e.KeyCode;
                inputBox.Text = FormatInput(Modifiers, VirtualKey);
            }

            void OkButton_Click(object sender, EventArgs e)
            {
                if (Modifiers == 0 || VirtualKey == 0)
                {
                    MessageBox.Show("请按下一个有效的热键组合。", "提示", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    DialogResult = DialogResult.None;
                }
            }

            string FormatInput(uint modifiers, uint vk)
            {
                var parts = new System.Collections.Generic.List<string>();
                if ((modifiers & MOD_CONTROL) != 0) parts.Add("Ctrl");
                if ((modifiers & MOD_ALT) != 0) parts.Add("Alt");
                if ((modifiers & MOD_SHIFT) != 0) parts.Add("Shift");
                if ((modifiers & MOD_WIN) != 0) parts.Add("Win");

                string keyName;
                switch (vk)
                {
                    case 0x41: keyName = "A"; break;
                    case 0x42: keyName = "B"; break;
                    case 0x43: keyName = "C"; break;
                    case 0x44: keyName = "D"; break;
                    case 0x45: keyName = "E"; break;
                    case 0x46: keyName = "F"; break;
                    case 0x47: keyName = "G"; break;
                    case 0x48: keyName = "H"; break;
                    case 0x49: keyName = "I"; break;
                    case 0x4A: keyName = "J"; break;
                    case 0x4B: keyName = "K"; break;
                    case 0x4C: keyName = "L"; break;
                    case 0x4D: keyName = "M"; break;
                    case 0x4E: keyName = "N"; break;
                    case 0x4F: keyName = "O"; break;
                    case 0x50: keyName = "P"; break;
                    case 0x51: keyName = "Q"; break;
                    case 0x52: keyName = "R"; break;
                    case 0x53: keyName = "S"; break;
                    case 0x54: keyName = "T"; break;
                    case 0x55: keyName = "U"; break;
                    case 0x56: keyName = "V"; break;
                    case 0x57: keyName = "W"; break;
                    case 0x58: keyName = "X"; break;
                    case 0x59: keyName = "Y"; break;
                    case 0x5A: keyName = "Z"; break;
                    case 0x30: keyName = "0"; break;
                    case 0x31: keyName = "1"; break;
                    case 0x32: keyName = "2"; break;
                    case 0x33: keyName = "3"; break;
                    case 0x34: keyName = "4"; break;
                    case 0x35: keyName = "5"; break;
                    case 0x36: keyName = "6"; break;
                    case 0x37: keyName = "7"; break;
                    case 0x38: keyName = "8"; break;
                    case 0x39: keyName = "9"; break;
                    case 0x70: keyName = "F1"; break;
                    case 0x71: keyName = "F2"; break;
                    case 0x72: keyName = "F3"; break;
                    case 0x73: keyName = "F4"; break;
                    case 0x74: keyName = "F5"; break;
                    case 0x75: keyName = "F6"; break;
                    case 0x76: keyName = "F7"; break;
                    case 0x77: keyName = "F8"; break;
                    case 0x78: keyName = "F9"; break;
                    case 0x79: keyName = "F10"; break;
                    case 0x7A: keyName = "F11"; break;
                    case 0x7B: keyName = "F12"; break;
                    default: keyName = ((Keys)vk).ToString(); break;
                }

                parts.Add(keyName);
                return string.Join("+", parts);
            }
        }

        // 透明覆盖窗口，用于绘制绿色虚线圆周（使用Layered Window实现真正透明）
        class OverlayForm : Form
        {
            public OverlayForm()
            {
                FormBorderStyle = FormBorderStyle.None;
                StartPosition = FormStartPosition.Manual;
                ShowInTaskbar = false;
                TopMost = true;
                Width = 100;
                Height = 100;
                Visible = false;
            }

            public void CreateWindowHandle()
            {
                var unused = Handle; // 触发受保护的 CreateHandle()
            }

            protected override CreateParams CreateParams
            {
                get
                {
                    var cp = base.CreateParams;
                    cp.ExStyle |= 0x80000; // WS_EX_LAYERED，分层透明窗口
                    cp.ExStyle |= 0x20;    // WS_EX_TRANSPARENT，使鼠标事件穿透覆盖窗口
                    cp.ExStyle |= 0x80;    // WS_EX_TOOLWINDOW，避免显示在任务栏
                    return cp;
                }
            }

            protected override void OnPaint(PaintEventArgs e)
            {
                // 分层窗口不使用默认绘制
            }

            protected override void OnResize(EventArgs e)
            {
                base.OnResize(e);
                if (ClientSize.Width > 0 && ClientSize.Height > 0)
                    DrawOverlay();
            }

            public void DrawOverlay()
            {
                if (ClientSize.Width <= 0 || ClientSize.Height <= 0) return;

                using var bmp = new Bitmap(ClientSize.Width, ClientSize.Height, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
                using (var g = Graphics.FromImage(bmp))
                {
                    g.Clear(Color.Transparent);
                    g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
                    using var pen = new Pen(Color.Lime, 2)
                    {
                        DashStyle = System.Drawing.Drawing2D.DashStyle.Dash
                    };
                    int diameter = Math.Min(ClientSize.Width, ClientSize.Height) - 2;
                    int x = (ClientSize.Width - diameter) / 2;
                    int y = (ClientSize.Height - diameter) / 2;
                    g.DrawEllipse(pen, x, y, diameter, diameter);
                }

                SetBitmap(bmp);
            }

            void SetBitmap(Bitmap bmp)
            {
                IntPtr screenDC = IntPtr.Zero;
                IntPtr memDC = IntPtr.Zero;
                IntPtr hBitmap = IntPtr.Zero;
                IntPtr oldBitmap = IntPtr.Zero;
                try
                {
                    screenDC = GetDC(IntPtr.Zero);
                    memDC = CreateCompatibleDC(screenDC);
                    hBitmap = bmp.GetHbitmap(Color.FromArgb(0));
                    oldBitmap = SelectObject(memDC, hBitmap);

                    var size = new SIZE { cx = bmp.Width, cy = bmp.Height };
                    var pointSource = new POINT { X = 0, Y = 0 };
                    var topPos = new POINT { X = Left, Y = Top };
                    var blend = new BLENDFUNCTION
                    {
                        BlendOp = AC_SRC_OVER,
                        BlendFlags = 0,
                        SourceConstantAlpha = 255,
                        AlphaFormat = AC_SRC_ALPHA
                    };

                    UpdateLayeredWindow(Handle, screenDC, ref topPos, ref size, memDC, ref pointSource, 0, ref blend, ULW_ALPHA);
                }
                finally
                {
                    if (oldBitmap != IntPtr.Zero) SelectObject(memDC, oldBitmap);
                    if (hBitmap != IntPtr.Zero) DeleteObject(hBitmap);
                    if (memDC != IntPtr.Zero) DeleteDC(memDC);
                    if (screenDC != IntPtr.Zero) ReleaseDC(IntPtr.Zero, screenDC);
                }
            }
        }

        // 通过WMI读取显示器物理尺寸(cm)，计算每厘米像素数；失败时回退到96DPI估算值
        (double, double) GetPixelsPerCm()
        {
            double fallback = 96.0 / 2.54;
            try
            {
                double widthCm = 0, heightCm = 0;
                var scope = new ManagementScope("root\\WMI");
                var query = new ObjectQuery("SELECT * FROM WmiMonitorBasicDisplayParams");
                using var searcher = new ManagementObjectSearcher(scope, query);
                foreach (ManagementObject mo in searcher.Get())
                {
                    widthCm = Convert.ToDouble(mo["MaxHorizontalImageSize"]);
                    heightCm = Convert.ToDouble(mo["MaxVerticalImageSize"]);
                    break;
                }
                if (widthCm > 0 && heightCm > 0)
                {
                    var bounds = Screen.PrimaryScreen.Bounds;
                    return (bounds.Width / widthCm, bounds.Height / heightCm);
                }
            }
            catch
            {
                // WMI读取失败(部分显示器/驱动不支持)，使用回退值
            }
            return (fallback, fallback);
        }
    }
}