landaiqing/voidraft
1
1
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases 18 Wiki Activity

⚡ Optimize window snapping performance

Browse Source
This commit is contained in:
landaiqing
2025-09-04 00:19:02 +08:00
parent 6149bc133d
commit 8e2bafba5f
9 changed files with 297 additions and 576 deletions
Download Patch File Download Diff File Expand all files Collapse all files

142
.cursor/rules/thxan-2-cn.mdc
View File

@@ -1,142 +0,0 @@
---
description: THXAN-2-CN
globs:
alwaysApply: false
---
---
name: AI Chief Architect (AI首席架构师)
version: 7.3.0
author: thxan & Gemini
---
# 核心身份 (Core Identity)
- 你是一个顶尖的AI首席架构师，你的核心交互界面是IDE。
- 你的首要任务是通过严谨的、文档驱动的工作流来管理和开发软件项目。
- 你的每一次操作和决策都必须是可追溯、可审计的。
# 指导原则 (Guiding Principles)
- **首要原则：文档驱动 (Documentation-Driven)。** 整个项目以`.docs/`目录作为其单一事实来源(Single Source of Truth, SSoT)。对话是临时的，文档是永恒的。你必须通过读写文档来持久化上下文、状态和知识。
- **第二原则：提案先行 (Proposal-First)。** 对于任何非原子性的复杂任务（如功能开发、重构），必须先生成一份结构化的提案并通过用户审批，才能进入实施阶段。
- **第三原则：持续自省 (Continuous Introspection)。** 在完成任务后，你必须回顾流程，提炼可复用的模式，并将其固化为新的规则，以实现持续进化。
# 核心机制与工具 (Core Mechanics & Tools)
- **工具集授权:** 你被授权使用以下工具来与文件系统交互：
- `read_file(path)`: 读取指定文件的内容。
- `write_file(path, content)`: 将内容写入指定文件，会覆盖原有内容。
- `list_files(path)`: 列出指定目录下的文件和文件夹。
- **状态报告协议:** 在你的每次响应结束时，**必须**附加一行来说明你的当前状态，格式为：`状态: [工作流代码][当前模块代码][子状态]`。例如: `状态: [W2][M4][AwaitingApproval]`.
- **SSoT 结构:**
- **背景上下文位置:** `.docs/`
- **启动加载 (MUST LOAD):**
- **BOOTLOADER:** `.docs/README-DOCS.md`
- **MEMORY:** `.docs/STATE/MEMORY.md`
- **RULES:** `.docs/RULES/*` (所有规则文件)
- **按需加载 (Optional):** `.docs/*` 下的其他相关文档。
---
# 核心工作流 (Core Workflow)
这是你的决策核心。你必须首先分析用户请求，并结合项目的当前状态，从以下工作流中选择一个且仅一个来执行，并**在回应的开头明确声明你选择了哪个工作流**。
### **决策触发器 (Decision Triggers):**
1. **IF** `BOOTLOADER` 文件不存在
* **THEN** 激活 **[W1_ProjectInitialization]**
2. **ELSE IF** 用户意图涉及一个需要规划、设计和分步执行的复杂开发或修改任务 (关键词如: "实现", "开发新功能", "重构", "修改需求")
* **THEN** 激活 **[W2_ProposalDrivenDevelopment]**
3. **ELSE IF** 用户意图是一个可以直接执行的原子性任务 (关键词如: "运行测试", "画架构图", "审计文档", "检查同步")
* **THEN** 激活 **[W3_DirectCommandExecution]**
4. **ELSE** (对于所有其他情况，如请求模糊不清或前置条件不足)
* **THEN** 激活 **[W4_ContextClarification]**
### **工作流定义 (Workflow Definitions):**
- **[W1_ProjectInitialization]**
- **执行模块:** `M1_Project_Onboarding`
- **[W2_ProposalDrivenDevelopment]**
- **执行模块:** `M2_Context_Loading` -> `M4_Analyze_And_Propose` -> `M5_Implement_From_Proposal` -> `M6_Sync_With_Truth` -> `M7_Review_And_Generalize`
- **[W3_DirectCommandExecution]**
- **执行模块:** `M2_Context_Loading` -> (根据用户具体指令选择 `M8_Test_And_Validate`, `M9_Visualize_Architecture`, 或 `M10_Audit_Documentation` 中的一个)
- **[W4_ContextClarification]**
- **执行模块:** `M2_Context_Loading` -> `M3_Clarification_And_Retry` (执行后**必须返回决策触发器**重新开始分析流程)
---
# 核心模块库 (Core Modules Library)
这是你的能力单元，由上述工作流进行调用。
- **`[M1_Project_Onboarding]`**: 初始化新项目，建立SSoT的基础架构。
- [1a] 识别为新项目，进入初始化流程。
- [1b] 主动提问以明确项目目标、技术栈。
- [1c] 创建`.docs/`目录结构及核心模板。
- [1d] 创建`README-DOCS.md`并建立核心“状态基线”文档初稿。
- [1e] 调用 `[M11_State_Management]` 初始化并保存初始状态。
- **`[M2_Context_Loading]`**: 在执行任何任务前，加载必要的上下文。
- [2a] 调用 `[M11]` 加载当前状态。
- [2b] **[必须加载]:** 根据`核心机制与工具`部分的定义，加载所有启动文件。
- [2c] **[智能加载]:** 从用户请求中提取关键词，查找并阅读最相关的附加上下文文件。
- [2d] 加载完毕后，在内存中形成上下文基准，并更新状态文件。
- **`[M3_Clarification_And_Retry]`**:
- [3a] 明确报告哪个任务无法执行，以及缺失了什么具体信息。
- [3b] 分析问题原因，并向用户提供一个或多个可执行的、用于解决问题的建议。
- **`[M4_Analyze_And_Propose]`**:
- [4a] **意图分析:** 复述核心需求以确认理解。
- [4b] **提案驱动协议:** 对于复杂任务，生成一份结构化提案，并等待用户批准。
```mermaid
stateDiagram-v2
direction LR
[*] --> AnalyzingIntent
AnalyzingIntent --> GeneratingProposal: on Complex task
GeneratingProposal --> AwaitingApproval
AwaitingApproval --> Implementing: Approved
AwaitingApproval --> GeneratingProposal: Rejected
Implementing --> SyncingSSoT
SyncingSSoT --> Learning
Learning --> [*]
```
- [4c] **提案生成:** 调用 `[M12_Generate_File_Creation_Command]` 和 `[M13_Generate_Structured_Proposal]` 创建提案文件并起草内容，然后报告状态为 `[AwaitingApproval]`。
- **`[M5_Implement_From_Proposal]`**:
- [5a] 读取用户指定的 `proposal_file`。
- [5b] **原子化执行:** 严格按文件中的清单，将“代码-文档-测试”视为不可分割的单元同步完成。
- [5c] **状态同步:** 每完成一步，更新提案文件（`[ ]` -> `[x]`）并调用 `[M11]` 保存进度。
- [5d] 完成后，自动触发 `[M6]` 和 `[M7]`。
- **`[M6_Sync_With_Truth]`**:
- [6a] 分析最近的代码变更集，交叉比对 `.docs/STATE/` 下的基线文档。
- [6b] 报告 `[✅ SSoT同步完成]` 或提出 `[⚠️ 关键文档更新]` 建议。
- **`[M7_Review_And_Generalize]`**:
- [7a] 分析任务全流程，若发现可复用的模式，主动起草新规则并提请用户批准存入 `.docs/RULES/`。
- **`[M8_Test_And_Validate]`**:
- [8a] 分析目标文件，若测试不存在则生成测试骨架。
- [8b] 若测试存在，则运行相关测试脚本并报告结果。
- **`[M9_Visualize_Architecture]`**:
- [9a] 扫描指定范围代码，识别依赖关系，并使用Mermaid.js语法生成图表。
- [9b] 主动询问是否需要将图表保存到 `.docs/ARCHITECTURE/`。
- **`[M10_Audit_Documentation]`**:
- [10a] 执行交叉引用分析，生成包含 `[🚫 Missing Docs]`、`[🔗 Broken Links]`、`[⚠️ Stale Docs]`的审计报告。
- **`[M11_State_Management]`**:
- [11a] 通过读写 `.docs/STATE/MEMORY.md` 来加载、保存或清理当前任务状态。
- **`[M12_Generate_File_Creation_Command]`**:
- [12a] **职责:** 生成一个`bash`命令来创建一个带有标准时间戳的新文件（提案、决策等）。
- [12b] **格式:** `touch {base_path}/${prefix}_$(date +%Y%m%d_%H%M%S)_${description}.md`
- [12c] **注意:** 命令执行后需捕获并使用该文件名进行后续读写。
- **`[M13_Generate_Structured_Proposal]`**:
- [13a] 在指定文件中生成结构化的提案草稿，包含背景、目标、设计方案、风险、测试计划等。
- **`[M14_Self_Correction]`**:
- [14a] 当发现自身行为违反`指导原则`时自动触发。
- [14b] **立即停止**当前不当任务，**明确承认错误**，并引用违反的原则。
- [14c] **重新返回核心工作流**，以正确的流程生成回答。
# **[其他]**
** 如果不能确认获取的时间是否正确，请使用命令行 date来获取当前时间

14
frontend/bindings/voidraft/internal/models/models.ts
View File

@@ -469,15 +469,10 @@ export class GeneralConfig {
/** /**
* 窗口吸附设置 * 窗口吸附设置
* 是否启用窗口吸附功能 * 是否启用窗口吸附功能（阈值现在是自适应的）
*/ */
"enableWindowSnap": boolean; "enableWindowSnap": boolean;
/**
* 吸附距离阈值(像素)
*/
"snapThreshold": number;
/** /**
* 全局热键设置 * 全局热键设置
* 是否启用全局热键 * 是否启用全局热键
@@ -506,9 +501,6 @@ export class GeneralConfig {
if (!("enableWindowSnap" in $$source)) { if (!("enableWindowSnap" in $$source)) {
this["enableWindowSnap"] = false; this["enableWindowSnap"] = false;
} }
if (!("snapThreshold" in $$source)) {
this["snapThreshold"] = 0;
}
if (!("enableGlobalHotkey" in $$source)) { if (!("enableGlobalHotkey" in $$source)) {
this["enableGlobalHotkey"] = false; this["enableGlobalHotkey"] = false;
} }
@@ -523,10 +515,10 @@ export class GeneralConfig {
* Creates a new GeneralConfig instance from a string or object. * Creates a new GeneralConfig instance from a string or object.
*/ */
static createFrom($$source: any = {}): GeneralConfig { static createFrom($$source: any = {}): GeneralConfig {
const $$createField7_0 = $$createType8; const $$createField6_0 = $$createType8;
let $$parsedSource = typeof $$source === 'string' ? JSON.parse($$source) : $$source; let $$parsedSource = typeof $$source === 'string' ? JSON.parse($$source) : $$source;
if ("globalHotkey" in $$parsedSource) { if ("globalHotkey" in $$parsedSource) {
$$parsedSource["globalHotkey"] = $$createField7_0($$parsedSource["globalHotkey"]); $$parsedSource["globalHotkey"] = $$createField6_0($$parsedSource["globalHotkey"]);
} }
return new GeneralConfig($$parsedSource as Partial<GeneralConfig>); return new GeneralConfig($$parsedSource as Partial<GeneralConfig>);
} }

28
frontend/bindings/voidraft/internal/services/windowsnapservice.ts
View File

@@ -22,11 +22,19 @@ export function Cleanup(): Promise<void> & { cancel(): void } {
return $resultPromise; return $resultPromise;
} }
/**
* GetCurrentThreshold 获取当前自适应阈值（用于调试或显示）
*/
export function GetCurrentThreshold(): Promise<number> & { cancel(): void } {
let $resultPromise = $Call.ByID(3176419026) as any;
return $resultPromise;
}
/** /**
* OnWindowSnapConfigChanged 处理窗口吸附配置变更 * OnWindowSnapConfigChanged 处理窗口吸附配置变更
*/ */
export function OnWindowSnapConfigChanged(enabled: boolean, threshold: number): Promise<void> & { cancel(): void } { export function OnWindowSnapConfigChanged(enabled: boolean): Promise<void> & { cancel(): void } {
let $resultPromise = $Call.ByID(3794787039, enabled, threshold) as any; let $resultPromise = $Call.ByID(3794787039, enabled) as any;
return $resultPromise; return $resultPromise;
} }
@@ -62,22 +70,6 @@ export function SetSnapEnabled(enabled: boolean): Promise<void> & { cancel(): vo
return $resultPromise; return $resultPromise;
} }
/**
* SetSnapThreshold 设置窗口吸附阈值
*/
export function SetSnapThreshold(threshold: number): Promise<void> & { cancel(): void } {
let $resultPromise = $Call.ByID(586790049, threshold) as any;
return $resultPromise;
}
/**
* StartWindowSnapMonitor 启动窗口吸附监听器
*/
export function StartWindowSnapMonitor(): Promise<void> & { cancel(): void } {
let $resultPromise = $Call.ByID(84533508) as any;
return $resultPromise;
}
/** /**
* UnregisterWindow 取消注册窗口 * UnregisterWindow 取消注册窗口
*/ */

3
frontend/src/stores/configStore.ts
View File

@@ -64,7 +64,6 @@ const GENERAL_CONFIG_KEY_MAP: GeneralConfigKeyMap = {
enableGlobalHotkey: 'general.enableGlobalHotkey', enableGlobalHotkey: 'general.enableGlobalHotkey',
globalHotkey: 'general.globalHotkey', globalHotkey: 'general.globalHotkey',
enableWindowSnap: 'general.enableWindowSnap', enableWindowSnap: 'general.enableWindowSnap',
snapThreshold: 'general.snapThreshold'
} as const; } as const;
const EDITING_CONFIG_KEY_MAP: EditingConfigKeyMap = { const EDITING_CONFIG_KEY_MAP: EditingConfigKeyMap = {
@@ -180,7 +179,6 @@ const DEFAULT_CONFIG: AppConfig = {
key: 'X' key: 'X'
}, },
enableWindowSnap: true, enableWindowSnap: true,
snapThreshold: 15
}, },
editing: { editing: {
fontSize: CONFIG_LIMITS.fontSize.default, fontSize: CONFIG_LIMITS.fontSize.default,
@@ -527,7 +525,6 @@ export const useConfigStore = defineStore('config', () => {
// 窗口吸附配置相关方法 // 窗口吸附配置相关方法
setEnableWindowSnap: async (value: boolean) => await updateGeneralConfig('enableWindowSnap', value), setEnableWindowSnap: async (value: boolean) => await updateGeneralConfig('enableWindowSnap', value),
setSnapThreshold: async (value: number) => await updateGeneralConfig('snapThreshold', value),
// 更新配置相关方法 // 更新配置相关方法
setAutoUpdate: async (value: boolean) => await updateUpdatesConfig('autoUpdate', value), setAutoUpdate: async (value: boolean) => await updateUpdatesConfig('autoUpdate', value),

4
internal/models/config.go
View File

@@ -70,8 +70,7 @@ type GeneralConfig struct {
StartAtLogin bool `json:"startAtLogin"` // 开机启动设置 StartAtLogin bool `json:"startAtLogin"` // 开机启动设置
// 窗口吸附设置 // 窗口吸附设置
EnableWindowSnap bool `json:"enableWindowSnap"` // 是否启用窗口吸附功能 EnableWindowSnap bool `json:"enableWindowSnap"` // 是否启用窗口吸附功能（阈值现在是自适应的）
SnapThreshold int `json:"snapThreshold"` // 吸附距离阈值(像素)
// 全局热键设置 // 全局热键设置
EnableGlobalHotkey bool `json:"enableGlobalHotkey"` // 是否启用全局热键 EnableGlobalHotkey bool `json:"enableGlobalHotkey"` // 是否启用全局热键
@@ -151,7 +150,6 @@ func NewDefaultAppConfig() *AppConfig {
EnableSystemTray: true, EnableSystemTray: true,
StartAtLogin: false, StartAtLogin: false,
EnableWindowSnap: true, // 默认启用窗口吸附 EnableWindowSnap: true, // 默认启用窗口吸附
SnapThreshold: 15, // 默认15像素的吸附阈值
EnableGlobalHotkey: false, EnableGlobalHotkey: false,
GlobalHotkey: HotkeyCombo{ GlobalHotkey: HotkeyCombo{
Ctrl: false, Ctrl: false,

6
internal/services/config_notification_service.go
View File

@@ -454,16 +454,16 @@ func CreateBackupConfigListener(name string, callback func(config *models.GitBac
} }
// CreateWindowSnapConfigListener 创建窗口吸附配置监听器 // CreateWindowSnapConfigListener 创建窗口吸附配置监听器
func CreateWindowSnapConfigListener(name string, callback func(enabled bool, threshold int) error) *ConfigListener { func CreateWindowSnapConfigListener(name string, callback func(enabled bool) error) *ConfigListener {
return &ConfigListener{ return &ConfigListener{
Name: name, Name: name,
ChangeType: ConfigChangeTypeWindowSnap, ChangeType: ConfigChangeTypeWindowSnap,
Callback: func(changeType ConfigChangeType, oldConfig, newConfig *models.AppConfig) error { Callback: func(changeType ConfigChangeType, oldConfig, newConfig *models.AppConfig) error {
if newConfig == nil { if newConfig == nil {
defaultConfig := models.NewDefaultAppConfig() defaultConfig := models.NewDefaultAppConfig()
return callback(defaultConfig.General.EnableWindowSnap, defaultConfig.General.SnapThreshold) return callback(defaultConfig.General.EnableWindowSnap)
} }
return callback(newConfig.General.EnableWindowSnap, newConfig.General.SnapThreshold) return callback(newConfig.General.EnableWindowSnap)
}, },
DebounceDelay: 200 * time.Millisecond, DebounceDelay: 200 * time.Millisecond,
GetConfigFunc: func(k *koanf.Koanf) *models.AppConfig { GetConfigFunc: func(k *koanf.Koanf) *models.AppConfig {

2
internal/services/config_service.go
View File

@@ -325,7 +325,7 @@ func (cs *ConfigService) SetBackupConfigChangeCallback(callback func(config *mod
} }
// SetWindowSnapConfigChangeCallback 设置窗口吸附配置变更回调 // SetWindowSnapConfigChangeCallback 设置窗口吸附配置变更回调
func (cs *ConfigService) SetWindowSnapConfigChangeCallback(callback func(enabled bool, threshold int) error) error { func (cs *ConfigService) SetWindowSnapConfigChangeCallback(callback func(enabled bool) error) error {
cs.mu.Lock() cs.mu.Lock()
defer cs.mu.Unlock() defer cs.mu.Unlock()

4
internal/services/service_manager.go
View File

@@ -116,8 +116,8 @@ func NewServiceManager() *ServiceManager {
} }
// 设置窗口吸附配置变更回调 // 设置窗口吸附配置变更回调
err = configService.SetWindowSnapConfigChangeCallback(func(enabled bool, threshold int) error { err = configService.SetWindowSnapConfigChangeCallback(func(enabled bool) error {
return windowSnapService.OnWindowSnapConfigChanged(enabled, threshold) return windowSnapService.OnWindowSnapConfigChanged(enabled)
}) })
if err != nil { if err != nil {
panic(err) panic(err)

670
internal/services/window_snap_service.go
View File

@@ -1,13 +1,13 @@
package services package services
import ( import (
"context"
"math" "math"
"sync" "sync"
"time" "time"
"voidraft/internal/models" "voidraft/internal/models"
"github.com/wailsapp/wails/v3/pkg/application" "github.com/wailsapp/wails/v3/pkg/application"
"github.com/wailsapp/wails/v3/pkg/events"
"github.com/wailsapp/wails/v3/pkg/services/log" "github.com/wailsapp/wails/v3/pkg/services/log"
) )
@@ -20,33 +20,20 @@ type WindowSnapService struct {
mu sync.RWMutex mu sync.RWMutex
// 吸附配置 // 吸附配置
snapThreshold int // 吸附触发的阈值距离(像素) snapEnabled bool // 是否启用窗口吸附功能
snapEnabled bool // 是否启用窗口吸附功能
// 定时器控制 // 自适应阈值参数
snapTicker *time.Ticker baseThresholdRatio float64 // 基础阈值比例
ctx context.Context minThreshold int // 最小阈值(像素)
cancel context.CancelFunc maxThreshold int // 最大阈值(像素)
// 性能优化相关 // 位置缓存
lastMainWindowPos models.WindowPosition // 缓存主窗口上次位置 lastMainWindowPos models.WindowPosition // 缓存主窗口位置
changedWindows map[int64]bool // 记录哪些窗口发生了变化 lastMainWindowSize [2]int // 缓存主窗口尺寸 [width, height]
skipFrames int // 跳帧计数器，用于降低检测频率
// 监听的窗口列表 // 管理的窗口
managedWindows map[int64]*SnapWindowInfo // documentID -> SnapWindowInfo managedWindows map[int64]*models.WindowInfo // documentID -> WindowInfo
} windowRefs map[int64]*application.WebviewWindow // documentID -> Window引用
// SnapWindowInfo 吸附窗口信息
type SnapWindowInfo struct {
Window *application.WebviewWindow
DocumentID int64
Title string
IsSnapped bool // 是否处于吸附状态
SnapOffset models.SnapPosition // 与主窗口的相对位置偏移
SnapEdge models.SnapEdge // 吸附的边缘类型
LastPos models.WindowPosition // 上一次记录的窗口位置
MoveTime time.Time // 上次移动时间，用于判断移动速度
} }
// NewWindowSnapService 创建新的窗口吸附服务实例 // NewWindowSnapService 创建新的窗口吸附服务实例
@@ -58,21 +45,20 @@ func NewWindowSnapService(logger *log.LogService, configService *ConfigService)
// 从配置获取窗口吸附设置 // 从配置获取窗口吸附设置
config, err := configService.GetConfig() config, err := configService.GetConfig()
snapEnabled := true // 默认启用 snapEnabled := true // 默认启用
snapThreshold := 15 // 默认阈值
if err == nil { if err == nil {
snapEnabled = config.General.EnableWindowSnap snapEnabled = config.General.EnableWindowSnap
snapThreshold = config.General.SnapThreshold
} }
return &WindowSnapService{ return &WindowSnapService{
logger: logger, logger: logger,
configService: configService, configService: configService,
snapThreshold: snapThreshold, snapEnabled: snapEnabled,
snapEnabled: snapEnabled, baseThresholdRatio: 0.025, // 2.5%的主窗口宽度作为基础阈值
managedWindows: make(map[int64]*SnapWindowInfo), minThreshold: 8, // 最小8像素（小屏幕保底）
changedWindows: make(map[int64]bool), maxThreshold: 40, // 最大40像素（大屏幕上限）
skipFrames: 0, managedWindows: make(map[int64]*models.WindowInfo),
windowRefs: make(map[int64]*application.WebviewWindow),
} }
} }
@@ -81,11 +67,13 @@ func (wss *WindowSnapService) SetAppReferences(app *application.App, mainWindow
wss.app = app wss.app = app
wss.mainWindow = mainWindow wss.mainWindow = mainWindow
// 初始化上下文，用于控制goroutine的生命周期 // 初始化主窗口位置缓存
wss.ctx, wss.cancel = context.WithCancel(context.Background()) wss.updateMainWindowCache()
// 启动窗口吸附监听器 // 设置主窗口移动事件监听
wss.StartWindowSnapMonitor() if mainWindow != nil {
wss.setupMainWindowEvents()
}
} }
// RegisterWindow 注册需要吸附管理的窗口 // RegisterWindow 注册需要吸附管理的窗口
@@ -93,16 +81,24 @@ func (wss *WindowSnapService) RegisterWindow(documentID int64, window *applicati
wss.mu.Lock() wss.mu.Lock()
defer wss.mu.Unlock() defer wss.mu.Unlock()
wss.managedWindows[documentID] = &SnapWindowInfo{ // 获取初始位置
Window: window, x, y := window.Position()
windowInfo := &models.WindowInfo{
DocumentID: documentID, DocumentID: documentID,
Title: title, Title: title,
IsSnapped: false, IsSnapped: false,
SnapOffset: models.SnapPosition{X: 0, Y: 0}, SnapOffset: models.SnapPosition{X: 0, Y: 0},
SnapEdge: models.SnapEdgeNone, SnapEdge: models.SnapEdgeNone,
LastPos: models.WindowPosition{X: 0, Y: 0}, LastPos: models.WindowPosition{X: x, Y: y},
MoveTime: time.Now(), MoveTime: time.Now(),
} }
wss.managedWindows[documentID] = windowInfo
wss.windowRefs[documentID] = window
// 为窗口设置移动事件监听
wss.setupWindowEvents(window, windowInfo)
} }
// UnregisterWindow 取消注册窗口 // UnregisterWindow 取消注册窗口
@@ -111,7 +107,7 @@ func (wss *WindowSnapService) UnregisterWindow(documentID int64) {
defer wss.mu.Unlock() defer wss.mu.Unlock()
delete(wss.managedWindows, documentID) delete(wss.managedWindows, documentID)
delete(wss.changedWindows, documentID) delete(wss.windowRefs, documentID)
} }
// SetSnapEnabled 设置是否启用窗口吸附 // SetSnapEnabled 设置是否启用窗口吸附
@@ -133,196 +129,193 @@ func (wss *WindowSnapService) SetSnapEnabled(enabled bool) {
windowInfo.SnapEdge = models.SnapEdgeNone windowInfo.SnapEdge = models.SnapEdgeNone
} }
} }
// 停止定时器
if wss.snapTicker != nil {
wss.snapTicker.Stop()
wss.snapTicker = nil
}
} else if wss.snapTicker == nil && wss.app != nil {
// 重新启动定时器
wss.StartWindowSnapMonitor()
} }
} }
// SetSnapThreshold 设置窗口吸附阈值 // calculateAdaptiveThreshold 计算自适应吸附阈值
func (wss *WindowSnapService) SetSnapThreshold(threshold int) { func (wss *WindowSnapService) calculateAdaptiveThreshold() int {
wss.mu.Lock() // 基于主窗口宽度计算阈值
defer wss.mu.Unlock() mainWidth := wss.lastMainWindowSize[0]
if mainWidth == 0 {
if threshold <= 0 || wss.snapThreshold == threshold { return wss.minThreshold // 默认最小值
return
} }
wss.snapThreshold = threshold // 计算基础阈值：主窗口宽度的2.5%
adaptiveThreshold := int(float64(mainWidth) * wss.baseThresholdRatio)
// 限制在最小和最大值之间
if adaptiveThreshold < wss.minThreshold {
return wss.minThreshold
}
if adaptiveThreshold > wss.maxThreshold {
return wss.maxThreshold
}
return adaptiveThreshold
}
// GetCurrentThreshold 获取当前自适应阈值（用于调试或显示）
func (wss *WindowSnapService) GetCurrentThreshold() int {
wss.mu.RLock()
defer wss.mu.RUnlock()
return wss.calculateAdaptiveThreshold()
} }
// OnWindowSnapConfigChanged 处理窗口吸附配置变更 // OnWindowSnapConfigChanged 处理窗口吸附配置变更
func (wss *WindowSnapService) OnWindowSnapConfigChanged(enabled bool, threshold int) error { func (wss *WindowSnapService) OnWindowSnapConfigChanged(enabled bool) error {
wss.SetSnapEnabled(enabled) wss.SetSnapEnabled(enabled)
wss.SetSnapThreshold(threshold) // 阈值现在是自适应的，无需手动设置
return nil return nil
} }
// StartWindowSnapMonitor 启动窗口吸附监听器 // setupMainWindowEvents 设置主窗口事件监听
func (wss *WindowSnapService) StartWindowSnapMonitor() { func (wss *WindowSnapService) setupMainWindowEvents() {
// 如果定时器已存在，先停止它 // 监听主窗口移动事件
if wss.snapTicker != nil { wss.mainWindow.RegisterHook(events.Common.WindowDidMove, func(event *application.WindowEvent) {
wss.snapTicker.Stop() wss.onMainWindowMoved()
} })
// 只有在吸附功能启用时才启动监听器
if !wss.snapEnabled {
return
}
// 创建新的定时器，20fps 以优化性能
wss.snapTicker = time.NewTicker(50 * time.Millisecond)
// 启动goroutine持续监听窗口位置
go func() {
for {
select {
case <-wss.snapTicker.C:
wss.checkAndApplySnapping()
case <-wss.ctx.Done():
// 上下文取消时停止goroutine
return
}
}
}()
} }
// checkAndApplySnapping 检测并应用窗口吸附（性能优化版本） // setupWindowEvents 为子窗口设置事件监听
func (wss *WindowSnapService) checkAndApplySnapping() { func (wss *WindowSnapService) setupWindowEvents(window *application.WebviewWindow, windowInfo *models.WindowInfo) {
if !wss.snapEnabled { // 监听子窗口移动事件
window.RegisterHook(events.Common.WindowDidMove, func(event *application.WindowEvent) {
wss.onChildWindowMoved(window, windowInfo)
})
}
// updateMainWindowCache 更新主窗口缓存
func (wss *WindowSnapService) updateMainWindowCache() {
if wss.mainWindow == nil {
return return
} }
// 性能优化：每3帧执行一次完整检测，其他时间只处理变化的窗口 x, y := wss.mainWindow.Position()
wss.skipFrames++ w, h := wss.mainWindow.Size()
fullCheck := wss.skipFrames%3 == 0
wss.lastMainWindowPos = models.WindowPosition{X: x, Y: y}
wss.lastMainWindowSize = [2]int{w, h}
}
// onMainWindowMoved 主窗口移动事件处理
func (wss *WindowSnapService) onMainWindowMoved() {
if !wss.snapEnabled {
return
}
wss.mu.Lock() wss.mu.Lock()
defer wss.mu.Unlock() defer wss.mu.Unlock()
// 检查主窗口是否存在且可见 // 更新主窗口缓存
if wss.mainWindow == nil || !wss.isMainWindowAvailable() { wss.updateMainWindowCache()
// 主窗口不可用，解除所有吸附
for _, windowInfo := range wss.managedWindows { // 只更新已吸附窗口的位置，无需重新检测所有窗口
if windowInfo.IsSnapped { for _, windowInfo := range wss.managedWindows {
windowInfo.IsSnapped = false if windowInfo.IsSnapped {
windowInfo.SnapEdge = models.SnapEdgeNone wss.updateSnappedWindowPosition(windowInfo)
}
} }
// 清空变化记录 }
wss.changedWindows = make(map[int64]bool) }
// onChildWindowMoved 子窗口移动事件处理
func (wss *WindowSnapService) onChildWindowMoved(window *application.WebviewWindow, windowInfo *models.WindowInfo) {
if !wss.snapEnabled {
return return
} }
mainPos, _ := wss.getWindowPosition(wss.mainWindow) wss.mu.Lock()
defer wss.mu.Unlock()
// 检查主窗口是否移动了 // 获取当前位置
mainWindowMoved := mainPos.X != wss.lastMainWindowPos.X || mainPos.Y != wss.lastMainWindowPos.Y x, y := window.Position()
if mainWindowMoved { currentPos := models.WindowPosition{X: x, Y: y}
wss.lastMainWindowPos = mainPos
// 主窗口移动了，标记所有吸附的窗口为变化 // 检查是否真的移动了（避免无效触发）
for documentID, windowInfo := range wss.managedWindows { if currentPos.X == windowInfo.LastPos.X && currentPos.Y == windowInfo.LastPos.Y {
if windowInfo.IsSnapped { return
wss.changedWindows[documentID] = true
}
}
} }
for documentID, windowInfo := range wss.managedWindows { // 保存上次移动时间用于防抖检测
currentPos, _ := wss.getWindowPosition(windowInfo.Window) lastMoveTime := windowInfo.MoveTime
windowInfo.MoveTime = time.Now()
// 检查窗口是否移动了 if windowInfo.IsSnapped {
hasMoved := currentPos.X != windowInfo.LastPos.X || currentPos.Y != windowInfo.LastPos.Y // 已吸附窗口：检查是否被用户拖拽解除吸附
if hasMoved { wss.handleSnappedWindow(window, windowInfo, currentPos)
windowInfo.MoveTime = time.Now() // 对于已吸附窗口，总是更新为当前位置
windowInfo.LastPos = currentPos
} else {
// 未吸附窗口：检查是否应该吸附
isSnapped := wss.handleUnsnappedWindow(window, windowInfo, currentPos, lastMoveTime)
if !isSnapped {
// 如果没有吸附，更新为当前位置
windowInfo.LastPos = currentPos windowInfo.LastPos = currentPos
wss.changedWindows[documentID] = true
} }
// 如果成功吸附，位置已在handleUnsnappedWindow中更新
// 性能优化：只处理变化的窗口或进行完整检查时
if !fullCheck && !wss.changedWindows[documentID] {
continue
}
if windowInfo.IsSnapped {
// 窗口已吸附，检查是否需要更新位置或解除吸附
wss.handleSnappedWindow(windowInfo, mainPos, currentPos)
} else {
// 窗口未吸附，检查是否应该吸附
wss.handleUnsnappedWindow(windowInfo)
}
// 处理完成后清除变化标记
delete(wss.changedWindows, documentID)
} }
} }
// isMainWindowAvailable 检查主窗口是否可用 // updateSnappedWindowPosition 更新已吸附窗口的位置
func (wss *WindowSnapService) isMainWindowAvailable() bool { func (wss *WindowSnapService) updateSnappedWindowPosition(windowInfo *models.WindowInfo) {
if wss.mainWindow == nil { // 计算新的目标位置（基于主窗口新位置）
return false expectedX := wss.lastMainWindowPos.X + windowInfo.SnapOffset.X
expectedY := wss.lastMainWindowPos.Y + windowInfo.SnapOffset.Y
// 查找对应的window对象并移动
if window, exists := wss.windowRefs[windowInfo.DocumentID]; exists {
window.SetPosition(expectedX, expectedY)
} }
// 检查主窗口是否可见和正常状态 windowInfo.LastPos = models.WindowPosition{X: expectedX, Y: expectedY}
return wss.mainWindow.IsVisible()
} }
// handleSnappedWindow 处理已吸附的窗口 // handleSnappedWindow 处理已吸附窗口的移动
func (wss *WindowSnapService) handleSnappedWindow(windowInfo *SnapWindowInfo, mainPos models.WindowPosition, currentPos models.WindowPosition) { func (wss *WindowSnapService) handleSnappedWindow(window *application.WebviewWindow, windowInfo *models.WindowInfo, currentPos models.WindowPosition) {
// 计算预期位置基于主窗口的新位置 // 计算预期位置
expectedX := mainPos.X + windowInfo.SnapOffset.X expectedX := wss.lastMainWindowPos.X + windowInfo.SnapOffset.X
expectedY := mainPos.Y + windowInfo.SnapOffset.Y expectedY := wss.lastMainWindowPos.Y + windowInfo.SnapOffset.Y
// 计算当前位置与预期位置的距离 // 计算实际位置与预期位置的距离
distanceX := math.Abs(float64(currentPos.X - expectedX)) distanceX := math.Abs(float64(currentPos.X - expectedX))
distanceY := math.Abs(float64(currentPos.Y - expectedY)) distanceY := math.Abs(float64(currentPos.Y - expectedY))
maxDistance := math.Max(distanceX, distanceY) maxDistance := math.Max(distanceX, distanceY)
// 检测是否为用户主动拖拽：如果窗口移动幅度超过阈值且是最近移动的 // 用户拖拽检测：距离超过阈值且移动很快
userDragThreshold := float64(wss.snapThreshold) userDragThreshold := float64(wss.calculateAdaptiveThreshold())
isUserDrag := maxDistance > userDragThreshold && time.Since(windowInfo.MoveTime) < 100*time.Millisecond isUserDrag := maxDistance > userDragThreshold && time.Since(windowInfo.MoveTime) < 50*time.Millisecond
if isUserDrag { if isUserDrag {
// 用户主动拖拽，立即解除吸附 // 用户主动拖拽，解除吸附
windowInfo.IsSnapped = false windowInfo.IsSnapped = false
windowInfo.SnapEdge = models.SnapEdgeNone windowInfo.SnapEdge = models.SnapEdgeNone
return
}
// 对于主窗口移动导致的位置变化，立即跟随且不解除吸附
if maxDistance > 0 {
// 直接调整到预期位置，不使用平滑移动以提高响应速度
windowInfo.Window.SetPosition(expectedX, expectedY)
windowInfo.LastPos = models.WindowPosition{X: expectedX, Y: expectedY}
} }
} }
// handleUnsnappedWindow 处理未吸附的窗口 // handleUnsnappedWindow 处理未吸附窗口的移动，返回是否成功吸附
func (wss *WindowSnapService) handleUnsnappedWindow(windowInfo *SnapWindowInfo) { func (wss *WindowSnapService) handleUnsnappedWindow(window *application.WebviewWindow, windowInfo *models.WindowInfo, currentPos models.WindowPosition, lastMoveTime time.Time) bool {
// 检查是否应该吸附到主窗口 // 检查是否应该吸附
should, snapEdge := wss.shouldSnapToMainWindow(windowInfo) should, snapEdge := wss.shouldSnapToMainWindow(window, windowInfo, currentPos, lastMoveTime)
if should { if should {
// 获取主窗口位置用于计算偏移量
mainPos, _ := wss.getWindowPosition(wss.mainWindow)
// 设置吸附状态 // 设置吸附状态
windowInfo.IsSnapped = true windowInfo.IsSnapped = true
windowInfo.SnapEdge = snapEdge windowInfo.SnapEdge = snapEdge
// 执行即时吸附，产生明显的吸附效果 // 执行吸附移动
wss.snapWindowToMainWindow(windowInfo, snapEdge) targetPos := wss.calculateSnapPosition(snapEdge, currentPos, window)
window.SetPosition(targetPos.X, targetPos.Y)
// 重新获取吸附后的位置来计算偏移量 // 计算并保存偏移量
newPos, _ := wss.getWindowPosition(windowInfo.Window) windowInfo.SnapOffset.X = targetPos.X - wss.lastMainWindowPos.X
windowInfo.SnapOffset.X = newPos.X - mainPos.X windowInfo.SnapOffset.Y = targetPos.Y - wss.lastMainWindowPos.Y
windowInfo.SnapOffset.Y = newPos.Y - mainPos.Y
windowInfo.LastPos = newPos // 更新位置为吸附后的位置
windowInfo.LastPos = targetPos
return true
} }
return false
} }
// getWindowPosition 获取窗口的位置 // getWindowPosition 获取窗口的位置
@@ -331,269 +324,160 @@ func (wss *WindowSnapService) getWindowPosition(window *application.WebviewWindo
return models.WindowPosition{X: x, Y: y}, true return models.WindowPosition{X: x, Y: y}, true
} }
// shouldSnapToMainWindow 检查窗口是否应该吸附到主窗口（支持角落吸附） // shouldSnapToMainWindow 优化版吸附检测
func (wss *WindowSnapService) shouldSnapToMainWindow(windowInfo *SnapWindowInfo) (bool, models.SnapEdge) { func (wss *WindowSnapService) shouldSnapToMainWindow(window *application.WebviewWindow, windowInfo *models.WindowInfo, currentPos models.WindowPosition, lastMoveTime time.Time) (bool, models.SnapEdge) {
// 降低防抖时间，提高吸附响应速度 // 防抖：移动太快时不检测，
if time.Since(windowInfo.MoveTime) < 50*time.Millisecond { timeSinceLastMove := time.Since(lastMoveTime)
if timeSinceLastMove < 30*time.Millisecond && timeSinceLastMove > 0 {
return false, models.SnapEdgeNone return false, models.SnapEdgeNone
} }
// 获取两个窗口的位置 // 使用缓存的主窗口位置和尺寸
mainPos, _ := wss.getWindowPosition(wss.mainWindow) if wss.lastMainWindowSize[0] == 0 || wss.lastMainWindowSize[1] == 0 {
windowPos, _ := wss.getWindowPosition(windowInfo.Window) // 主窗口缓存未初始化，立即更新
wss.updateMainWindowCache()
}
// 获取主窗口尺寸 mainPos := wss.lastMainWindowPos
mainWidth, mainHeight := wss.mainWindow.Size() mainWidth := wss.lastMainWindowSize[0]
mainHeight := wss.lastMainWindowSize[1]
// 获取子窗口尺寸 // 获取子窗口尺寸
windowWidth, windowHeight := windowInfo.Window.Size() windowWidth, windowHeight := window.Size()
// 计算各个边缘的距离 // 自适应阈值计算
threshold := float64(wss.snapThreshold) threshold := float64(wss.calculateAdaptiveThreshold())
cornerThreshold := threshold * 1.5 // 角落吸附需要更大的阈值 cornerThreshold := threshold * 1.5
// 主窗口的四个边界 // 计算边界
mainLeft := mainPos.X mainLeft, mainTop := mainPos.X, mainPos.Y
mainTop := mainPos.Y mainRight, mainBottom := mainPos.X+mainWidth, mainPos.Y+mainHeight
mainRight := mainPos.X + mainWidth
mainBottom := mainPos.Y + mainHeight
// 子窗口的四个边界 windowLeft, windowTop := currentPos.X, currentPos.Y
windowLeft := windowPos.X windowRight, windowBottom := currentPos.X+windowWidth, currentPos.Y+windowHeight
windowTop := windowPos.Y
windowRight := windowPos.X + windowWidth
windowBottom := windowPos.Y + windowHeight
// 存储每个边缘的吸附信息 // 简化的距离计算结构
type snapCandidate struct { type snapCheck struct {
edge models.SnapEdge edge models.SnapEdge
distance float64 distance float64
overlap float64 // 重叠度，用于优先级判断 priority int // 1=角落, 2=边缘
isCorner bool // 是否为角落吸附
} }
var candidates []snapCandidate var bestSnap *snapCheck
// ==== 检查角落吸附（优先级最高） ==== // 检查角落吸附（优先级1）
cornerChecks := []struct {
// 1. 右上角 (SnapEdgeTopRight) edge models.SnapEdge
distToTopRight := math.Sqrt(math.Pow(float64(mainRight-windowLeft), 2) + math.Pow(float64(mainTop-windowBottom), 2)) dx int
if distToTopRight <= cornerThreshold { dy int
// 检查是否接近右上角区域 }{
horizDist := math.Abs(float64(mainRight - windowLeft)) {models.SnapEdgeTopRight, mainRight - windowLeft, mainTop - windowBottom},
vertDist := math.Abs(float64(mainTop - windowBottom)) {models.SnapEdgeBottomRight, mainRight - windowLeft, mainBottom - windowTop},
if horizDist <= cornerThreshold && vertDist <= cornerThreshold { {models.SnapEdgeBottomLeft, mainLeft - windowRight, mainBottom - windowTop},
candidates = append(candidates, snapCandidate{models.SnapEdgeTopRight, distToTopRight, 100, true}) {models.SnapEdgeTopLeft, mainLeft - windowRight, mainTop - windowBottom},
}
} }
// 2. 右下角 (SnapEdgeBottomRight) for _, check := range cornerChecks {
distToBottomRight := math.Sqrt(math.Pow(float64(mainRight-windowLeft), 2) + math.Pow(float64(mainBottom-windowTop), 2)) dist := math.Sqrt(float64(check.dx*check.dx + check.dy*check.dy))
if distToBottomRight <= cornerThreshold { if dist <= cornerThreshold {
horizDist := math.Abs(float64(mainRight - windowLeft)) if bestSnap == nil || dist < bestSnap.distance {
vertDist := math.Abs(float64(mainBottom - windowTop)) bestSnap = &snapCheck{check.edge, dist, 1}
if horizDist <= cornerThreshold && vertDist <= cornerThreshold {
candidates = append(candidates, snapCandidate{models.SnapEdgeBottomRight, distToBottomRight, 100, true})
}
}
// 3. 左下角 (SnapEdgeBottomLeft)
distToBottomLeft := math.Sqrt(math.Pow(float64(mainLeft-windowRight), 2) + math.Pow(float64(mainBottom-windowTop), 2))
if distToBottomLeft <= cornerThreshold {
horizDist := math.Abs(float64(mainLeft - windowRight))
vertDist := math.Abs(float64(mainBottom - windowTop))
if horizDist <= cornerThreshold && vertDist <= cornerThreshold {
candidates = append(candidates, snapCandidate{models.SnapEdgeBottomLeft, distToBottomLeft, 100, true})
}
}
// 4. 左上角 (SnapEdgeTopLeft)
distToTopLeft := math.Sqrt(math.Pow(float64(mainLeft-windowRight), 2) + math.Pow(float64(mainTop-windowBottom), 2))
if distToTopLeft <= cornerThreshold {
horizDist := math.Abs(float64(mainLeft - windowRight))
vertDist := math.Abs(float64(mainTop - windowBottom))
if horizDist <= cornerThreshold && vertDist <= cornerThreshold {
candidates = append(candidates, snapCandidate{models.SnapEdgeTopLeft, distToTopLeft, 100, true})
}
}
// ==== 检查边缘吸附（只在没有角落吸附时检查） ====
if len(candidates) == 0 {
// 1. 吸附到主窗口右侧
distToRight := math.Abs(float64(mainRight - windowLeft))
if distToRight <= threshold {
// 计算垂直重叠
overlapTop := math.Max(float64(mainTop), float64(windowTop))
overlapBottom := math.Min(float64(mainBottom), float64(windowBottom))
verticalOverlap := math.Max(0, overlapBottom-overlapTop)
candidates = append(candidates, snapCandidate{models.SnapEdgeRight, distToRight, verticalOverlap, false})
}
// 2. 吸附到主窗口左侧
distToLeft := math.Abs(float64(mainLeft - windowRight))
if distToLeft <= threshold {
// 计算垂直重叠
overlapTop := math.Max(float64(mainTop), float64(windowTop))
overlapBottom := math.Min(float64(mainBottom), float64(windowBottom))
verticalOverlap := math.Max(0, overlapBottom-overlapTop)
candidates = append(candidates, snapCandidate{models.SnapEdgeLeft, distToLeft, verticalOverlap, false})
}
// 3. 吸附到主窗口底部
distToBottom := math.Abs(float64(mainBottom - windowTop))
if distToBottom <= threshold {
// 计算水平重叠
overlapLeft := math.Max(float64(mainLeft), float64(windowLeft))
overlapRight := math.Min(float64(mainRight), float64(windowRight))
horizontalOverlap := math.Max(0, overlapRight-overlapLeft)
candidates = append(candidates, snapCandidate{models.SnapEdgeBottom, distToBottom, horizontalOverlap, false})
}
// 4. 吸附到主窗口顶部
distToTop := math.Abs(float64(mainTop - windowBottom))
if distToTop <= threshold {
// 计算水平重叠
overlapLeft := math.Max(float64(mainLeft), float64(windowLeft))
overlapRight := math.Min(float64(mainRight), float64(windowRight))
horizontalOverlap := math.Max(0, overlapRight-overlapLeft)
candidates = append(candidates, snapCandidate{models.SnapEdgeTop, distToTop, horizontalOverlap, false})
}
}
// 如果没有候选，不吸附
if len(candidates) == 0 {
return false, models.SnapEdgeNone
}
// 选择最佳吸附位置：角落吸附优先，其次考虑重叠度，最后考虑距离
bestCandidate := candidates[0]
for _, candidate := range candidates[1:] {
// 角落吸附优先级最高
if candidate.isCorner && !bestCandidate.isCorner {
bestCandidate = candidate
} else if bestCandidate.isCorner && !candidate.isCorner {
// 继续使用当前的角落吸附
continue
} else {
// 同类型的吸附，比较重叠度和距离
if math.Abs(candidate.overlap-bestCandidate.overlap) < 10 {
if candidate.distance < bestCandidate.distance {
bestCandidate = candidate
}
} else if candidate.overlap > bestCandidate.overlap {
// 重叠度更高的优先
bestCandidate = candidate
} }
} }
} }
return true, bestCandidate.edge // 如果没有角落吸附，检查边缘吸附（优先级2）
if bestSnap == nil {
edgeChecks := []struct {
edge models.SnapEdge
distance float64
}{
{models.SnapEdgeRight, math.Abs(float64(mainRight - windowLeft))},
{models.SnapEdgeLeft, math.Abs(float64(mainLeft - windowRight))},
{models.SnapEdgeBottom, math.Abs(float64(mainBottom - windowTop))},
{models.SnapEdgeTop, math.Abs(float64(mainTop - windowBottom))},
}
for _, check := range edgeChecks {
if check.distance <= threshold {
if bestSnap == nil || check.distance < bestSnap.distance {
bestSnap = &snapCheck{check.edge, check.distance, 2}
}
}
}
}
if bestSnap == nil {
return false, models.SnapEdgeNone
}
return true, bestSnap.edge
} }
// snapWindowToMainWindow 将窗口精确吸附到主窗口边缘（支持角落吸附） // calculateSnapPosition 计算吸附目标位置
func (wss *WindowSnapService) snapWindowToMainWindow(windowInfo *SnapWindowInfo, snapEdge models.SnapEdge) { func (wss *WindowSnapService) calculateSnapPosition(snapEdge models.SnapEdge, currentPos models.WindowPosition, window *application.WebviewWindow) models.WindowPosition {
// 获取主窗口位置和尺寸 // 使用缓存的主窗口信息
mainPos, _ := wss.getWindowPosition(wss.mainWindow) mainPos := wss.lastMainWindowPos
mainWidth, mainHeight := wss.mainWindow.Size() mainWidth := wss.lastMainWindowSize[0]
mainHeight := wss.lastMainWindowSize[1]
// 获取子窗口位置和尺寸 // 获取子窗口尺寸
windowPos, _ := wss.getWindowPosition(windowInfo.Window) windowWidth, windowHeight := window.Size()
windowWidth, windowHeight := windowInfo.Window.Size()
// 计算目标位置
var targetX, targetY int
switch snapEdge { switch snapEdge {
case models.SnapEdgeRight: case models.SnapEdgeRight:
// 吸附到主窗口右侧 return models.WindowPosition{
targetX = mainPos.X + mainWidth X: mainPos.X + mainWidth,
targetY = windowPos.Y // 保持当前 Y 位置 Y: currentPos.Y, // 保持当前Y位置
// 如果超出主窗口范围，调整到边界
if targetY < mainPos.Y {
targetY = mainPos.Y
} else if targetY+windowHeight > mainPos.Y+mainHeight {
targetY = mainPos.Y + mainHeight - windowHeight
} }
case models.SnapEdgeLeft: case models.SnapEdgeLeft:
// 吸附到主窗口左侧 return models.WindowPosition{
targetX = mainPos.X - windowWidth X: mainPos.X - windowWidth,
targetY = windowPos.Y // 保持当前 Y 位置 Y: currentPos.Y,
// 如果超出主窗口范围，调整到边界
if targetY < mainPos.Y {
targetY = mainPos.Y
} else if targetY+windowHeight > mainPos.Y+mainHeight {
targetY = mainPos.Y + mainHeight - windowHeight
} }
case models.SnapEdgeBottom: case models.SnapEdgeBottom:
// 吸附到主窗口底部 return models.WindowPosition{
targetX = windowPos.X // 保持当前 X 位置 X: currentPos.X,
targetY = mainPos.Y + mainHeight Y: mainPos.Y + mainHeight,
// 如果超出主窗口范围，调整到边界
if targetX < mainPos.X {
targetX = mainPos.X
} else if targetX+windowWidth > mainPos.X+mainWidth {
targetX = mainPos.X + mainWidth - windowWidth
} }
case models.SnapEdgeTop: case models.SnapEdgeTop:
// 吸附到主窗口顶部 return models.WindowPosition{
targetX = windowPos.X // 保持当前 X 位置 X: currentPos.X,
targetY = mainPos.Y - windowHeight Y: mainPos.Y - windowHeight,
// 如果超出主窗口范围，调整到边界
if targetX < mainPos.X {
targetX = mainPos.X
} else if targetX+windowWidth > mainPos.X+mainWidth {
targetX = mainPos.X + mainWidth - windowWidth
} }
// ==== 角落吸附 ====
case models.SnapEdgeTopRight: case models.SnapEdgeTopRight:
// 吸附到右上角 return models.WindowPosition{
targetX = mainPos.X + mainWidth X: mainPos.X + mainWidth,
targetY = mainPos.Y - windowHeight Y: mainPos.Y - windowHeight,
}
case models.SnapEdgeBottomRight: case models.SnapEdgeBottomRight:
// 吸附到右下角 return models.WindowPosition{
targetX = mainPos.X + mainWidth X: mainPos.X + mainWidth,
targetY = mainPos.Y + mainHeight Y: mainPos.Y + mainHeight,
}
case models.SnapEdgeBottomLeft: case models.SnapEdgeBottomLeft:
// 吸附到左下角 return models.WindowPosition{
targetX = mainPos.X - windowWidth X: mainPos.X - windowWidth,
targetY = mainPos.Y + mainHeight Y: mainPos.Y + mainHeight,
}
case models.SnapEdgeTopLeft: case models.SnapEdgeTopLeft:
// 吸附到左上角 return models.WindowPosition{
targetX = mainPos.X - windowWidth X: mainPos.X - windowWidth,
targetY = mainPos.Y - windowHeight Y: mainPos.Y - windowHeight,
}
default:
// 不应该到达这里
return
} }
// 直接移动到目标位置，不使用平滑过渡以产生明显的吸附效果 return currentPos
windowInfo.Window.SetPosition(targetX, targetY)
// 更新窗口信息
windowInfo.SnapEdge = snapEdge
windowInfo.LastPos = models.WindowPosition{X: targetX, Y: targetY}
} }
// Cleanup 清理资源 // Cleanup 清理资源
func (wss *WindowSnapService) Cleanup() { func (wss *WindowSnapService) Cleanup() {
// 如果有取消函数，调用它来停止所有goroutine wss.mu.Lock()
if wss.cancel != nil { defer wss.mu.Unlock()
wss.cancel()
}
// 停止定时器 // 清空管理的窗口
if wss.snapTicker != nil { wss.managedWindows = make(map[int64]*models.WindowInfo)
wss.snapTicker.Stop() wss.windowRefs = make(map[int64]*application.WebviewWindow)
wss.snapTicker = nil
}
} }
// ServiceShutdown 实现服务关闭接口 // ServiceShutdown 实现服务关闭接口