dsh-mini 0.1.4 → 0.1.6

package/README.md

@@ -177,20 +177,29 @@ cd app
 在**任何程序**里用鼠标选中一段文字，松开后光标右下方会弹出蓝色小药丸「问大肥鱼」；点它，
 小窗自动弹到最前，选中的内容以引用块（每行 `> ` 前缀）插进输入框，直接接着提问即可。
 
-* 实现在 `app/SelectionWatcher.cs`：全局鼠标钩子（90ms 轮询）→ 松开时若拖动距离 ≥6 逻辑像素、
+* 实现在 `app/SelectionWatcher.cs`：全局鼠标轮询（90ms）→ 松开时若拖动距离 ≥6 逻辑像素、
   且不在小窗/药丸自己身上 → 后台线程等 130ms（双击选词等 320ms）→ 校验仍在前台 → 取选区。
-* Windows 没有「给我当前选区」的 API，所以取选区是：备份剪贴板 → 发一次 `Ctrl+C` →
-  轮询 `GetClipboardSequenceNumber()` 变化（最多 900ms）→ 读文本 → **还原剪贴板**。
-  用序列号而不是「文本变了没」，重复选同一段也能识别。
-* 三处保护：终端窗口（console/cascadia/mintty/putty）**不发** `Ctrl+C`（会变 SIGINT）；
-  资源管理器/桌面/任务栏（Progman/WorkerW/CabinetWClass…）直接跳过（否则会真的复制文件、
-  污染 `Win+V` 剪贴板历史）；用户已切窗就不发。
+* **取选区三级阶梯**（`SelectionReader.ReadHit`），从最无侵入的一档开始：
+  1. **UI Automation**（`TextPattern`）—— 不碰键盘、不碰剪贴板，还能拿到选区最后一行/一个字的矩形，
+     药丸因此能精确贴在它右下角。Notepad、Word、WPS、VS Code、WinForms/WPF、DSH 自己都走这一档。
+  2. **`WM_COPY`** —— 发给焦点控件，不发按键。部分老式编辑框只认这条。
+  3. **合成一次 `Ctrl+C`** —— 只有前两档都拿不到时才用。**浏览器正文（Chromium）、部分 Electron 应用、
+     某些游戏/自绘控件根本没有 `TextPattern` 也没有 `WM_COPY`，这是唯一可行的手段**。
+* **绝不做「备份剪贴板 → 复制 → 还原」**。之前那套是"选中后复制不上"的元凶：还原那一步会把你刚按的
+  `Ctrl+C` 覆盖回旧内容。现在第三档会**把选区留在剪贴板里**（你在浏览器里划一下就发现 `Ctrl+V` 有内容了），
+  代价是<u>占用</u>剪贴板，而不是<u>破坏</u>它 —— 这是读取 Chromium 选区的唯一代价，取舍写在明处。
+* 设置页的「选区读取：辅助功能读不到时改用复制」**默认打开**；关掉后浏览器正文里就不会再弹按钮，
+  但剪贴板绝对不会被碰（适合只用 Office/记事本、或对剪贴板敏感的场景）。
+* 保护：按住 Ctrl/Alt/Shift 时的拖动直接跳过（那是复制/扩选，不是重新选词）；终端
+  （console/cascadia/mintty/putty）不发按键；资源管理器/桌面/任务栏（Progman/WorkerW/CabinetWClass…）
+  一律跳过（否则会真的复制文件、污染 `Win+V` 历史）；用户按着修饰键期间完全不介入。
 * 药丸 9 秒无操作自动消失；托盘菜单「划词问大肥鱼」可随时关掉，状态存在
   `%LOCALAPPDATA%\dsh-hud\ask.txt`。
 * 因此**标题条 ✕ 只是收进托盘**（不是退出）——watcher 活在这个进程里，退出了就没法划词。
   彻底退出用托盘菜单「退出」。
-* 诊断：`hud.log` 里 `[pill]` 开头的行会写每次 `kick / skip / read N chars`；
-  往 `%LOCALAPPDATA%\dsh-hud\seltest.txt` 写任意内容可触发一次「只读不弹」的自检。
+* 诊断：`hud.log` 里 `[pill]` 开头的行会写每次 `kick / skip / read N chars`，以及实际走了哪一档：
+  `copy: wm_copy N chars`、`copy: key_chord N chars seq A->B`（`0 chars` 且序号没动，说明那儿没有真选中
+  或目标程序忽略了合成按键）；往 `%LOCALAPPDATA%\dsh-hud\seltest.txt` 写任意内容可触发一次「只读不弹」的自检。
 
 ## 常驻划词服务、全局快捷键与设置页
 
@@ -222,6 +231,8 @@ DSH小窗.exe --service --url <tokenized>    # Mutex Local\DshHudService，单
 主窗「设置 → DSH 小窗」：
 
 * 截图自动复制到剪贴板（默认开，整屏/框选都复制）；
+* 兼容模式：读不到选区时模拟 `Ctrl+C`（**默认关**。关着时只用系统辅助功能读选区，
+  完全不碰剪贴板、不发按键；打开后老式控件才读得到，代价是可能和自己按的 `Ctrl+C` 抢剪贴板）；
 * 全屏截图快捷键、框选截图快捷键（失焦即保存）。
 
 配置落在 `%LOCALAPPDATA%\dsh-hud\config.ini`（`key=value`，C# 壳、宿主插件、客户端三边都读），
@@ -256,9 +267,12 @@ cd ..;  npm pack             # → dsh-mini-0.1.0.tgz（约 600 KB）
 * 截图只有「整屏」和「框选/吸附窗口」两种，没有滚动长截图；框选吸附依赖窗口标题非空，
   无标题窗口（部分全屏游戏、自绘界面）会退化成「该点所在的整块屏幕」。
   （滚动长截图评估过：要拼接滚动帧 + 去重 + 处理懒加载，工作量明显大于本轮其它几项，先没做。）
-* 划词优先走 UI Automation `TextPattern.GetSelection()`（无侵入、能拿到选区矩形），
-  只有 UIA 读不到时才回退「发 Ctrl+C 读剪贴板」；终端（console/cascadia/mintty/putty）
-  和桌面/资源管理器窗口直接跳过，避免 Ctrl+C 变成 SIGINT 或真的复制文件。
+* 划词按三级阶梯取选区：UIA `TextPattern`（无侵入、带选区矩形）→ `WM_COPY`（发消息、不发按键）→
+  合成一次 `Ctrl+C`。**Chromium 正文没有 `TextPattern`、也不响应 `WM_COPY`**（我实测过 UIA 与
+  IAccessible2 两条路都拿不到选区），所以浏览器里必然走到第三档，会占用剪贴板；不想被碰可在设置页关掉
+  「选区读取：辅助功能读不到时改用复制」。终端（console/cascadia/mintty/putty）和桌面/资源管理器窗口
+  直接跳过，避免 Ctrl+C 变成 SIGINT 或真的复制文件。**任何情况都不再还原旧剪贴板内容**——那正是以前
+  「选中后 Ctrl+C 复制不上」的根因。
 * 主题色与小窗边框：导航完成后同步两次，另外每 6 秒复查一次页面背景色；
   跨显示器拖到不同 DPI 的屏会收到 `WM_DPICHANGED` 并重算标题条/图标/最小尺寸。
 * 标题条图标是 `Segoe MDL2 Assets` 字体，字号偏小（E8BB 关闭键取 8.5f 才和其它图标一样大）。

package/app/HudWindow.cs

@@ -228,6 +228,7 @@ namespace DshHud
 
             config = HudConfig.Load();
             configStamp = HudConfig.Stamp();
+            SelectionReader.ClipboardFallback = config.TextFallback;
         }
 
         private Size Logical(int w, int h)
@@ -567,7 +568,9 @@ namespace DshHud
                 {
                     configStamp = stamp;
                     config = HudConfig.Load();
-                    Log("config reloaded copyShot=" + config.CopyShot);
+                    SelectionReader.ClipboardFallback = config.TextFallback;
+                    Log("config reloaded copyShot=" + config.CopyShot +
+                        " textFallback=" + (config.TextFallback ? "1" : "0"));
                 }
 
                 string quote = HudConfig.QuotePath;

package/app/SelectionWatcher.cs

@@ -52,15 +52,92 @@ namespace DshHud
 
         internal const uint GA_ROOT = 2;
         internal const int VK_LBUTTON = 0x01;
-        internal const byte VK_CONTROL = 0x11;
+        internal const int VK_SHIFT = 0x10;
+        internal const int VK_CONTROL = 0x11;
+        internal const int VK_MENU = 0x12;
         internal const byte VK_C = 0x43;
         internal const uint KEYEVENTF_KEYUP = 0x0002;
 
+        [StructLayout(LayoutKind.Sequential)]
+        internal struct GUITHREADINFO
+        {
+            public int cbSize;
+            public uint flags;
+            public IntPtr hwndActive;
+            public IntPtr hwndFocus;
+            public IntPtr hwndCapture;
+            public IntPtr hwndMenuOwner;
+            public IntPtr hwndMoveSize;
+            public IntPtr hwndCaret;
+            public RECT rcCaret;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        internal struct RECT
+        {
+            public int left;
+            public int top;
+            public int right;
+            public int bottom;
+        }
+
+        [DllImport("user32.dll")]
+        internal static extern bool GetGUIThreadInfo(uint idThread, ref GUITHREADINFO info);
+
+        [DllImport("user32.dll", CharSet = CharSet.Unicode)]
+        internal static extern IntPtr SendMessageTimeout(IntPtr hWnd, uint msg, IntPtr wParam,
+            IntPtr lParam, uint flags, uint timeout, out IntPtr result);
+
+        internal const uint WM_COPY = 0x0301;
+        internal const uint SMTO_ABORTIFHUNG = 0x0002;
+
         internal static bool IsMouseDown()
         {
             return (GetAsyncKeyState(VK_LBUTTON) & 0x8000) != 0;
         }
 
+        internal static bool IsKeyDown(int vk)
+        {
+            return (GetAsyncKeyState(vk) & 0x8000) != 0;
+        }
+
+        /// <summary>
+        /// True while the user holds Ctrl/Alt/Shift himself. Every probe is skipped then:
+        /// injecting our own Ctrl+C on top of a real one is what made the user's copies
+        /// land empty, and it can also cancel a drag-copy in Explorer.
+        /// </summary>
+        internal static bool IsModifierDown()
+        {
+            return IsKeyDown(VK_CONTROL) || IsKeyDown(VK_MENU) || IsKeyDown(VK_SHIFT);
+        }
+
+        /// <summary>
+        /// The control that currently has the keyboard focus. WM_COPY has to be delivered to
+        /// the edit control, not the top-level window.
+        /// </summary>
+        internal static IntPtr FocusedControl()
+        {
+            try
+            {
+                IntPtr fg = GetForegroundWindow();
+                if (fg == IntPtr.Zero) return IntPtr.Zero;
+                uint pid;
+                uint tid = GetWindowThreadProcessId(fg, out pid);
+                GUITHREADINFO gti = new GUITHREADINFO();
+                gti.cbSize = Marshal.SizeOf(typeof(GUITHREADINFO));
+                if (GetGUIThreadInfo(tid, ref gti))
+                {
+                    if (gti.hwndFocus != IntPtr.Zero) return gti.hwndFocus;
+                    if (gti.hwndActive != IntPtr.Zero) return gti.hwndActive;
+                }
+                return fg;
+            }
+            catch
+            {
+                return IntPtr.Zero;
+            }
+        }
+
         /// <summary>
         /// Terminals map Ctrl+C to an interrupt rather than to "copy", so the clipboard
         /// fallback must never fire over one of them.
@@ -187,6 +264,28 @@ namespace DshHud
             return false;
         }
 
+        /// <summary>
+        /// Ask the focused control to copy through WM_COPY. This is the polite fallback:
+        /// no keystrokes are synthesised, so a real Ctrl+C pressed by the user is never
+        /// raced or cancelled, and nothing is written back over the clipboard.
+        /// </summary>
+        internal static bool SendCopyMessage()
+        {
+            try
+            {
+                IntPtr target = FocusedControl();
+                if (target == IntPtr.Zero) return false;
+                IntPtr result;
+                SendMessageTimeout(target, WM_COPY, IntPtr.Zero, IntPtr.Zero,
+                    SMTO_ABORTIFHUNG, 300, out result);
+                return true;
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
         internal static void SendCopy()
         {
             keybd_event(VK_CONTROL, 0, 0, UIntPtr.Zero);
@@ -218,6 +317,19 @@ namespace DshHud
 
     internal static class SelectionReader
     {
+        /// <summary>
+        /// On by default, but only ever consulted after UIA came back empty — so modern text
+        /// surfaces (Notepad, WinForms, WPF, Office, the browser's own chrome) never touch the
+        /// clipboard. Chromium content and legacy controls expose no TextPattern at all, and for
+        /// those a copy is the only way to read the selection.
+        ///
+        /// Crucially the copy is *not* undone: the old implementation restored the previous
+        /// clipboard contents afterwards, and that restore raced the user's own Ctrl+C and
+        /// overwrote what they had just copied. Losing the previous clipboard contents is the
+        /// price of reading a selection here; breaking Ctrl+C is not.
+        /// </summary>
+        internal static bool ClipboardFallback = true;
+
         /// <summary>
         /// Read the current selection. UIA first: it is passive (no keystrokes, no clipboard
         /// churn) and it also tells us where the selection ends, which is what the pill
@@ -275,7 +387,7 @@ namespace DshHud
             {
             }
 
-            hit.Text = Read();
+            if (ClipboardFallback) hit.Text = Read();
             return hit;
         }
 
@@ -338,16 +450,30 @@ namespace DshHud
 
         private static string ReadOnStaThread()
         {
-            IDataObject backup = null;
-            try
-            {
-                backup = Clipboard.GetDataObject();
-            }
-            catch
+            // No clipboard backup/restore any more. Restoring was the actual damage: while
+            // we waited for our own copy to land, the user's real Ctrl+C could complete
+            // first, and our restore then threw that copy away ("复制不上"). Now the worst
+            // case is that the selection text stays on the clipboard — which is exactly
+            // what the user just asked for anyway.
+            if (ShellWin.IsModifierDown()) return "";
+
+            uint seq = ShellWin.GetClipboardSequenceNumber();
+            // WM_COPY is best effort only: Win32 edits answer it, Chromium and most
+            // modern renderers ignore it, and SendMessageTimeout also returns false
+            // when the target window is busy. Never treat "no answer" as "no selection".
+            ShellWin.SendCopyMessage();
+
+            string text = WaitForClipboardText(seq, 320);
+            if (!string.IsNullOrEmpty(text))
             {
+                SelectionWatcher.Log("copy: wm_copy " + text.Length + " chars");
+                return Finish(text);
             }
 
-            uint seq = ShellWin.GetClipboardSequenceNumber();
+            // A real key chord is the only thing that works for Chromium content and
+            // legacy controls. Only when the user has opted in, and never while they
+            // are holding a modifier themselves.
+            if (!ClipboardFallback || ShellWin.IsModifierDown()) return "";
             try
             {
                 ShellWin.SendCopy();
@@ -356,32 +482,35 @@ namespace DshHud
             {
                 return "";
             }
+            text = WaitForClipboardText(seq, 700);
+            SelectionWatcher.Log("copy: key_chord " + (text == null ? 0 : text.Length) +
+                " chars seq " + seq + "->" + ShellWin.GetClipboardSequenceNumber());
+            return string.IsNullOrEmpty(text) ? "" : Finish(text);
+        }
 
-            string text = null;
+        /// <summary>Wait until the clipboard sequence number moves, then read its text.</summary>
+        private static string WaitForClipboardText(uint seq, int budgetMs)
+        {
             int waited = 0;
-            while (waited < 900)
+            while (waited < budgetMs)
             {
-                Thread.Sleep(30);
-                waited += 30;
+                Thread.Sleep(25);
+                waited += 25;
                 if (ShellWin.GetClipboardSequenceNumber() == seq) continue;
                 try
                 {
-                    if (Clipboard.ContainsText()) text = Clipboard.GetText();
+                    if (Clipboard.ContainsText()) return Clipboard.GetText();
                 }
                 catch
                 {
                 }
-                break;
-            }
-
-            try
-            {
-                if (backup != null) Clipboard.SetDataObject(backup, false);
-            }
-            catch
-            {
+                return "";
             }
+            return "";
+        }
 
+        private static string Finish(string text)
+        {
             if (string.IsNullOrEmpty(text)) return "";
             text = text.Replace("\r\n", "\n").Replace('\r', '\n').Trim();
             if (text.Length == 0) return "";
@@ -748,6 +877,9 @@ namespace DshHud
         private void Kick(Point pt, int delay)
         {
             if (!enabled) { Log("skip: disabled"); return; }
+            // A drag with Ctrl/Shift/Alt held is a copy or an extension, not a fresh
+            // selection: probing it races the user's own shortcut.
+            if (ShellWin.IsModifierDown()) { Log("skip: modifier down"); return; }
 
             if (ShellWin.IsShellSurfaceAt(pt)) { Log("skip: shell surface"); return; }
             int id = ++probeId;

package/app/Service.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Diagnostics;
 using System.Drawing;
 using System.IO;
@@ -19,6 +19,7 @@ namespace DshHud
         internal bool Ask;
         internal string HotkeyFull;
         internal string HotkeyRegion;
+        internal bool TextFallback;
 
         internal HudConfig()
         {
@@ -26,6 +27,7 @@ namespace DshHud
             Ask = true;
             HotkeyFull = "Ctrl+Shift+1";
             HotkeyRegion = "Ctrl+Shift+2";
+            TextFallback = true;
         }
 
         internal static string Dir
@@ -61,6 +63,7 @@ namespace DshHud
                     else if (key == "ask") cfg.Ask = val != "0";
                     else if (key == "hotkeyFull") cfg.HotkeyFull = val;
                     else if (key == "hotkeyRegion") cfg.HotkeyRegion = val;
+                    else if (key == "textFallback") cfg.TextFallback = val != "0";
                 }
             }
             catch
@@ -79,6 +82,7 @@ namespace DshHud
                 sb.AppendLine("ask=" + (Ask ? "1" : "0"));
                 sb.AppendLine("hotkeyFull=" + HotkeyFull);
                 sb.AppendLine("hotkeyRegion=" + HotkeyRegion);
+                sb.AppendLine("textFallback=" + (TextFallback ? "1" : "0"));
                 File.WriteAllText(ConfigPath, sb.ToString(), Encoding.UTF8);
             }
             catch
@@ -250,6 +254,7 @@ namespace DshHud
             watcher = new SelectionWatcher(host);
             watcher.QuoteRequested += DeliverQuote;
             watcher.Enabled = config.Ask;
+            SelectionReader.ClipboardFallback = config.TextFallback;
 
             tray = new NotifyIcon();
             tray.Icon = SystemIcons.Application;
@@ -313,9 +318,11 @@ namespace DshHud
             config = HudConfig.Load();
             watcher.Enabled = config.Ask;
             askItem.Checked = config.Ask;
+            SelectionReader.ClipboardFallback = config.TextFallback;
             host.Bind(config);
             SelectionWatcher.Log("config reloaded: hotkeyFull=" + config.HotkeyFull +
-                                 " hotkeyRegion=" + config.HotkeyRegion);
+                                 " hotkeyRegion=" + config.HotkeyRegion +
+                                 " textFallback=" + (config.TextFallback ? "1" : "0"));
         }
 
         private void OnHotkey(string kind)

package/lib/client.js

@@ -551,6 +551,8 @@ window.__ModuleLoader__.load({
         react.createElement('h3', { style: { fontSize: '14px', margin: '0 0 4px' } }, '小窗与截图'),
         react.createElement('p', { style: hintStyle }, '设置对原生小窗和后台划词服务同时生效，保存后约 3 秒内应用。'),
         checkbox('copyShot', '截图自动复制到剪贴板', '全屏、框选两种截图都会复制'),
+        checkbox('textFallback', '选区读取：辅助功能读不到时改用复制',
+          '默认打开。先走系统辅助功能（不发按键、不碰剪贴板）；浏览器正文、老控件没有这个接口，只能复制一次来读选区 —— 会占用剪贴板，但不会再还原，所以不会覆盖你刚按的 Ctrl+C。关掉后这些地方就不出按钮。'),
         hotkey('hotkeyFull', '全屏截图快捷键'),
         hotkey('hotkeyRegion', '框选截图快捷键'),
         react.createElement('p', { style: hintStyle }, '写法：Ctrl+Shift+1、Ctrl+Shift+S、Alt+PrintScreen、F8 等。组合里必须带 Ctrl/Alt/Shift/Win 之一。'),

package/lib/index.js

@@ -202,7 +202,7 @@ function advertise(ctx) {
 
 const CONFIG_PATH = join(WORK_DIR, 'config.ini')
 
-const CONFIG_DEFAULTS = { copyShot: true, ask: true, hotkeyFull: 'Ctrl+Shift+1', hotkeyRegion: 'Ctrl+Shift+2' }
+const CONFIG_DEFAULTS = { copyShot: true, ask: true, textFallback: true, hotkeyFull: 'Ctrl+Shift+1', hotkeyRegion: 'Ctrl+Shift+2' }
 
 /**
  * Settings live in a flat `key=value` file because the window shell (C# 5) and this
@@ -219,7 +219,7 @@ function readConfig() {
       if (eq <= 0) continue
       const key = line.slice(0, eq).trim()
       const value = line.slice(eq + 1).trim()
-      if (key === 'copyShot' || key === 'ask') config[key] = value !== '0'
+      if (key === 'copyShot' || key === 'ask' || key === 'textFallback') config[key] = value !== '0'
       else if (key === 'hotkeyFull' || key === 'hotkeyRegion') config[key] = value
     }
   } catch {
@@ -235,6 +235,7 @@ function writeConfig(config) {
     `copyShot=${config.copyShot ? '1' : '0'}`,
     `ask=${config.ask ? '1' : '0'}`,
     `hotkeyFull=${config.hotkeyFull}`,
+    `textFallback=${config.textFallback ? '1' : '0'}`,
     `hotkeyRegion=${config.hotkeyRegion}`,
   ]
   writeFileSync(CONFIG_PATH, lines.join('\n') + '\n', 'utf8')
@@ -326,12 +327,13 @@ export function apply(ctx, config = {}) {
     let body
     try { body = await readJson(req) } catch (error) { sendJson(res, 400, { error: error.message }); return }
     const next = readConfig()
-    for (const key of ['copyShot', 'ask', 'hotkeyFull', 'hotkeyRegion']) {
+    for (const key of ['copyShot', 'ask', 'textFallback', 'hotkeyFull', 'hotkeyRegion']) {
       if (Object.prototype.hasOwnProperty.call(body, key)) next[key] = body[key]
     }
     // Normalize before writing: the shell matches these strings exactly when it
     // registers the global hotkeys.
     next.copyShot = Boolean(next.copyShot)
+  next.textFallback = Boolean(next.textFallback)
     next.ask = Boolean(next.ask)
     next.hotkeyFull = String(next.hotkeyFull ?? '').trim() || CONFIG_DEFAULTS.hotkeyFull
     next.hotkeyRegion = String(next.hotkeyRegion ?? '').trim() || CONFIG_DEFAULTS.hotkeyRegion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mini",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "DSH 常驻小窗插件：把当前会话一键弹出为独立置顶小窗（WebView2 原生窗口），含整屏/框选截图、划词「问大肥鱼」、全局快捷键与截图自动复制",
   "type": "module",
   "main": "lib/index.js",