dsh-mini 0.1.3 → 0.1.5

package/README.md

@@ -105,7 +105,20 @@ PNG → base64 → `postMessage` 给页面 → 走 Lexical 粘贴事件塞进输
 数据目录固定是 `%LOCALAPPDATA%\dsh-hud\`（`config.ini`、`window.txt`、日志、WebView2 用户数据），
 改名前后没动过，装到别的机器上也是这个路径、按用户隔离。
 
-## 安装（本机已做）
+## 安装
+
+### A. 从 npm 装（别人用这个）
+
+```bash
+cd ~/.dsh/profiles/desktop
+npm install dsh-mini
+```
+
+然后在同一个 `package.json` 的 `dsh.profile.bundles` 末尾加一项 `"dsh-mini"`，重启 DSH（或 `plugin_manager set_bundle` 关一次再开一次）。
+
+装完不需要额外配置：插件会在 DSH 启动 2.5 秒后自己拉起常驻服务（划词药丸 + 全局热键 + 托盘），小窗由标题栏的「弹出此窗口」按需打开。**前提是机器上已有 WebView2 Runtime**（见上面「系统要求」）。
+
+### B. 本机 link（改代码时用）
 
 profile 走 `link:` 依赖，和 `tju-plugin` 一样：
 
@@ -164,14 +177,17 @@ 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` 剪贴板历史）；用户已切窗就不发。
+* **取选区走系统辅助功能（UIA `TextPattern`），不碰键盘也不碰剪贴板**：拿到文本的同时还能拿到
+  选区最后一行/一个字的矩形，药丸才能精确贴在它右下角。绝大多数现代程序（Notepad、Chrome/Edge、
+  Word、WPS、VS Code、DSH 自己）都支持。
+* 只有用户显式打开设置里的**兼容模式**，UIA 读不到时才补一次读剪贴板：先给焦点控件发 `WM_COPY`
+  （不合成按键），仍不行才真的发一次 `Ctrl+C`。**任何情况下都不再做「备份 → 复制 → 还原」**——
+  之前那套会把你自己的 `Ctrl+C` 覆盖掉，这正是"选中后复制不上"的元凶。
+* 保护：按住 Ctrl/Alt/Shift 时的拖动直接跳过（那是复制/扩选，不是重新选词）；终端
+  （console/cascadia/mintty/putty）不发按键；资源管理器/桌面/任务栏（Progman/WorkerW/CabinetWClass…）
+  一律跳过（否则会真的复制文件、污染 `Win+V` 历史）；用户按着修饰键期间完全不介入。
 * 药丸 9 秒无操作自动消失；托盘菜单「划词问大肥鱼」可随时关掉，状态存在
   `%LOCALAPPDATA%\dsh-hud\ask.txt`。
 * 因此**标题条 ✕ 只是收进托盘**（不是退出）——watcher 活在这个进程里，退出了就没法划词。
@@ -209,6 +225,8 @@ DSH小窗.exe --service --url <tokenized>    # Mutex Local\DshHudService，单
 主窗「设置 → DSH 小窗」：
 
 * 截图自动复制到剪贴板（默认开，整屏/框选都复制）；
+* 兼容模式：读不到选区时模拟 `Ctrl+C`（**默认关**。关着时只用系统辅助功能读选区，
+  完全不碰剪贴板、不发按键；打开后老式控件才读得到，代价是可能和自己按的 `Ctrl+C` 抢剪贴板）；
 * 全屏截图快捷键、框选截图快捷键（失焦即保存）。
 
 配置落在 `%LOCALAPPDATA%\dsh-hud\config.ini`（`key=value`，C# 壳、宿主插件、客户端三边都读），

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,14 @@ namespace DshHud
 
     internal static class SelectionReader
     {
+        /// <summary>
+        /// Off by default. UIA answers for every modern text surface without touching the
+        /// keyboard or the clipboard; the copy-based path is only needed by legacy controls,
+        /// and it necessarily competes with the user's own Ctrl+C. Users can enable it from
+        /// the settings page.
+        /// </summary>
+        internal static bool ClipboardFallback;
+
         /// <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 +382,7 @@ namespace DshHud
             {
             }
 
-            hit.Text = Read();
+            if (ClipboardFallback) hit.Text = Read();
             return hit;
         }
 
@@ -338,16 +445,23 @@ 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();
+            bool asked = ShellWin.SendCopyMessage();
+            if (!asked) return "";
+
+            string text = WaitForClipboardText(seq, 320);
+            if (!string.IsNullOrEmpty(text)) return Finish(text);
+
+            // WM_COPY is ignored by a few legacy controls; only then fall back to a real
+            // key chord, and only when the user has opted in.
+            if (!ClipboardFallback || ShellWin.IsModifierDown()) return "";
             try
             {
                 ShellWin.SendCopy();
@@ -356,32 +470,33 @@ namespace DshHud
             {
                 return "";
             }
+            text = WaitForClipboardText(seq, 700);
+            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 +863,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 = false;
         }
 
         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',
+          '默认关闭。关闭时只走系统辅助功能读选区，完全不碰剪贴板、不发按键；打开后老式控件才读得到，但可能和你自己的 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: false, 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.3",
+  "version": "0.1.5",
   "description": "DSH 常驻小窗插件：把当前会话一键弹出为独立置顶小窗（WebView2 原生窗口），含整屏/框选截图、划词「问大肥鱼」、全局快捷键与截图自动复制",
   "type": "module",
   "main": "lib/index.js",