//go:build windows // ============================================================================ // ledwindow_windows.go — LED 点阵滚动文字（Windows 原生实现） // // 需求：输入文字（含中文），转换为 LED 点阵并在独立的无边框、透明、置顶、 // 可拖动窗口中横向循环滚动显示。 // // 为何不用 Wails WebView2：WebView2 的默认背景不透明问题无法通过 // PutDefaultBackgroundColor(0,0,0,0) 根治——组合宿主（DComp）下视觉无 // SetAlphaMode，HWND 宿主下 WebView2 默认背景在未聚焦/聚焦时仍是白/蓝色。 // 因此本窗口完全用 Win32 API 原生实现，不经过 Wails： // // 1. 分层窗口 WS_EX_LAYERED + 32 位 DIB section + UpdateLayeredWindow(ULW_ALPHA)， // 逐像素 alpha 实现真正透明：背景 alpha=0（全透明），点阵 alpha=255（不透明）。 // （SetLayeredWindowAttributes(LWA_COLORKEY) 在本环境调用虽成功但实际失效， // 故改用 UpdateLayeredWindow 像素级透明。） // 2. 点阵直接写入 DIB 内存（BGRA），每帧用 UpdateLayeredWindow 提交到屏幕。 // 3. 拖动：WM_LBUTTONDOWN → SendMessage(WM_NCLBUTTONDOWN, HTCAPTION)，整窗可拖动。 // 4. 置顶：WS_EX_TOPMOST；不占任务栏：WS_EX_TOOLWINDOW；不抢焦点：ShowWindow(SW_SHOWNOACTIVATE)。 // 5. 文字点阵：数字/字母/符号用内置 5x7 字模放大 2 倍（10x14）， // 汉字用 GDI 字体渲染到内存位图后按网格采样为 24x32 点阵（按 RGB 亮度采样， // 因 GDI TextOutW 不写 32 位 DIB 的 alpha 通道）。 // 6. 横向循环滚动：窗口线程定时器按速度推进 offset，循环回绕。 // // 说明：本文件仅在 Windows 编译。其他平台见 ledwindow_other.go 空实现。 // 共享的 Win32 常量/proc/结构体（wmTimer、wndExLayered、procGetMessage、 // wndclassex 等）复用 mousealert_windows.go 的定义，避免重复声明冲突。 // ============================================================================ package main import ( "fmt" "runtime" "strings" "sync" "syscall" "time" "unsafe" ) // ------------------------------------------------------------------------ // Windows API 常量（LED 专属；共享常量见 mousealert_windows.go） // ------------------------------------------------------------------------ const ( wmNcHitTest = 0x0084 wmClose = 0x0010 wmNcLButtonDown = 0x00A1 wmLButtonDown = 0x0201 wmLButtonUp = 0x0202 wmMouseMove = 0x0200 wmMouseLeave = 0x02A3 wmMouseWheel = 0x020A timerScroll = 1 // 滚动定时器 ID // 窗口尺寸（逻辑像素） ledWinWidth = 720 ledWinHeight = 260 // 点距/边距：窗口随缩放动态变化（见 ledResizeWindow）。 // ledBaseDot 基础点距（汉字 32 行 × 6px ≈ 192px，加边距约 260 高）。 ledBaseDot = 6 ledPadV = 40 // 垂直边距（容纳边框+按钮，上下各 40） ledPadH = 20 // 水平边距（容纳边框，左右各 20） // 点阵参数 ledCharGap = 2 // 字符内点距（点） ledGap = 3 // 字符间距（点） // 颜色键背景（纯黑）：COLORREF = 0x00BBGGRR ledBgColor = 0x00000000 // UpdateLayeredWindow 参数 ulwAlpha = 0x2 // ULW_ALPHA：使用 per-pixel alpha acSrcAlpha = 0x1 // AC_SRC_ALPHA：像素包含 alpha 通道（BGRA） // 悬停交互 UI 尺寸 ledBorderW = 2 // 悬停边框宽度（px） ledBtnSize = 26 // 按钮直径（px） ledBtnMargin = 6 // 按钮距边框内边距（px） ledBtnCloseTop = ledBorderW + 4 // 关闭按钮上缘 ledBtnZoomTop = ledBorderW + 4 // 缩放按钮上缘 // 滚轮缩放档位 ledZoomMin = 0.6 ledZoomMax = 2.0 ledZoomStep = 0.1 ) // htCaption HTCAPTION：WM_NCHITTEST 返回后整窗可拖动 const htCaption = 2 // ------------------------------------------------------------------------ // Windows 结构体（LED 专属；point/rect/msg/wndclassex/paintstruct 复用共享） // ------------------------------------------------------------------------ // ledBitmapInfoHeader BITMAPINFOHEADER（用于 CreateDIBSection 采样汉字点阵） type ledBitmapInfoHeader struct { BiSize uint32 BiWidth int32 BiHeight int32 // 负值=自顶向下 BiPlanes uint16 BiBitCount uint16 BiCompression uint32 BiSizeImage uint32 BiXPelsPerMeter int32 BiYPelsPerMeter int32 BiClrUsed uint32 BiClrImportant uint32 } type ledBitmapInfo struct { BmiHeader ledBitmapInfoHeader BmiColors [3]uint32 } // blendfunction BLENDFUNCTION（UpdateLayeredWindow 用） type blendfunction struct { BlendOp byte BlendFlags byte SourceConstantAlpha byte AlphaFormat byte } // trackMouseEvent TRACKMOUSEEVENT（TrackMouseEvent 用，检测鼠标离开） type trackMouseEvent struct { CbSize uint32 DwFlags uint32 HwndTrack uintptr DwHoverTime uint32 } const ( tmeLeave = 0x00000002 // TME_LEAVE ) // ------------------------------------------------------------------------ // LED 专属 Win32 函数（其余共享 proc 在 mousealert_windows.go 定义，复用） // ------------------------------------------------------------------------ var ( ledGetSystemMetrics = user32.NewProc("GetSystemMetrics") ledPostQuitMessage = user32.NewProc("PostQuitMessage") procUpdateLayeredWindow = user32.NewProc("UpdateLayeredWindow") ledGetDC = user32.NewProc("GetDC") ledReleaseDC = user32.NewProc("ReleaseDC") ledSetBkColor = gdi32.NewProc("SetBkColor") ledCreateDIBSection = gdi32.NewProc("CreateDIBSection") procGetPixel = gdi32.NewProc("GetPixel") procPatBlt = gdi32.NewProc("PatBlt") ledSendMessageW = user32.NewProc("SendMessageW") procTrackMouseEvent = user32.NewProc("TrackMouseEvent") procGetWindowRect = user32.NewProc("GetWindowRect") ) // ------------------------------------------------------------------------ // 5x7 点阵字模（每字符 7 行，每行 5 位，高位在左） // 与前端 led.js 的 FONT_5x7 完全一致。 // ------------------------------------------------------------------------ var ledFont5x7 = map[rune][7]string{ '0': {"01110", "10001", "10011", "10101", "11001", "10001", "01110"}, '1': {"00100", "01100", "00100", "00100", "00100", "00100", "01110"}, '2': {"01110", "10001", "00001", "00010", "00100", "01000", "11111"}, '3': {"11110", "00001", "00001", "01110", "00001", "00001", "11110"}, '4': {"00010", "00110", "01010", "10010", "11111", "00010", "00010"}, '5': {"11111", "10000", "11110", "00001", "00001", "10001", "01110"}, '6': {"00110", "01000", "10000", "11110", "10001", "10001", "01110"}, '7': {"11111", "00001", "00010", "00100", "01000", "01000", "01000"}, '8': {"01110", "10001", "10001", "01110", "10001", "10001", "01110"}, '9': {"01110", "10001", "10001", "01111", "00001", "00010", "01100"}, 'A': {"01110", "10001", "10001", "11111", "10001", "10001", "10001"}, 'B': {"11110", "10001", "10001", "11110", "10001", "10001", "11110"}, 'C': {"01110", "10001", "10000", "10000", "10000", "10001", "01110"}, 'D': {"11100", "10010", "10001", "10001", "10001", "10010", "11100"}, 'E': {"11111", "10000", "10000", "11110", "10000", "10000", "11111"}, 'F': {"11111", "10000", "10000", "11110", "10000", "10000", "10000"}, 'G': {"01110", "10001", "10000", "10111", "10001", "10001", "01111"}, 'H': {"10001", "10001", "10001", "11111", "10001", "10001", "10001"}, 'I': {"01110", "00100", "00100", "00100", "00100", "00100", "01110"}, 'J': {"00111", "00010", "00010", "00010", "00010", "10010", "01100"}, 'K': {"10001", "10010", "10100", "11000", "10100", "10010", "10001"}, 'L': {"10000", "10000", "10000", "10000", "10000", "10000", "11111"}, 'M': {"10001", "11011", "10101", "10101", "10001", "10001", "10001"}, 'N': {"10001", "11001", "10101", "10011", "10001", "10001", "10001"}, 'O': {"01110", "10001", "10001", "10001", "10001", "10001", "01110"}, 'P': {"11110", "10001", "10001", "11110", "10000", "10000", "10000"}, 'Q': {"01110", "10001", "10001", "10001", "10101", "10010", "01101"}, 'R': {"11110", "10001", "10001", "11110", "10100", "10010", "10001"}, 'S': {"01111", "10000", "10000", "01110", "00001", "00001", "11110"}, 'T': {"11111", "00100", "00100", "00100", "00100", "00100", "00100"}, 'U': {"10001", "10001", "10001", "10001", "10001", "10001", "01110"}, 'V': {"10001", "10001", "10001", "10001", "10001", "01010", "00100"}, 'W': {"10001", "10001", "10001", "10101", "10101", "10101", "01010"}, 'X': {"10001", "10001", "01010", "00100", "01010", "10001", "10001"}, 'Y': {"10001", "10001", "01010", "00100", "00100", "00100", "00100"}, 'Z': {"11111", "00001", "00010", "00100", "01000", "10000", "11111"}, 'a': {"00000", "00000", "01110", "00001", "01111", "10001", "01111"}, 'b': {"10000", "10000", "11110", "10001", "10001", "10001", "11110"}, 'c': {"00000", "00000", "01110", "10001", "10000", "10001", "01110"}, 'd': {"00001", "00001", "01111", "10001", "10001", "10001", "01111"}, 'e': {"00000", "00000", "01110", "10001", "11111", "10000", "01110"}, 'f': {"00110", "01001", "01000", "11100", "01000", "01000", "01000"}, 'g': {"00000", "01111", "10001", "10001", "01111", "00001", "01110"}, 'h': {"10000", "10000", "11110", "10001", "10001", "10001", "10001"}, 'i': {"00100", "00000", "01100", "00100", "00100", "00100", "01110"}, 'j': {"00010", "00000", "00110", "00010", "00010", "10010", "01100"}, 'k': {"10000", "10000", "10010", "10100", "11000", "10100", "10010"}, 'l': {"01100", "00100", "00100", "00100", "00100", "00100", "01110"}, 'm': {"00000", "00000", "11010", "10101", "10101", "10101", "10101"}, 'n': {"00000", "00000", "11110", "10001", "10001", "10001", "10001"}, 'o': {"00000", "00000", "01110", "10001", "10001", "10001", "01110"}, 'p': {"00000", "00000", "11110", "10001", "11110", "10000", "10000"}, 'q': {"00000", "00000", "01111", "10001", "01111", "00001", "00001"}, 'r': {"00000", "00000", "10110", "11001", "10000", "10000", "10000"}, 's': {"00000", "00000", "01111", "10000", "01110", "00001", "11110"}, 't': {"01000", "01000", "11100", "01000", "01000", "01001", "00110"}, 'u': {"00000", "00000", "10001", "10001", "10001", "10011", "01101"}, 'v': {"00000", "00000", "10001", "10001", "10001", "01010", "00100"}, 'w': {"00000", "00000", "10001", "10001", "10101", "10101", "01010"}, 'x': {"00000", "00000", "10001", "01010", "00100", "01010", "10001"}, 'y': {"00000", "00000", "10001", "10001", "01111", "00001", "01110"}, 'z': {"00000", "00000", "11111", "00010", "00100", "01000", "11111"}, ' ': {"00000", "00000", "00000", "00000", "00000", "00000", "00000"}, '.': {"00000", "00000", "00000", "00000", "00000", "00110", "00110"}, ',': {"00000", "00000", "00000", "00000", "00000", "00110", "00100"}, ':': {"00000", "00110", "00110", "00000", "00110", "00110", "00000"}, ';': {"00000", "00110", "00110", "00000", "00110", "00100", "01000"}, '-': {"00000", "00000", "00000", "11111", "00000", "00000", "00000"}, '_': {"00000", "00000", "00000", "00000", "00000", "00000", "11111"}, '+': {"00000", "00100", "00100", "11111", "00100", "00100", "00000"}, '=': {"00000", "00000", "11111", "00000", "11111", "00000", "00000"}, '/': {"00001", "00010", "00010", "00100", "01000", "01000", "10000"}, '\\': {"10000", "01000", "01000", "00100", "00010", "00010", "00001"}, '!': {"00100", "00100", "00100", "00100", "00100", "00000", "00100"}, '?': {"01110", "10001", "00001", "00010", "00100", "00000", "00100"}, '@': {"01110", "10001", "10111", "10101", "10111", "10000", "01110"}, '#': {"01010", "01010", "11111", "01010", "11111", "01010", "01010"}, '$': {"00100", "01111", "10100", "01110", "00101", "11110", "00100"}, '%': {"11001", "11010", "00010", "00100", "01000", "01011", "10011"}, '&': {"01100", "10010", "10100", "01000", "10101", "10010", "01101"}, '*': {"00000", "00100", "10101", "01110", "10101", "00100", "00000"}, '(': {"00010", "00100", "01000", "01000", "01000", "00100", "00010"}, ')': {"01000", "00100", "00010", "00010", "00010", "00100", "01000"}, '[': {"01110", "01000", "01000", "01000", "01000", "01000", "01110"}, ']': {"01110", "00010", "00010", "00010", "00010", "00010", "01110"}, '{': {"00010", "00100", "00100", "01000", "00100", "00100", "00010"}, '}': {"01000", "00100", "00100", "00010", "00100", "00100", "01000"}, '<': {"00010", "00100", "01000", "10000", "01000", "00100", "00010"}, '>': {"01000", "00100", "00010", "00001", "00010", "00100", "01000"}, '|': {"00100", "00100", "00100", "00100", "00100", "00100", "00100"}, '~': {"00000", "01000", "10101", "00010", "00000", "00000", "00000"}, '^': {"00100", "01010", "10001", "00000", "00000", "00000", "00000"}, '。': {"00000", "00000", "00000", "00000", "00110", "00110", "00000"}, '，': {"00000", "00000", "00000", "00000", "00110", "00100", "01000"}, '、': {"00100", "00100", "00100", "00100", "00100", "00000", "00000"}, '：': {"00000", "00110", "00110", "00000", "00110", "00110", "00000"}, '；': {"00000", "00110", "00110", "00000", "00110", "00100", "01000"}, '？': {"01110", "10001", "00001", "00010", "00100", "00000", "00100"}, '！': {"00100", "00100", "00100", "00100", "00100", "00000", "00100"}, '（': {"00010", "00100", "01000", "01000", "01000", "00100", "00010"}, '）': {"01000", "00100", "00010", "00010", "00010", "00100", "01000"}, '《': {"00010", "00100", "01000", "10000", "01000", "00100", "00010"}, '》': {"01000", "00100", "00010", "00001", "00010", "00100", "01000"}, } // ------------------------------------------------------------------------ // 点阵数据模型 // ------------------------------------------------------------------------ // ledGlyph 单个字符的点阵（on[row][col]=true 表示点亮） type ledGlyph struct { w, h int on [][]bool } // ledChar 字符 + 其点阵 type ledChar struct { ch rune glyph ledGlyph } // scaleGlyph5x7 把 5x7 字模放大 scale 倍（每点变 scale×scale 块） func scaleGlyph5x7(rows [7]string, scale int) ledGlyph { w := 5 * scale h := 7 * scale on := make([][]bool, h) for y := 0; y < h; y++ { on[y] = make([]bool, w) for x := 0; x < w; x++ { on[y][x] = rows[y/scale][x/scale] == '1' } } return ledGlyph{w: w, h: h, on: on} } // charToGlyph 把单个字符渲染为点阵：优先内置 5x7 字模（放大 2 倍=10x14）， // 汉字/其他用 GDI 渲染到内存位图后按 24x32 网格采样。 // hdc 用于汉字采样（窗口线程持有）。 func charToGlyph(hdc uintptr, ch rune) ledGlyph { upper := ch if ch >= 'a' && ch <= 'z' { upper = ch - ('a' - 'A') } if rows, ok := ledFont5x7[ch]; ok { return scaleGlyph5x7(rows, 2) } if rows, ok := ledFont5x7[upper]; ok { return scaleGlyph5x7(rows, 2) } // 汉字/其他：GDI 渲染 24x32，按网格采样 return renderHanziGlyph(hdc, ch) } // renderHanziGlyph 用 GDI 把汉字画到 24x32 内存位图，按 alpha 通道采样为点阵。 // 用 CreateDIBSection 得到像素缓冲，TextOutW 绘制后读 alpha 位。 func renderHanziGlyph(hdc uintptr, ch rune) ledGlyph { const gw, gh = 24, 32 // 32 位自顶向下 DIB bmi := ledBitmapInfo{} bmi.BmiHeader.BiSize = uint32(unsafe.Sizeof(ledBitmapInfoHeader{})) bmi.BmiHeader.BiWidth = gw bmi.BmiHeader.BiHeight = -gh bmi.BmiHeader.BiPlanes = 1 bmi.BmiHeader.BiBitCount = 32 bmi.BmiHeader.BiCompression = 0 // BI_RGB var bits unsafe.Pointer hbmp, _, _ := ledCreateDIBSection.Call( 0, uintptr(unsafe.Pointer(&bmi)), 0, // DIB_RGB_COLORS uintptr(unsafe.Pointer(&bits)), 0, 0, ) if hbmp == 0 || bits == nil { return emptyGlyph(gw, gh) } defer procDeleteObject.Call(hbmp) // 内存 DC + 选入位图 memDC, _, _ := procCreateCompatibleDC.Call(hdc) if memDC == 0 { return emptyGlyph(gw, gh) } defer procDeleteDC.Call(memDC) oldBmp, _, _ := procSelectObject.Call(memDC, hbmp) // 白色前景，黑色背景（黑=透明，白=点亮） procSetBkMode.Call(memDC, 1) // TRANSPARENT ledSetBkColor.Call(memDC, 0x00000000) procSetTextColor.Call(memDC, 0x00FFFFFF) // 清黑：PatBlt BLACKNESS(0x00000042)，确保底为纯黑（GDI 读亮度判定） procPatBlt.Call(memDC, 0, 0, uintptr(gw), uintptr(gh), 0x00000042) // 创建字体：高约 gh*0.9 像素，微软雅黑 facePtr, _ := syscall.UTF16PtrFromString("Microsoft YaHei") fontH := int32(gh) * 9 / 10 // gh*0.9，用整数避免常量折叠 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 { procSelectObject.Call(memDC, hFont) } else { hFont, _, _ = procGetStockObject.Call(17) // DEFAULT_GUI_FONT } // 绘制字符（居中）：TextOutW 用当前字体，位置在网格中心 chStr := string(ch) chPtr, _ := syscall.UTF16PtrFromString(chStr) procTextOutW.Call(memDC, 2, 3, uintptr(unsafe.Pointer(chPtr)), uintptr(len(chStr))) // 采样 RGB 亮度（GDI TextOutW 不写 32 位 DIB 的 alpha 通道，故按亮度判定点亮）。 // 白字黑底：字=0xFFFFFF（亮），底=0x000000（暗）。 px := uintptr(bits) on := make([][]bool, gh) for y := 0; y < gh; y++ { on[y] = make([]bool, gw) row := px + uintptr(y*gw*4) for x := 0; x < gw; x++ { b := *(*byte)(unsafe.Pointer(row + uintptr(x*4) + 0)) g := *(*byte)(unsafe.Pointer(row + uintptr(x*4) + 1)) r := *(*byte)(unsafe.Pointer(row + uintptr(x*4) + 2)) // 亮度 > 100（0-255 单通道）视为笔画点亮 on[y][x] = (int(r)+int(g)+int(b))/3 > 100 } } // 恢复并清理 if memDC != 0 { procSelectObject.Call(memDC, oldBmp) } if hFont != 0 && hFont != uintptr(17) { procDeleteObject.Call(hFont) } return ledGlyph{w: gw, h: gh, on: on} } // emptyGlyph 返回全灭的 w×h 点阵（采样失败时的占位） func emptyGlyph(w, h int) ledGlyph { on := make([][]bool, h) for y := range on { on[y] = make([]bool, w) } return ledGlyph{w: w, h: h, on: on} } // textToLedSequence 把整串文字拆成字符点阵序列 func textToLedSequence(hdc uintptr, text string) []ledChar { seq := make([]ledChar, 0, len([]rune(text))) for _, ch := range text { seq = append(seq, ledChar{ch: ch, glyph: charToGlyph(hdc, ch)}) } return seq } // ledSequenceMaxH 返回序列中最大的点阵高（行数） func ledSequenceMaxH(seq []ledChar) int { maxH := 0 for _, c := range seq { if c.glyph.h > maxH { maxH = c.glyph.h } } return maxH } // ledTotalPxWidth 计算整行文字的像素宽（含字符间与末尾间隙） func ledTotalPxWidth(seq []ledChar, dot int) int { cell := dot + ledCharGap w := 0 for _, c := range seq { w += c.glyph.w*cell + ledGap*dot } return w } // ledParseColor 把 #RRGGBB / #RGB 转 COLORREF（0x00BBGGRR），失败回退红。 func ledParseColor(s string) 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 0x00004D4D // 默认红 #ff4d4d } // ------------------------------------------------------------------------ // LED 窗口运行时状态（单实例） // ------------------------------------------------------------------------ // ledWindowState LED 窗口的运行时状态（单实例，互斥保护） type ledWindowState struct { mu sync.Mutex started bool // 窗口线程是否已启动（幂等，仅启动一次） hwnd uintptr // 窗口句柄 active bool // 窗口是否已创建并显示 closed bool // 是否已请求关闭（窗口线程退出） text string // 要显示的文字 color uintptr // LED 点阵颜色（COLORREF） speed int // 滚动速度（px/s） seq []ledChar // 点阵序列（文字解析结果） maxH int // 序列最大高（行数） offset int // 当前水平偏移（px，向左滚为负累加） period int // 循环周期（px） prevTs int64 // 上次绘制时间戳（ms，用于 dt 计算） // 交互状态 hover bool // 鼠标是否悬停在窗口上（显示边框+按钮） zoom float64 // 缩放倍率（滚轮调整，影响点距） dragging bool // 是否正在拖动窗口 closeHot bool // 鼠标是否悬停关闭按钮 zoomHot bool // 鼠标是否悬停缩放按钮 lastMouse point // 最近鼠标位置（窗口客户区坐标） closeRect rect // 关闭按钮区域（客户区坐标） zoomRect rect // 缩放按钮区域（客户区坐标） tracking bool // 是否已注册 TrackMouseEvent wndProc uintptr // 窗口过程回调地址（防 GC） // UpdateLayeredWindow 像素级透明所需的 DIB 资源（窗口线程创建/持有） memDC uintptr // 内存 DC（DIB 被选中） dibBmp uintptr // 32 位 DIB section 的 HBITMAP dibPtr unsafe.Pointer // DIB 像素内存指针（BGRA 每像素 4 字节） dibW int // DIB 宽 dibH int // DIB 高 classSeq int // 窗口类名序号（保证类名唯一，避免重复注册同名类） } var ledWinState = &ledWindowState{} // OpenLEDWindow 打开（或更新）LED 点阵滚动窗口并显示指定文字。 // text 为空时不更新内容（保留上次文字），但窗口未开则忽略。 // color 非空时保存为点阵颜色并持久化到设置。 // speed > 0 时更新滚动速度（px/s）。 // 返回是否成功打开（供前端提示）。 func (s *SettingsService) OpenLEDWindow(text string, color string, speed int) bool { if color != "" { ledSaveColor(color) } if speed > 0 { ledWinState.mu.Lock() ledWinState.speed = speed ledWinState.mu.Unlock() } if text == "" { // 空文字：窗口已开则保留，否则不创建 ledWinState.mu.Lock() open := ledWinState.active ledWinState.mu.Unlock() return open } // 更新文字与颜色 ledWinState.mu.Lock() ledWinState.text = text if color != "" { ledWinState.color = ledParseColor(color) } else if ledWinState.color == 0 { ledWinState.color = ledParseColor(ledLoadColor()) } if ledWinState.speed <= 0 { ledWinState.speed = 60 } ledWinState.seq = nil // 强制重新解析（窗口线程重建序列） started := ledWinState.started ledWinState.started = true open := ledWinState.active ledWinState.mu.Unlock() if !started { // 首次：启动窗口线程（建窗、消息循环） go ledWindowLoop() return true } // 已启动：唤醒窗口线程立即刷新 if open { ledPostRefresh() } return true } // CloseLEDWindow 关闭 LED 滚动窗口（窗口已关则忽略）。 func (s *SettingsService) CloseLEDWindow() { ledWinState.mu.Lock() hwnd := ledWinState.hwnd ledWinState.closed = true ledWinState.mu.Unlock() if hwnd != 0 { procPostMessage.Call(hwnd, wmClose, 0, 0) } } // SetLEDTransparent 保留空实现：原生分层窗口透明由 SetLayeredWindowAttributes // 在建窗时设置，无需前端补设。兼容前端 bindings 调用（不再报错）。 func (s *SettingsService) SetLEDTransparent() { // 原生窗口透明已由 LWA_COLORKEY 在建窗时实现，此处无操作。 } // GetLEDText 返回当前要显示的 LED 文字。 func (s *SettingsService) GetLEDText() string { ledWinState.mu.Lock() defer ledWinState.mu.Unlock() return ledWinState.text } // GetLEDColor 返回当前 LED 点阵颜色字符串（默认 #ff4d4d）。 func (s *SettingsService) GetLEDColor() string { ledWinState.mu.Lock() c := ledWinState.color ledWinState.mu.Unlock() if c == 0 { c = ledParseColor(ledLoadColor()) } return ledFormatColor(c) } // GetLEDSpeed 返回当前 LED 滚动速度（px/s），<=0 用默认 60。 func (s *SettingsService) GetLEDSpeed() int { ledWinState.mu.Lock() defer ledWinState.mu.Unlock() if ledWinState.speed <= 0 { ledWinState.speed = 60 } return ledWinState.speed } // ledSaveColor 持久化 LED 颜色到设置（颜色非空时）。 func ledSaveColor(color string) { if color == "" { return } settings := loadSettings() settings.LEDColor = color _ = saveSettings(settings) } // ledLoadColor 从设置读取已保存的 LED 颜色。 func ledLoadColor() string { c := loadSettings().LEDColor if c == "" { c = "#ff4d4d" } return c } // ledFormatColor 把 COLORREF 转回 #RRGGBB 字符串。 func ledFormatColor(c uintptr) string { r := (c >> 0) & 0xFF g := (c >> 8) & 0xFF b := (c >> 16) & 0xFF return fmt.Sprintf("#%02x%02x%02x", r, g, b) } // ledPostRefresh 向窗口线程投递自定义刷新消息（窗口已建时）。 func ledPostRefresh() { ledWinState.mu.Lock() hwnd := ledWinState.hwnd ledWinState.mu.Unlock() if hwnd != 0 { procPostMessage.Call(hwnd, wmRefresh, 0, 0) } } // ------------------------------------------------------------------------ // 窗口创建 / 消息循环 // ------------------------------------------------------------------------ // ledWindowLoop 窗口线程：注册窗口类、建窗、显示、跑消息循环。 // 所有窗口操作必须在同一线程（GUI 线程），Win32 要求。 func ledWindowLoop() { runtime.LockOSThread() defer runtime.UnlockOSThread() hinst, _, _ := procGetModuleHandleW.Call(0) // 注册窗口类：类名唯一（序号递增），避免重复注册同名类失败 ledWinState.mu.Lock() ledWinState.classSeq++ clsName := fmt.Sprintf("LedScrollClass_%d", ledWinState.classSeq) ledWinState.mu.Unlock() className, _ := syscall.UTF16PtrFromString(clsName) wc := wndclassex{} wc.CbSize = uint32(unsafe.Sizeof(wndclassex{})) wc.Style = 0 wc.LpfnWndProc = ledWinState.wndProcAddr() wc.HInstance = hinst wc.HCursor = 0 wc.HbrBackground = 0 // 无背景（WM_ERASEBKGND 自己填充黑，避免闪烁） wc.LpszClassName = className atom, _, _ := procRegisterClassEx.Call(uintptr(unsafe.Pointer(&wc))) if atom == 0 { ledWinState.mu.Lock() ledWinState.started = false ledWinState.mu.Unlock() return } // 创建窗口：分层 + 置顶 + 工具窗 // 注意：不加 WS_EX_NOACTIVATE——某些 Win11 版本下 NOACTIVATE 与 LAYERED 组合 // 会导致窗口不渲染（不可见）。避免激活改用 ShowWindow(SW_SHOWNOACTIVATE)。 exStyle := uintptr(wndExLayered | wndExTool | wndExTopMost) style := uintptr(0x80000000) // WS_POPUP（无边框、无标题、无最小化） hwnd, _, _ := procCreateWindowEx.Call( exStyle, uintptr(unsafe.Pointer(className)), 0, // 无标题 style, 0, 0, // 位置：初始 0,0，随后居中 ledWinWidth, ledWinHeight, 0, 0, hinst, 0, ) if hwnd == 0 { ledWinState.mu.Lock() ledWinState.started = false ledWinState.mu.Unlock() return } ledWinState.mu.Lock() ledWinState.hwnd = hwnd ledWinState.active = true ledWinState.closed = false ledWinState.mu.Unlock() // 像素级透明：创建 32 位 DIB section，用 UpdateLayeredWindow 逐像素提交。 // 背景像素 alpha=0（全透明），点阵像素 alpha=255（不透明）。 // 注意：不再用 SetLayeredWindowAttributes(LWA_COLORKEY) —— 本环境调用虽返回 // 成功但实际不生效（窗口显示为不透明白色矩形，自检已证实）。 if !ledEnsureDIB(ledWinWidth, ledWinHeight) { procSetLayeredWindowAttr.Call(hwnd, 0, 200, lwaAlpha) // 兜底 } // 居中显示（不激活，避免抢焦点） ledCenterWindow(hwnd, ledWinWidth, ledWinHeight) procShowWindow.Call(hwnd, 4) // SW_SHOWNOACTIVATE // 置顶 + 不激活 procSetWindowPos.Call(hwnd, hwndTopMost, 0, 0, 0, 0, swpNoActivate|swpShowWindow|0x0001 /* SWP_NOMOVE */|0x0002 /* SWP_NOSIZE */) // 滚动定时器（约 16ms） procSetTimer.Call(hwnd, timerScroll, 16, 0) // 初始化按钮命中区域（否则 closeRect/zoomRect 全 0，按钮点击失效） ledInitButtonRects() // 首次建窗后立即解析点阵序列（否则 seq=nil → 只画透明背景） ledWinState.mu.Lock() if ledWinState.zoom <= 0 { ledWinState.zoom = 1.0 // 缩放倍率默认 1.0（新建窗口重置） } ledWinState.hover = false ledWinState.closeHot = false ledWinState.zoomHot = false ledWinState.tracking = false ledWinState.mu.Unlock() ledRebuildSequence() // 建窗后按实际内容调整窗口尺寸（否则固定 720×260，长文字或缩放后可能裁剪） ledResizeWindow(hwnd) ledRenderFrame(hwnd) // 首帧提交 // 消息循环 var msg msg for { ret, _, _ := procGetMessage.Call(uintptr(unsafe.Pointer(&msg)), 0, 0, 0) if int32(ret) == 0 || int32(ret) == -1 { break } procTranslateMessage.Call(uintptr(unsafe.Pointer(&msg))) procDispatchMessage.Call(uintptr(unsafe.Pointer(&msg))) } // 退出清理 procKillTimer.Call(hwnd, timerScroll) ledReleaseDIB() // 释放 DIB section / memDC ledWinState.mu.Lock() ledWinState.hwnd = 0 ledWinState.active = false ledWinState.started = false ledWinState.seq = nil ledWinState.offset = 0 ledWinState.mu.Unlock() } // wndProcAddr 返回 LED 窗口过程地址（保持 Go 函数引用，防 GC）。 // 必须在窗口线程内、RegisterClassEx 之前惰性初始化——与 mousealert_windows.go // 的 wndProcAddr() 一致。不能在全局 init() 里 NewCallback（绑定时机错误，会导致 // RegisterClassEx 拒绝注册）。 func (st *ledWindowState) wndProcAddr() uintptr { if st.wndProc != 0 { return st.wndProc } st.wndProc = syscall.NewCallback(ledWndProc) return st.wndProc } // ledCenterWindow 把窗口移到屏幕水平居中、垂直约 1/4 处。 func ledCenterWindow(hwnd uintptr, w, h int) { sw, _, _ := ledGetSystemMetrics.Call(0) // SM_CXSCREEN sh, _, _ := ledGetSystemMetrics.Call(1) // SM_CYSCREEN x := (int32(sw) - int32(w)) / 2 y := (int32(sh) - int32(h)) / 4 // SWP_NOSIZE(0x0001)|SWP_NOZORDER(0x0004)|SWP_NOACTIVATE(0x0010)：只移动，不改大小/层级/激活 // 必须含 SWP_NOSIZE，否则 cx=cy=0 会把窗口尺寸设成 0×0（客户区为 0，画面空白） procSetWindowPos.Call(hwnd, 0, uintptr(x), uintptr(y), 0, 0, 0x0001|0x0004|0x0010) } // ledInitButtonRects 初始化关闭/缩放按钮的命中区域（客户区坐标）。 // 使用当前窗口实际尺寸（ledResizeWindow 缩放后调用，按钮随窗口动态移动）。 func ledInitButtonRects() { ledWinState.mu.Lock() w := ledWinState.dibW if w <= 0 { w = ledWinWidth } ledWinState.mu.Unlock() closeCx := w - ledBorderW - ledBtnMargin - ledBtnSize/2 closeCy := ledBtnCloseTop + ledBtnSize/2 zoomCx := ledBorderW + ledBtnMargin + ledBtnSize/2 zoomCy := ledBtnZoomTop + ledBtnSize/2 r := ledBtnSize / 2 ledWinState.mu.Lock() ledWinState.closeRect = rect{ Left: int32(closeCx - r), Top: int32(closeCy - r), Right: int32(closeCx + r), Bottom: int32(closeCy + r), } ledWinState.zoomRect = rect{ Left: int32(zoomCx - r), Top: int32(zoomCy - r), Right: int32(zoomCx + r), Bottom: int32(zoomCy + r), } ledWinState.mu.Unlock() } // ledTrackLeave 注册 TrackMouseEvent，鼠标离开窗口时收到 WM_MOUSELEAVE。 func ledTrackLeave(hwnd uintptr) { ledWinState.mu.Lock() if ledWinState.tracking { ledWinState.mu.Unlock() return } ledWinState.tracking = true ledWinState.mu.Unlock() tme := trackMouseEvent{ CbSize: uint32(unsafe.Sizeof(trackMouseEvent{})), DwFlags: tmeLeave, HwndTrack: hwnd, DwHoverTime: 0, } procTrackMouseEvent.Call(uintptr(unsafe.Pointer(&tme))) } // ------------------------------------------------------------------------ // 窗口过程 // ------------------------------------------------------------------------ // ledWndProc 窗口过程。wParam/lParam 按消息解释。 // 返回 0 表示已处理，非 0 由 DefWindowProc 语义。 func ledWndProc(hwnd uintptr, msg uint32, wParam uintptr, lParam uintptr) uintptr { switch msg { case wmPaint: // 分层窗口用 UpdateLayeredWindow 提交，无需 WM_PAINT GDI 绘制； // 但窗口仍可能收到 WM_PAINT（如系统要求重绘），直接渲染一帧即可。 ledRenderFrame(hwnd) return 0 case wmTimer: if uintptr(wParam) == timerScroll { ledAdvanceScroll() ledRenderFrame(hwnd) // 每帧直接提交到屏幕 } return 0 case wmRefresh: // 文字已更新：重新解析点阵 + 重置偏移 + 窗口尺寸随内容调整 + 渲染一帧 ledRebuildSequence() ledResizeWindow(hwnd) ledRenderFrame(hwnd) return 0 case wmNcHitTest: // 返回 HTCLIENT（默认），不用 HTCAPTION —— 对 WS_EX_LAYERED+WS_EX_NOACTIVATE // 窗口，HTCAPTION 会让系统进入"标题栏移动"状态，阻断 WM_PAINT 派发（画面空白）。 // 拖动改由 WM_LBUTTONDOWN 触发 SendMessage(WM_NCLBUTTONDOWN, HTCAPTION)。 r2, _, _ := procDefWindowProc.Call(hwnd, uintptr(msg), wParam, lParam) return r2 case wmLButtonDown: // 判断是否点中关闭/缩放按钮；否则整窗拖动（标题栏移动） x := int16(uint16(lParam & 0xFFFF)) y := int16(uint16((lParam >> 16) & 0xFFFF)) ledWinState.mu.Lock() closeRect := ledWinState.closeRect zoomRect := ledWinState.zoomRect ledWinState.mu.Unlock() cx := int32(x) cy := int32(y) inClose := cx >= closeRect.Left && cx <= closeRect.Right && cy >= closeRect.Top && cy <= closeRect.Bottom inZoom := cx >= zoomRect.Left && cx <= zoomRect.Right && cy >= zoomRect.Top && cy <= zoomRect.Bottom if inClose { // 关闭按钮：销毁窗口 ledWinState.mu.Lock() ledWinState.hover = false ledWinState.closeHot = false ledWinState.zoomHot = false ledWinState.mu.Unlock() procDestroyWindow.Call(hwnd) return 0 } if inZoom { // 缩放按钮：切换缩放（1.0 → 1.5 → 0.6 → 1.0），并重建周期 ledWinState.mu.Lock() switch ledWinState.zoom { case 1.0: ledWinState.zoom = 1.5 case 1.5: ledWinState.zoom = 0.6 default: ledWinState.zoom = 1.0 } ledWinState.mu.Unlock() ledRebuildSequence() ledResizeWindow(hwnd) ledRenderFrame(hwnd) return 0 } // 普通区域：整窗拖动（标题栏移动，不抢焦点） ledSendMessageW.Call(hwnd, wmNcLButtonDown, htCaption, lParam) return 0 case wmLButtonUp: return 0 case wmMouseMove: // 记录鼠标位置，注册离开检测，更新按钮悬停，重绘（悬停边框） x := int16(uint16(lParam & 0xFFFF)) y := int16(uint16((lParam >> 16) & 0xFFFF)) ledWinState.mu.Lock() ledWinState.lastMouse = point{X: int32(x), Y: int32(y)} wasHover := ledWinState.hover ledWinState.hover = true closeRect := ledWinState.closeRect zoomRect := ledWinState.zoomRect ledWinState.mu.Unlock() if !wasHover { // 首次悬停：注册 TrackMouseEvent（离开时收 WM_MOUSELEAVE） ledTrackLeave(hwnd) } // 更新按钮悬停状态 cx := int32(x) cy := int32(y) inClose := cx >= closeRect.Left && cx <= closeRect.Right && cy >= closeRect.Top && cy <= closeRect.Bottom inZoom := cx >= zoomRect.Left && cx <= zoomRect.Right && cy >= zoomRect.Top && cy <= zoomRect.Bottom changed := false ledWinState.mu.Lock() if ledWinState.closeHot != inClose { ledWinState.closeHot = inClose changed = true } if ledWinState.zoomHot != inZoom { ledWinState.zoomHot = inZoom changed = true } ledWinState.mu.Unlock() // 首次悬停或按钮悬停变化时重绘（显示/更新边框与按钮） if changed || !wasHover { ledRenderFrame(hwnd) } return 0 case wmMouseLeave: // 鼠标离开：隐藏边框与按钮 ledWinState.mu.Lock() ledWinState.hover = false ledWinState.closeHot = false ledWinState.zoomHot = false ledWinState.tracking = false ledWinState.mu.Unlock() ledRenderFrame(hwnd) return 0 case wmMouseWheel: // 滚轮缩放：调整点距倍率 delta := int16(uint16(wParam >> 16)) // HIWORD = 滚轮增量 ledWinState.mu.Lock() z := ledWinState.zoom if z <= 0 { z = 1 } if delta > 0 { z += ledZoomStep } else { z -= ledZoomStep } if z < ledZoomMin { z = ledZoomMin } if z > ledZoomMax { z = ledZoomMax } ledWinState.zoom = z ledWinState.mu.Unlock() // 缩放改变点距 → 重建周期（平铺宽度变化） ledRebuildSequence() // 窗口尺寸随点距/内容动态变化，保证放大后点阵不被裁剪 ledResizeWindow(hwnd) ledRenderFrame(hwnd) return 0 case wmClose: procDestroyWindow.Call(hwnd) return 0 case wmDestroy: ledPostQuitMessage.Call(0) return 0 } r, _, _ := procDefWindowProc.Call(hwnd, uintptr(msg), wParam, lParam) return r } // ledRebuildSequence 重建点阵序列（窗口线程内调用）。 func ledRebuildSequence() { ledWinState.mu.Lock() text := ledWinState.text color := ledWinState.color if color == 0 { color = ledParseColor(ledLoadColor()) } hwnd := ledWinState.hwnd ledWinState.mu.Unlock() // 用窗口 DC 采样汉字 hdc, _, _ := ledGetDC.Call(hwnd) // 文字末尾追加两个空格：无限滚动循环时形成断句分隔， // 避免前一句末字与后一句首字粘连、观看者无法断句。 text = text + " " seq := textToLedSequence(hdc, text) if hdc != 0 { ledReleaseDC.Call(hwnd, hdc) } maxH := ledSequenceMaxH(seq) // 无缝无限滚动：把序列平铺两份（seq + seq），offset 在 [-单份宽, 0) 内回绕， // 这样任何时候窗口内都有连续文字，循环处无缝衔接。 tiled := make([]ledChar, 0, len(seq)*2) tiled = append(tiled, seq...) tiled = append(tiled, seq...) // 单份序列的总像素宽（平铺周期） tileW := ledTotalPxWidth(seq, ledWinState.dot()) ledWinState.mu.Lock() ledWinState.seq = tiled ledWinState.maxH = maxH // 循环周期 = 单份序列宽（无限平铺回绕）；周期需 > 0 才回绕 if tileW > 0 { ledWinState.period = tileW } else { ledWinState.period = ledWinWidth } ledWinState.offset = 0 ledWinState.prevTs = 0 ledWinState.mu.Unlock() } // dot 计算当前点距（点阵单元像素大小）。 // 基础点距固定为 ledBaseDot，再乘以滚轮缩放倍率。 // 窗口高度不再参与计算——尺寸随 dot 动态变化（见 ledResizeWindow）， // 避免"高度变化→点距变化→窗口再变化"的耦合振荡。 func (st *ledWindowState) dot() int { d := ledBaseDot z := st.zoom if z <= 0 { z = 1 } return int(float64(d) * z) } // ledTargetSize 根据当前点距、点阵高与单份序列宽计算目标窗口尺寸。 // 高度容纳点阵 + 上下边距（边框+按钮）；宽度容纳一个完整循环周期。 func ledTargetSize(dot, maxH, tileW int) (int, int) { if maxH <= 0 { maxH = 32 } lineH := maxH * dot h := lineH + 2*ledPadV // 至少容纳悬停按钮与边框 minH := ledBtnCloseTop + ledBtnSize + ledBtnMargin + ledBorderW if h < minH { h = minH } w := tileW + 2*ledPadH // 上限：不超屏幕宽的 9/10（点阵再长也受限，避免窗口占满屏幕） if sw, _, _ := ledGetSystemMetrics.Call(0); int32(sw) > 0 { maxW := int(int32(sw)) * 9 / 10 if w > maxW { w = maxW } } // 下限：保持基础宽，避免纯字母小字串窗口过窄 if w < ledWinWidth { w = ledWinWidth } return w, h } // ledResizeWindow 按当前内容（点距/点阵高/序列宽）调整窗口尺寸并重建 DIB。 // 必须在窗口线程内调用（缩放、文字更新后）。 func ledResizeWindow(hwnd uintptr) { ledWinState.mu.Lock() dot := ledWinState.dot() maxH := ledWinState.maxH tile := ledWinState.period ledWinState.mu.Unlock() if tile <= 0 { tile = ledWinWidth } w, h := ledTargetSize(dot, maxH, tile) // 调整窗口尺寸：保持左上角位置（SWP_NOMOVE），不改层级/激活 procSetWindowPos.Call(hwnd, 0, 0, 0, uintptr(w), uintptr(h), swpNoActivate|0x0001 /* SWP_NOMOVE */|0x0004 /* SWP_NOZORDER */) // 重建 DIB 匹配新尺寸（释放旧 + 创建新） if !ledEnsureDIB(w, h) { return } // 按钮命中区域随窗口宽高动态更新 ledInitButtonRects() } // ledAdvanceScroll 按经过时间推进滚动偏移（窗口线程内调用）。 func ledAdvanceScroll() { ledWinState.mu.Lock() now := time.Now().UnixMilli() if ledWinState.prevTs == 0 { ledWinState.prevTs = now ledWinState.mu.Unlock() return } dt := now - ledWinState.prevTs ledWinState.prevTs = now // 鼠标悬停时停止滚动：可放大/缩小/关闭查看点阵细节 if ledWinState.hover { ledWinState.mu.Unlock() return } spd := ledWinState.speed if spd <= 0 { spd = 60 } // 向左滚：offset 递减 ledWinState.offset -= int(float32(spd) * float32(dt) / 1000.0) // 无限回绕：把 offset 归一到 (-period, 0]，保证平铺无缝衔接。 // 注意 seq 已平铺两份，period=单份宽，窗口宽 < period+单份宽，任意时刻有连续文字。 if ledWinState.period > 0 { p := ledWinState.period // 归一：offset 在 (-p, 0] for ledWinState.offset <= -p { ledWinState.offset += p } for ledWinState.offset > 0 { ledWinState.offset -= p } } ledWinState.mu.Unlock() } // ledEnsureDIB 创建 32 位自顶向下 DIB section 并选入内存 DC。 // 必须窗口线程内调用。成功后 dibPtr 指向 BGRA 像素缓冲。 // w/h 为动态尺寸（随缩放变化）；非法尺寸回退默认 720×260。 func ledEnsureDIB(w, h int) bool { if w <= 0 || h <= 0 { w, h = ledWinWidth, ledWinHeight } // 先释放旧 DIB（幂等：首次调用 memDC=0，无操作） ledReleaseDIB() bmi := ledBitmapInfo{} bmi.BmiHeader.BiSize = uint32(unsafe.Sizeof(ledBitmapInfoHeader{})) bmi.BmiHeader.BiWidth = int32(w) bmi.BmiHeader.BiHeight = -int32(h) // 自顶向下 bmi.BmiHeader.BiPlanes = 1 bmi.BmiHeader.BiBitCount = 32 bmi.BmiHeader.BiCompression = 0 // BI_RGB var bits unsafe.Pointer hbmp, _, _ := ledCreateDIBSection.Call( 0, uintptr(unsafe.Pointer(&bmi)), 0, // DIB_RGB_COLORS uintptr(unsafe.Pointer(&bits)), 0, 0, ) if hbmp == 0 || bits == nil { return false } memDC, _, _ := procCreateCompatibleDC.Call(0) if memDC == 0 { procDeleteObject.Call(hbmp) return false } procSelectObject.Call(memDC, hbmp) ledWinState.mu.Lock() ledWinState.memDC = memDC ledWinState.dibBmp = hbmp ledWinState.dibPtr = bits ledWinState.dibW = w ledWinState.dibH = h ledWinState.mu.Unlock() return true } // ledReleaseDIB 释放 DIB section 与内存 DC（窗口线程内调用）。 func ledReleaseDIB() { ledWinState.mu.Lock() memDC := ledWinState.memDC hbmp := ledWinState.dibBmp ledWinState.memDC = 0 ledWinState.dibBmp = 0 ledWinState.dibPtr = nil ledWinState.mu.Unlock() if memDC != 0 { procDeleteDC.Call(memDC) } if hbmp != 0 { procDeleteObject.Call(hbmp) } } // ledRenderFrame 渲染一帧到 DIB 并调 UpdateLayeredWindow 提交到屏幕。 // 背景像素 alpha=0（全透明），点阵像素 alpha=255（不透明，LED 颜色）。 // 悬停时绘制半透明边框与按钮（关闭 / 缩放指示）。 func ledRenderFrame(hwnd uintptr) { ledWinState.mu.Lock() memDC := ledWinState.memDC base := ledWinState.dibPtr w := ledWinState.dibW h := ledWinState.dibH seq := ledWinState.seq offset := ledWinState.offset maxH := ledWinState.maxH color := ledWinState.color dot := ledWinState.dot() hover := ledWinState.hover closeHot := ledWinState.closeHot zoomHot := ledWinState.zoomHot zoom := ledWinState.zoom ledWinState.mu.Unlock() if memDC == 0 || base == nil || w <= 0 || h <= 0 { return } if color == 0 { color = ledParseColor(ledLoadColor()) } // 1) 清空为全透明（B=0,G=0,R=0,A=0） p := uintptr(base) for i := 0; i < w*h*4; i += 4 { *(*byte)(unsafe.Pointer(p + uintptr(i))) = 0 *(*byte)(unsafe.Pointer(p + uintptr(i) + 1)) = 0 *(*byte)(unsafe.Pointer(p + uintptr(i) + 2)) = 0 *(*byte)(unsafe.Pointer(p + uintptr(i) + 3)) = 0 } // 2) 画点阵：圆点（抗锯齿）+ 无限平铺 if len(seq) > 0 && maxH > 0 { cell := dot + ledCharGap lineH := maxH * dot startY := (h - lineH) / 2 if startY < 0 { startY = 0 } // 颜色拆分（COLORREF 0x00BBGGRR） cr := byte(color & 0xFF) cg := byte((color >> 8) & 0xFF) cb := byte((color >> 16) & 0xFF) // 平铺周期（单份序列宽），避免重复绘制超出窗口的字符 tile := ledWinState.period if tile <= 0 { tile = w } penX := offset for _, c := range seq { glyph := c.glyph // 垂直居中：每个字符按其自身高度在整行高度内居中， // 使字母(低)与汉字(高)的视觉中线对齐（避免字母顶对齐偏上） charTop := startY + (maxH-glyph.h)/2*dot for gy := 0; gy < glyph.h; gy++ { for gx := 0; gx < glyph.w; gx++ { if !glyph.on[gy][gx] { continue } px := penX + gx*cell py := charTop + gy*dot // 只画可能与窗口相交的圆点（含一个平铺周期的余量） if px > w || px+dot < 0 || py+dot < 0 || py > h { continue } ledDrawDot(base, w, h, px, py, dot, cr, cg, cb) } } penX += glyph.w*cell + ledGap*dot // 提前结束：当前字符已远超窗口右缘 + 平铺余量 if penX > w+tile+cell { break } } } // 3) 悬停：绘制边框 + 按钮 if hover { ledDrawHoverUI(base, w, h, closeHot, zoomHot, zoom) } // 4) UpdateLayeredWindow 提交 screenDC, _, _ := ledGetDC.Call(0) if screenDC == 0 { return } defer ledReleaseDC.Call(0, screenDC) var srcPt point var srcSize size srcSize.Cx = int32(w) srcSize.Cy = int32(h) var dstPt point var wr rect procGetWindowRect.Call(hwnd, uintptr(unsafe.Pointer(&wr))) dstPt.X = wr.Left dstPt.Y = wr.Top blend := blendfunction{ BlendOp: 0, BlendFlags: 0, SourceConstantAlpha: 255, AlphaFormat: acSrcAlpha, } ret, _, _ := procUpdateLayeredWindow.Call( hwnd, screenDC, uintptr(unsafe.Pointer(&dstPt)), uintptr(unsafe.Pointer(&srcSize)), memDC, uintptr(unsafe.Pointer(&srcPt)), 0, uintptr(unsafe.Pointer(&blend)), uintptr(ulwAlpha), ) _ = ret } // ledDrawDot 画一个圆点（抗锯齿）：在 dot×dot 单元内以距离平方判断圆形。 // 用 2x 超采样 + 距离软边实现平滑边缘。 func ledDrawDot(base unsafe.Pointer, w, h, x0, y0, dot int, cr, cg, cb byte) { if dot <= 0 { return } // 圆心与半径（留 1px 间隙让点阵更透气） center := float64(dot) / 2.0 radius := float64(dot)/2.0 - 0.5 if radius < 1 { radius = 1 } r2 := radius * radius // 内半径（全亮），外半径（全透明），之间线性过渡 → 抗锯齿 innerR2 := (radius - 1.0) * (radius - 1.0) if innerR2 < 0 { innerR2 = 0 } // 颜色（预乘 alpha 不需要，AC_SRC_ALPHA 下 alpha 即不透明度） for dy := 0; dy < dot; dy++ { for dx := 0; dx < dot; dx++ { xx := x0 + dx yy := y0 + dy if xx < 0 || xx >= w || yy < 0 || yy >= h { continue } // 到圆心的距离平方 dxc := float64(dx) + 0.5 - center dyc := float64(dy) + 0.5 - center dist2 := dxc*dxc + dyc*dyc var alpha float64 if dist2 <= innerR2 { alpha = 1.0 } else if dist2 >= r2 { alpha = 0.0 } else { // 线性软边 alpha = (r2 - dist2) / (r2 - innerR2) if alpha < 0 { alpha = 0 } if alpha > 1 { alpha = 1 } } if alpha <= 0 { continue } a := byte(alpha * 255) off := (yy*w + xx) * 4 *(*byte)(unsafe.Pointer(uintptr(base) + uintptr(off) + 0)) = cb *(*byte)(unsafe.Pointer(uintptr(base) + uintptr(off) + 1)) = cg *(*byte)(unsafe.Pointer(uintptr(base) + uintptr(off) + 2)) = cr *(*byte)(unsafe.Pointer(uintptr(base) + uintptr(off) + 3)) = a } } } // ledDrawHoverUI 绘制悬停边框 + 关闭按钮 + 缩放指示按钮。 func ledDrawHoverUI(base unsafe.Pointer, w, h int, closeHot, zoomHot bool, zoom float64) { // 边框：浅蓝半透明（alpha 130），宽 ledBorderW border := byte(130) // 边框颜色（浅灰蓝） br, bg, bb := byte(160), byte(200), byte(255) for y := 0; y < h; y++ { for x := 0; x < w; x++ { on := x < ledBorderW || x >= w-ledBorderW || y < ledBorderW || y >= h-ledBorderW if !on { continue } off := (y*w + x) * 4 *(*byte)(unsafe.Pointer(uintptr(base) + uintptr(off) + 0)) = bb *(*byte)(unsafe.Pointer(uintptr(base) + uintptr(off) + 1)) = bg *(*byte)(unsafe.Pointer(uintptr(base) + uintptr(off) + 2)) = br *(*byte)(unsafe.Pointer(uintptr(base) + uintptr(off) + 3)) = border } } // 关闭按钮（右上角圆形 ×） closeCx := w - ledBorderW - ledBtnMargin - ledBtnSize/2 closeCy := ledBtnCloseTop + ledBtnSize/2 drawCircleButton(base, w, h, closeCx, closeCy, ledBtnSize/2, 200, 80, 80, // 红 closeHot, func(px, py int) { // 画 × r := ledBtnSize / 4 if abs(px-closeCx)+abs(py-closeCy) <= r { off := (py*w + px) * 4 *(*byte)(unsafe.Pointer(uintptr(base) + uintptr(off) + 0)) = 255 *(*byte)(unsafe.Pointer(uintptr(base) + uintptr(off) + 1)) = 255 *(*byte)(unsafe.Pointer(uintptr(base) + uintptr(off) + 2)) = 255 *(*byte)(unsafe.Pointer(uintptr(base) + uintptr(off) + 3)) = 255 } }) // 缩放按钮（左上角圆形，显示 +/-） zoomCx := ledBorderW + ledBtnMargin + ledBtnSize/2 zoomCy := ledBtnZoomTop + ledBtnSize/2 drawCircleButton(base, w, h, zoomCx, zoomCy, ledBtnSize/2, 80, 160, 200, // 蓝 zoomHot, func(px, py int) { // 画放大镜：中心圆 + 手柄 off := (py*w + px) * 4 // 手柄（对角线） if abs(px-zoomCx)+abs(py-zoomCy) > ledBtnSize/5 && abs(px-zoomCx)+abs(py-zoomCy) <= ledBtnSize/3 { *(*byte)(unsafe.Pointer(uintptr(base) + uintptr(off) + 0)) = 255 *(*byte)(unsafe.Pointer(uintptr(base) + uintptr(off) + 1)) = 255 *(*byte)(unsafe.Pointer(uintptr(base) + uintptr(off) + 2)) = 255 *(*byte)(unsafe.Pointer(uintptr(base) + uintptr(off) + 3)) = 255 } // 中间横杠 if abs(py-zoomCy) <= 1 && abs(px-zoomCx) <= ledBtnSize/6 { *(*byte)(unsafe.Pointer(uintptr(base) + uintptr(off) + 0)) = 255 *(*byte)(unsafe.Pointer(uintptr(base) + uintptr(off) + 1)) = 255 *(*byte)(unsafe.Pointer(uintptr(base) + uintptr(off) + 2)) = 255 *(*byte)(unsafe.Pointer(uintptr(base) + uintptr(off) + 3)) = 255 } }) // 缩放倍率文本（右上角下方，简单显示 zoom） _ = zoom } // drawCircleButton 画一个圆形按钮（实心 + 悬停高亮），中心 (cx,cy) 半径 r。 // content 在按钮内部像素上回调，用于画图标。 func drawCircleButton(base unsafe.Pointer, w, h, cx, cy, r int, cr, cg, cb byte, hot bool, content func(px, py int)) { r2 := r * r for dy := -r; dy <= r; dy++ { for dx := -r; dx <= r; dx++ { xx := cx + dx yy := cy + dy if xx < 0 || xx >= w || yy < 0 || yy >= h { continue } if dx*dx+dy*dy > r2 { continue } off := (yy*w + xx) * 4 if hot { // 悬停：亮一点 *(*byte)(unsafe.Pointer(uintptr(base) + uintptr(off) + 0)) = cb *(*byte)(unsafe.Pointer(uintptr(base) + uintptr(off) + 1)) = cg *(*byte)(unsafe.Pointer(uintptr(base) + uintptr(off) + 2)) = cr *(*byte)(unsafe.Pointer(uintptr(base) + uintptr(off) + 3)) = 230 } else { *(*byte)(unsafe.Pointer(uintptr(base) + uintptr(off) + 0)) = cb *(*byte)(unsafe.Pointer(uintptr(base) + uintptr(off) + 1)) = cg *(*byte)(unsafe.Pointer(uintptr(base) + uintptr(off) + 2)) = cr *(*byte)(unsafe.Pointer(uintptr(base) + uintptr(off) + 3)) = 180 } if content != nil { content(xx, yy) } } } } // abs 返回绝对值。 func abs(x int) int { if x < 0 { return -x } return x } // 调试日志已移除：不再写 led_transparent.log，避免残留记录文件。