//go:build windows // ============================================================================ // 系统级鼠标提醒（Windows 原生实现）—— 可靠方案 v2 // // 需求：平时鼠标是正常样式；有消息来（通过 API 触发）时，鼠标旁边浮出 // 半透明气泡提示文字，跟随鼠标移动、闪烁，可覆盖任意窗口（系统级）， // 默认 8 秒自动消退。 // // v1 的失败原因：全局低层鼠标钩子 WH_MOUSE_LL 的回调由系统在非 Go 线程 // 上调用，经 syscall.NewCallback 进入 Go runtime 时会导致进程静默退出； // 且 DIB 自绘 + UpdateLayeredWindow 尺寸不匹配时绘制失效。v2 全部移除： // // 1. 不装任何钩子（去掉唯一危险源），位置跟随改为窗口线程定时器轮询 // GetCursorPos（GetMessage 消息循环所在线程，安全）。 // 2. 用 SetLayeredWindowAttributes(LWA_COLORKEY) 把背景色抠成透明（背景透明， // 只留白色文字），WM_PAINT 用普通 GDI（FillRect + TextOutW）绘制气泡， // 不再用 DIB/UpdateLayeredWindow。 // 3. 窗口过程 WndProc 的 syscall.NewCallback 由 DispatchMessageW 在同线程 // 同步调用，Go runtime 完全支持（安全）。 // 4. 超长文字：TextOutW 单行绘制 + 定时器推进 scrollX 偏移，实现水平循环滚动。 // // 说明：本文件仅在 Windows 编译。其他平台见 mousealert_other.go 空实现。 // ============================================================================ package main import ( "fmt" "os" "runtime" "strings" "sync" "syscall" "time" "unsafe" ) // Windows API 常量 const ( wmTimer = 0x0113 wmDestroy = 0x0002 wmNcDestroy = 0x0082 wmPaint = 0x000F wmRefresh = 0x8001 // 自定义：立即刷新（trigger 唤醒窗口线程） wndExLayered = 0x00080000 // WS_EX_LAYERED 分层窗口（支持透明） wndExTool = 0x00000080 // WS_EX_TOOLWINDOW 不占任务栏 wndExTopMost = 0x00000008 // WS_EX_TOPMOST 置顶 wndExNoActivate = 0x08000000 // WS_EX_NOACTIVATE 不抢焦点 swpNoActivate = 0x0010 // SWP_NOACTIVATE swpShowWindow = 0x0040 // SWP_SHOWWINDOW lwaAlpha = 0x2 // LWA_ALPHA：SetLayeredWindowAttributes 设置整体 alpha lwaColorKey = 0x1 // LWA_COLORKEY：把指定颜色像素抠成透明（背景透明） timerFollow = 1 // 位置跟随 + 闪烁定时器 ID overlayWidth = 200 overlayHeight = 54 alertDuration = 8 * time.Second followIntervalMs = 60 // 跟随/闪烁轮询间隔 60ms ) // hwndTopMost HWND_TOPMOST = (HWND)-1 const hwndTopMost uintptr = ^uintptr(0) // 气泡背景色（深蓝黑）：COLORREF = 0x00BBGGRR（LWA_COLORKEY 抠成透明，只留文字） const bgColorRef = 0x001E1E3C // cfgDurationOrDefault 返回配置的显示时长（秒），非法时用默认 8 秒 func cfgDurationOrDefault(sec int) time.Duration { if sec < 2 || sec > 60 { sec = 8 } return time.Duration(sec) * time.Second } // estimateTextWidth 估算文字像素宽度（微软雅黑：全角/中文≈字号，半角/ASCII≈0.55*字号）。 // 用于在触发时预判文字是否超长，从而智能延长显示时长。 func estimateTextWidth(text string, fontSize int32) int32 { if text == "" || fontSize <= 0 { return 0 } var w float32 for _, r := range text { if r < 0x2E80 { // 半角 / ASCII / 拉丁 w += 0.55 * float32(fontSize) } else { // 全角 / 中日韩 w += float32(fontSize) } } return int32(w) } // hexColorToRef 把 #RRGGBB 或 #RGB 颜色字符串转 COLORREF（0x00BBGGRR）。 // 解析失败时回退 fallback。 func hexColorToRef(s string, fallback uintptr) uintptr { s = strings.TrimSpace(s) if len(s) == 7 && s[0] == '#' { var r, g, b uint32 if _, err := fmt.Sscanf(s, "#%02x%02x%02x", &r, &g, &b); err == nil { return uintptr(r | g<<8 | b<<16) } } if len(s) == 4 && s[0] == '#' { var r, g, b uint32 if _, err := fmt.Sscanf(s, "#%1x%1x%1x", &r, &g, &b); err == nil { return uintptr(r*17 | g*17<<8 | b*17<<16) } } return fallback } // ------------------------------------------------------------------------ // Windows 结构体与函数指针声明（用 syscall 直接调用，避免引入额外依赖） // ------------------------------------------------------------------------ type point struct { X int32 Y int32 } // rect Windows RECT 结构（GetWindowRect / FillRect 输出） type rect struct { Left int32 Top int32 Right int32 Bottom int32 } type msg struct { HWND uintptr Message uint32 WParam uintptr LParam uintptr Time uint32 Pt point LPrivate uint32 } type wndclassex struct { CbSize uint32 Style uint32 LpfnWndProc uintptr CbClsExtra int32 CbWndExtra int32 HInstance uintptr HIcon uintptr HCursor uintptr HbrBackground uintptr LpszMenuName *uint16 LpszClassName *uint16 HIconSm uintptr } // paintstruct PAINTSTRUCT（BeginPaint / EndPaint 输出） type paintstruct struct { Hdc uintptr FErase int32 RcPaint rect FRestore int32 FIncUpdate int32 RGBReserved [32]byte } // size SIZE 结构（GetTextExtentPoint32W 输出：文字像素尺寸） type size struct { Cx int32 Cy int32 } // 延迟加载的 user32.dll / gdi32.dll / kernel32.dll 函数 var ( user32 = syscall.NewLazyDLL("user32.dll") gdi32 = syscall.NewLazyDLL("gdi32.dll") kernel32 = syscall.NewLazyDLL("kernel32.dll") procGetMessage = user32.NewProc("GetMessageW") procTranslateMessage = user32.NewProc("TranslateMessage") procDispatchMessage = user32.NewProc("DispatchMessageW") procRegisterClassEx = user32.NewProc("RegisterClassExW") procCreateWindowEx = user32.NewProc("CreateWindowExW") procDefWindowProc = user32.NewProc("DefWindowProcW") procDestroyWindow = user32.NewProc("DestroyWindow") procSetTimer = user32.NewProc("SetTimer") procKillTimer = user32.NewProc("KillTimer") procShowWindow = user32.NewProc("ShowWindow") procSetWindowPos = user32.NewProc("SetWindowPos") procGetCursorPos = user32.NewProc("GetCursorPos") procPostMessage = user32.NewProc("PostMessageW") procSetLayeredWindowAttr = user32.NewProc("SetLayeredWindowAttributes") procBeginPaint = user32.NewProc("BeginPaint") procEndPaint = user32.NewProc("EndPaint") procInvalidateRect = user32.NewProc("InvalidateRect") procFillRect = user32.NewProc("FillRect") // 注意：FillRect 在 user32.dll，不在 gdi32.dll procDrawTextW = user32.NewProc("DrawTextW") procCreateSolidBrush = gdi32.NewProc("CreateSolidBrush") procDeleteObject = gdi32.NewProc("DeleteObject") procSetBkMode = gdi32.NewProc("SetBkMode") procSetTextColor = gdi32.NewProc("SetTextColor") procGetStockObject = gdi32.NewProc("GetStockObject") procSelectObject = gdi32.NewProc("SelectObject") procCreateFontW = gdi32.NewProc("CreateFontW") procTextOutW = gdi32.NewProc("TextOutW") // 单行文字输出（超长滚动用） procGetTextExtentPoint32W = gdi32.NewProc("GetTextExtentPoint32W") // 测量文字宽度（判断是否超长） procCreateCompatibleDC = gdi32.NewProc("CreateCompatibleDC") // 双缓冲：创建内存 DC procCreateCompatibleBitmap = gdi32.NewProc("CreateCompatibleBitmap") // 双缓冲：创建兼容位图 procBitBlt = gdi32.NewProc("BitBlt") // 双缓冲：整块拷贝上屏 procDeleteDC = gdi32.NewProc("DeleteDC") // 双缓冲：删除内存 DC procGetModuleHandleW = kernel32.NewProc("GetModuleHandleW") ) // ------------------------------------------------------------------------ // 鼠标提醒运行时状态 // ------------------------------------------------------------------------ // mouseAlertState 鼠标提醒的运行时状态（单实例） type mouseAlertState struct { mu sync.Mutex started bool // 工作线程是否已启动（持久化，仅启动一次） overlayWnd uintptr active bool text string flashOn bool lastX, lastY int32 stopTime time.Time wndProc uintptr classOK bool bgBrush uintptr scrollX int32 // 超长文字水平滚动偏移（px），定时器推进 textWidth int32 // 当前文字像素宽度（>可用宽度时滚动） textGap int32 // 头尾相联间隔（两个空格宽度 px），滚动周期 = 文字宽 + 间隔 // 运行时配置（triggerMouseAlert 时从设置加载） cfgWidth int32 // 气泡窗口宽度（px） cfgHeight int32 // 气泡窗口高度（px，按字号自适应） cfgFontSize int32 // 字号（px） cfgSpeed int // 超长文字滚动速度（px/s） cfgDuration time.Duration // 显示时长 cfgTextColor uintptr // 文字颜色（COLORREF） cfgBgColor uintptr // 气泡背景色（COLORKEY 抠透明） cfgOutlineColor uintptr // 文字描边颜色（COLORREF），形成反差 cfgOutlineWidth int32 // 文字描边宽度（px），0 关闭 } var mouseAlert = &mouseAlertState{} // triggerMouseAlert 触发鼠标提醒：鼠标旁浮出半透明气泡提示，跟随鼠标闪烁。 // 文字为空时用默认提示。重复触发会刷新提醒计时并立即显示。 // // 定位策略：窗口线程的定时器主动用 GetCursorPos 读取当前鼠标位置并跟随， // 不依赖任何全局钩子回调（钩子回调在系统线程执行，曾导致进程退出）。 func triggerMouseAlert(text string) { if text == "" { text = "有新消息提醒" } // 从设置加载鼠标提醒配置（字号/宽度/速度/颜色/时长） cfg := loadSettings().MouseAlert var pt point curRet, _, _ := procGetCursorPos.Call(uintptr(unsafe.Pointer(&pt))) hasCursor := curRet != 0 // 智能延长显示时长：文字超长（需滚动）时，追加滚动一圈所需时间，保证能看完 cfgWidth := int32(cfg.Width) if cfgWidth <= 0 { cfgWidth = overlayWidth } cfgFontSize := int32(cfg.FontSize) if cfgFontSize <= 0 { cfgFontSize = DefaultMouseAlertFontSize } estW := estimateTextWidth(text, cfgFontSize) baseDur := cfgDurationOrDefault(cfg.Duration) totalDur := baseDur if estW > cfgWidth-24 && cfg.Speed > 0 { // 超出可用宽度的部分需滚动，所需时间 = 超出像素 / 速度 extra := estW - (cfgWidth - 24) need := time.Duration(float64(extra) / float64(cfg.Speed) * float64(time.Second)) totalDur = baseDur + need } mouseAlert.mu.Lock() mouseAlert.text = text mouseAlert.active = true mouseAlert.flashOn = true mouseAlert.stopTime = time.Now().Add(totalDur) mouseAlert.scrollX = 0 // 新消息从头开始滚动 mouseAlert.textWidth = 0 // 强制重新测量 // 缓存本次提醒的显示配置 mouseAlert.cfgWidth = cfgWidth mouseAlert.cfgFontSize = cfgFontSize mouseAlert.cfgSpeed = cfg.Speed mouseAlert.cfgDuration = totalDur mouseAlert.cfgTextColor = hexColorToRef(cfg.Color, 0x00FFFFFF) // 默认白字 mouseAlert.cfgBgColor = bgColorRef mouseAlert.cfgOutlineColor = hexColorToRef(cfg.OutlineColor, 0x00000000) // 默认黑边 mouseAlert.cfgOutlineWidth = int32(cfg.OutlineWidth) // 头尾相联间隔 = 两个空格宽度（约 0.3*字号 每个），提前缓存供滚动周期使用 mouseAlert.textGap = int32(float32(cfgFontSize) * 0.3 * 2) if mouseAlert.textGap < 4 { mouseAlert.textGap = 4 } // 气泡高度按字号自适应：字号 + 上下留白 + 内边距 mouseAlert.cfgHeight = mouseAlert.cfgFontSize + 34 if hasCursor { mouseAlert.lastX, mouseAlert.lastY = pt.X, pt.Y } started := mouseAlert.started mouseAlert.started = true overlay := mouseAlert.overlayWnd mouseAlert.mu.Unlock() // 首次触发：启动常驻工作线程（幂等），建窗后由线程主动定位并重绘 if !started { go mouseAlertLoop() return } // 已启动：唤醒窗口线程立即刷新（窗口线程负责 SetWindowPos/绘制） if overlay != 0 { procPostMessage.Call(overlay, wmRefresh, 0, 0) } } // stopMouseAlert 立即停止鼠标提醒（隐藏气泡；线程保持常驻） func stopMouseAlert() { mouseAlert.mu.Lock() mouseAlert.active = false overlay := mouseAlert.overlayWnd mouseAlert.mu.Unlock() if overlay != 0 { procShowWindow.Call(overlay, 0) // SW_HIDE } } // mouseAlertLoop 常驻工作线程：注册窗口类、创建半透明置顶气泡窗口、 // 启动跟随/闪烁定时器，进入消息循环。 func mouseAlertLoop() { // 关键：Go 的 goroutine 会在 OS 线程间迁移。窗口消息循环（CreateWindowEx + // GetMessage + DispatchMessage）必须固定在同一个 OS 线程上，否则 WM_TIMER / // WM_PAINT 等消息投递到创建窗口的线程，而 GetMessage 在另一线程永远收不到， // 导致窗口出现后卡死（不跟随鼠标、不重绘、无文字）。LockOSThread 锁定本 // goroutine 到当前 OS 线程，保证消息循环与窗口同线程。 runtime.LockOSThread() hInst, _, _ := procGetModuleHandleW.Call(0) mouseAlert.mu.Lock() className, _ := syscall.UTF16PtrFromString("TengTuMouseAlertBubble") wc := wndclassex{ CbSize: uint32(unsafe.Sizeof(wndclassex{})), LpfnWndProc: mouseAlert.wndProcAddr(), HInstance: hInst, LpszClassName: className, HCursor: 0, } atom, _, _ := procRegisterClassEx.Call(uintptr(unsafe.Pointer(&wc))) if atom != 0 { mouseAlert.classOK = true } else { fmt.Fprintf(os.Stderr, "[mousealert] RegisterClassEx failed (classOK=%v)\n", mouseAlert.classOK) } mouseAlert.mu.Unlock() // 创建半透明置顶气泡窗口（不抢焦点、不占任务栏） // dwStyle 必须含 WS_POPUP(0x80000000)：无边框无标题的弹出窗口， // 否则 CreateWindowEx 可能失败或窗口不可见。 style := uintptr(wndExLayered | wndExTool | wndExTopMost | wndExNoActivate) mouseAlert.mu.Lock() w, h := mouseAlert.cfgWidth, mouseAlert.cfgHeight if w <= 0 { w = overlayWidth // 首次触发配置尚未缓存时用默认 } if h <= 0 { h = overlayHeight } mouseAlert.mu.Unlock() overlay, _, _ := procCreateWindowEx.Call( style, uintptr(unsafe.Pointer(className)), 0, uintptr(0x80000000) /* WS_POPUP */, 0, 0, uintptr(w), uintptr(h), 0, 0, 0, hInst, 0, ) if overlay == 0 { fmt.Fprintf(os.Stderr, "[mousealert] CreateWindowEx failed\n") } mouseAlert.mu.Lock() mouseAlert.overlayWnd = overlay if overlay != 0 { // 背景透明（LWA_COLORKEY）：把背景色 bgColorRef 的像素抠成透明，只留白色 // 文字。WM_PAINT 用普通 GDI 绘制气泡（背景+文字）。 // 注意：不要用 UpdateLayeredWindow——它会接管分层窗口内容，导致 // WM_PAINT 完全失效（这正是当前「完全不显示」的根因）。 bg := mouseAlert.cfgBgColor if bg == 0 { bg = bgColorRef } brush, _, _ := procCreateSolidBrush.Call(bg) mouseAlert.bgBrush = brush // LWA_COLORKEY：crKey=背景色，bAlpha=0（忽略），dwFlags=LWA_COLORKEY procSetLayeredWindowAttr.Call(overlay, bg, 0, uintptr(lwaColorKey)) } mouseAlert.mu.Unlock() // 启动跟随/闪烁定时器（窗口线程内轮询鼠标位置） if overlay != 0 { procSetTimer.Call(overlay, timerFollow, followIntervalMs, 0) // 建窗后立即用当前鼠标位置定位并重绘一次，保证首次触发即可见 var pt point curRet, _, _ := procGetCursorPos.Call(uintptr(unsafe.Pointer(&pt))) if curRet != 0 { mouseAlert.mu.Lock() if mouseAlert.active { mouseAlert.lastX, mouseAlert.lastY = pt.X, pt.Y mouseAlert.mu.Unlock() mouseAlert.positionAndDraw(overlay, pt.X, pt.Y) } else { mouseAlert.mu.Unlock() } } } // 消息循环（常驻，直到线程退出） var m msg for { ret, _, _ := procGetMessage.Call(uintptr(unsafe.Pointer(&m)), 0, 0, 0) if ret == 0 { break // WM_QUIT } procTranslateMessage.Call(uintptr(unsafe.Pointer(&m))) procDispatchMessage.Call(uintptr(unsafe.Pointer(&m))) } // 清理 if overlay != 0 { procKillTimer.Call(overlay, timerFollow) procDestroyWindow.Call(overlay) } mouseAlert.mu.Lock() if mouseAlert.bgBrush != 0 { procDeleteObject.Call(mouseAlert.bgBrush) mouseAlert.bgBrush = 0 } mouseAlert.overlayWnd = 0 mouseAlert.mu.Unlock() } // wndProcAddr 返回覆盖层窗口过程地址（保持 Go 函数引用，防 GC） func (s *mouseAlertState) wndProcAddr() uintptr { if s.wndProc != 0 { return s.wndProc } s.wndProc = syscall.NewCallback(s.wndProcCallback) return s.wndProc } // wndProcCallback 气泡窗口过程：处理跟随/闪烁定时器、自定义刷新、绘制与销毁。 // 此回调由 DispatchMessageW 在消息循环线程同步调用，是 Go runtime 支持的安全路径。 func (s *mouseAlertState) wndProcCallback(hwnd uintptr, msg uint32, wParam uintptr, lParam uintptr) uintptr { switch msg { case wmRefresh, wmTimer: if msg == wmRefresh || uintptr(wParam) == timerFollow { // 主动用 GetCursorPos 读取当前鼠标位置（窗口线程，安全） var pt point curRet, _, _ := procGetCursorPos.Call(uintptr(unsafe.Pointer(&pt))) s.mu.Lock() if !s.active { s.mu.Unlock() procShowWindow.Call(hwnd, 0) // SW_HIDE return 0 } if curRet != 0 { s.lastX, s.lastY = pt.X, pt.Y } // 到期判断 if !s.stopTime.IsZero() && time.Now().After(s.stopTime) { s.active = false s.mu.Unlock() procShowWindow.Call(hwnd, 0) // SW_HIDE return 0 } s.flashOn = !s.flashOn // 超长文字滚动：文字宽度超过可用区时，按配置速度推进偏移，循环滚动 w := s.cfgWidth if w <= 0 { w = overlayWidth } if s.textWidth > w-24 { step := int32(s.cfgSpeed * 60 / 1000) // 每 60ms 帧推进（px） if step < 1 { step = 1 } s.scrollX += step // 头尾相联无缝循环：滚动一个完整周期（文字宽 + 间隔）后归零， // 下一份正好接上，形成连续跑马灯。 cycle := s.textWidth + s.textGap if cycle <= 0 { cycle = s.textWidth + 40 } if s.scrollX > cycle { s.scrollX = 0 } } else { s.scrollX = 0 } x, y := s.lastX, s.lastY s.mu.Unlock() s.positionAndDraw(hwnd, x, y) return 0 } return 0 case wmPaint: // WM_PAINT 用普通 GDI 绘制气泡（背景 + 文字）。分层窗口已设 LWA_COLORKEY // 抠透明，此处只画内容，不调用 UpdateLayeredWindow（会接管窗口）。 // 双缓冲：先在内存 DC（兼容位图）上合成背景+文字，再一次性 BitBlt 上屏， // 避免多遍描边 + 正文逐笔直接画到屏幕导致滚动时闪烁。 var ps paintstruct hdc, _, _ := procBeginPaint.Call(hwnd, uintptr(unsafe.Pointer(&ps))) if hdc != 0 { s.mu.Lock() fw, fh := s.cfgWidth, s.cfgHeight s.mu.Unlock() if fw <= 0 { fw = overlayWidth } if fh <= 0 { fh = overlayHeight } // 创建内存 DC + 兼容位图作为双缓冲画布 memDC, _, _ := procCreateCompatibleDC.Call(hdc) memBmp, _, _ := procCreateCompatibleBitmap.Call(hdc, uintptr(fw), uintptr(fh)) oldBmp, _, _ := procSelectObject.Call(memDC, memBmp) if memDC != 0 && memBmp != 0 { // 背景：填满整个客户区（LWA_COLORKEY 把该色抠成透明，只留文字） var full rect full.Left = 0 full.Top = 0 full.Right = fw full.Bottom = fh if s.bgBrush != 0 { procFillRect.Call(memDC, uintptr(unsafe.Pointer(&full)), s.bgBrush) } // 文字：在内存 DC 上绘制（TRANSPARENT 背景模式，不覆盖气泡背景） s.paintText(memDC) // 一次性把合成结果拷贝上屏，避免逐笔绘制的闪烁 procBitBlt.Call(hdc, 0, 0, uintptr(fw), uintptr(fh), memDC, 0, 0, 0x00CC0020 /* SRCCOPY */) } // 清理双缓冲对象 if memDC != 0 { procSelectObject.Call(memDC, oldBmp) if memBmp != 0 { procDeleteObject.Call(memBmp) } procDeleteDC.Call(memDC) } procEndPaint.Call(hwnd, uintptr(unsafe.Pointer(&ps))) } return 0 case wmDestroy, wmNcDestroy: procKillTimer.Call(hwnd, timerFollow) return 0 } ret, _, _ := procDefWindowProc.Call(hwnd, uintptr(msg), wParam, lParam) return ret } // positionAndDraw 把气泡窗口定位到鼠标旁，设置整体 alpha，并触发 WM_PAINT 重绘。 // 窗口线程内调用。绘制本身由 WM_PAINT（普通 GDI）完成。 // 不闪烁：固定 alpha=235（此前 60ms 翻转 235↔150 导致闪烁严重，已去掉）。 func (s *mouseAlertState) positionAndDraw(overlay uintptr, x, y int32) { if overlay == 0 { return } s.mu.Lock() w, h := s.cfgWidth, s.cfgHeight if w <= 0 { w = overlayWidth } if h <= 0 { h = overlayHeight } s.mu.Unlock() // 气泡左上角位于鼠标右下偏移，避免遮挡光标 left := x + 20 top := y + 24 // 背景透明（LWA_COLORKEY）只在创建窗口时设置一次，避免每帧重复设置导致闪烁。 // 定位 + 显示（不激活） procSetWindowPos.Call(overlay, hwndTopMost, uintptr(int32(left)), uintptr(int32(top)), uintptr(w), uintptr(h), swpNoActivate|swpShowWindow) // 触发重绘（WM_PAINT 绘制背景 + 文字） procInvalidateRect.Call(overlay, 0, 0) } // paintText 在指定 HDC 上绘制白色提示文字（WM_PAINT 内调用，窗口线程）。 // 用 DrawTextW + 系统字体 + TRANSPARENT 背景模式：只画字形、不填充背景， // 这样不会覆盖 FillRect 画的气泡背景（此前 OPAQUE 模式导致文字区被填成黑色 // 背景而不可见）。 func (s *mouseAlertState) paintText(hdc uintptr) { s.mu.Lock() text := s.text scrollX := s.scrollX fontSize := s.cfgFontSize textColor := s.cfgTextColor outlineColor := s.cfgOutlineColor outlineWidth := s.cfgOutlineWidth width := s.cfgWidth s.mu.Unlock() if text == "" || hdc == 0 { return } if fontSize <= 0 { fontSize = DefaultMouseAlertFontSize // 默认 20px } if textColor == 0 { textColor = 0x00FFFFFF // 默认白字 } if outlineColor == 0 { outlineColor = 0x00000000 // 默认黑边 } if width <= 0 { width = overlayWidth } // TRANSPARENT：只画字形，不填背景（保留气泡背景） procSetBkMode.Call(hdc, 1) procSetTextColor.Call(hdc, textColor) // 大字体：CreateFontW 按配置字号创建清晰字体 // 参数：h=-fontSize(px), w=0, esc=0, orient=0, weight=FW_NORMAL(400), italic=0, // underline=0, strikeout=0, charset=DEFAULT_CHARSET(1), outprec=0, clipprec=0, // quality=ANTIALIASED(4), pitch=0, face=微软雅黑 facePtr, _ := syscall.UTF16PtrFromString("Microsoft YaHei") var fontH int32 = -fontSize // 负值=像素高度（字号 px），用变量避免常量溢出 hFont, _, _ := procCreateFontW.Call( uintptr(fontH), 0, 0, 0, 400, 0, 0, 0, 1 /* DEFAULT_CHARSET */, 0, 0, 4 /* ANTIALIASED */, 0, uintptr(unsafe.Pointer(facePtr)), ) if hFont == 0 { // 回退系统字体 hFont, _, _ = procGetStockObject.Call(17) // DEFAULT_GUI_FONT } if hFont != 0 { procSelectObject.Call(hdc, hFont) } // 测量文字像素宽度（选中字体下），判断是否需要滚动 textPtr, _ := syscall.UTF16PtrFromString(text) var ext size procGetTextExtentPoint32W.Call(hdc, uintptr(unsafe.Pointer(textPtr)), uintptr(len([]rune(text))), uintptr(unsafe.Pointer(&ext))) textW := ext.Cx availW := width - 24 // 左右各 12px 边距 s.mu.Lock() s.textWidth = textW s.mu.Unlock() // 文字垂直居中：气泡高度 = 字号 + 34，上下留白各约 (34-字号)/2 + 基线偏移 baseY := (fontSize + 10) / 2 // 字形基线 y 坐标（垂直居中） // 单行绘制（TextOutW）+ 超长时按 scrollX 偏移。文字从左边距开始画， // 滚动时整体向左平移（x - scrollX），实现文字从右向左循环滚动。 // 文字超长时先画两遍（偏移 和 偏移+周期）实现头尾相联无缝循环。 // // 描边反差：为避免文字在任意背景（亮/暗）上看不清，先用描边色把文字 // 向 8 个方向各偏移 outlineWidth 各画一遍形成外描边（stroke），最后用 // 正文色在中心画一遍（fill），构成带色边的文字，形成颜色反差。 textLen := uintptr(len([]rune(text))) leftX := int32(12) - scrollX if textW > availW { // 头尾相联：第二份从「文字头 + 文字宽 + 间隔」开始画，间隔为两个空格 s.mu.Lock() gap := s.textGap s.mu.Unlock() if gap < 4 { gap = 4 } // 第一遍：当前偏移处（文字头） s.drawOutlinedText(hdc, textPtr, textLen, leftX, baseY, outlineColor, outlineWidth, textColor) // 第二遍：文字头 + 文字宽 + 间隔，实现头尾相联无缝循环 s.drawOutlinedText(hdc, textPtr, textLen, leftX+textW+gap, baseY, outlineColor, outlineWidth, textColor) } else { // 未超长：左对齐单行 s.drawOutlinedText(hdc, textPtr, textLen, 12, baseY, outlineColor, outlineWidth, textColor) } } // drawOutlinedText 绘制带描边的文字：先用 outlineColor 在 8 方向各偏移 // outlineWidth 描一圈形成外轮廓，再在中心用 textColor 画正文字形。 // outlineWidth<=0 时不描边，直接画正文（等同旧行为）。 func (s *mouseAlertState) drawOutlinedText(hdc uintptr, textPtr *uint16, textLen uintptr, x, y int32, outlineColor uintptr, outlineWidth int32, textColor uintptr) { if textLen == 0 { return } draw := func(dx, dy int32, color uintptr) { procSetTextColor.Call(hdc, color) procTextOutW.Call(hdc, uintptr(x+dx), uintptr(y+dy), uintptr(unsafe.Pointer(textPtr)), textLen) } if outlineWidth > 0 { // 8 方向外描边（每像素偏移），形成环绕轮廓，避免不同背景下文字难辨认 for dy := -outlineWidth; dy <= outlineWidth; dy++ { for dx := -outlineWidth; dx <= outlineWidth; dx++ { if dx == 0 && dy == 0 { continue } draw(dx, dy, outlineColor) } } } // 中心正文字形 draw(0, 0, textColor) } // renderBubbleToDib 已移除：回退到 WM_PAINT 普通 GDI 绘制方案（见 wmPaint/paintText）。 // 分层窗口用 LWA_ALPHA 整体半透明，不再用 DIB + UpdateLayeredWindow。