604 lines
19 KiB
Go
604 lines
19 KiB
Go
package services
|
||
|
||
import (
|
||
"context"
|
||
"math"
|
||
"sync"
|
||
"time"
|
||
"voidraft/internal/models"
|
||
|
||
"github.com/wailsapp/wails/v3/pkg/application"
|
||
"github.com/wailsapp/wails/v3/pkg/services/log"
|
||
)
|
||
|
||
// WindowSnapService 窗口吸附服务
|
||
type WindowSnapService struct {
|
||
logger *log.LogService
|
||
configService *ConfigService
|
||
app *application.App
|
||
mainWindow *application.WebviewWindow
|
||
mu sync.RWMutex
|
||
|
||
// 吸附配置
|
||
snapThreshold int // 吸附触发的阈值距离(像素)
|
||
snapEnabled bool // 是否启用窗口吸附功能
|
||
|
||
// 定时器控制
|
||
snapTicker *time.Ticker
|
||
ctx context.Context
|
||
cancel context.CancelFunc
|
||
|
||
// 性能优化相关
|
||
lastMainWindowPos models.WindowPosition // 缓存主窗口上次位置
|
||
changedWindows map[int64]bool // 记录哪些窗口发生了变化
|
||
skipFrames int // 跳帧计数器，用于降低检测频率
|
||
|
||
// 监听的窗口列表
|
||
managedWindows map[int64]*SnapWindowInfo // documentID -> SnapWindowInfo
|
||
}
|
||
|
||
// 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 创建新的窗口吸附服务实例
|
||
func NewWindowSnapService(logger *log.LogService, configService *ConfigService) *WindowSnapService {
|
||
if logger == nil {
|
||
logger = log.New()
|
||
}
|
||
|
||
// 从配置获取窗口吸附设置
|
||
config, err := configService.GetConfig()
|
||
snapEnabled := true // 默认启用
|
||
snapThreshold := 15 // 默认阈值
|
||
|
||
if err == nil {
|
||
snapEnabled = config.General.EnableWindowSnap
|
||
snapThreshold = config.General.SnapThreshold
|
||
}
|
||
|
||
return &WindowSnapService{
|
||
logger: logger,
|
||
configService: configService,
|
||
snapThreshold: snapThreshold,
|
||
snapEnabled: snapEnabled,
|
||
managedWindows: make(map[int64]*SnapWindowInfo),
|
||
changedWindows: make(map[int64]bool),
|
||
skipFrames: 0,
|
||
}
|
||
}
|
||
|
||
// SetAppReferences 设置应用和主窗口引用
|
||
func (wss *WindowSnapService) SetAppReferences(app *application.App, mainWindow *application.WebviewWindow) {
|
||
wss.app = app
|
||
wss.mainWindow = mainWindow
|
||
|
||
// 初始化上下文，用于控制goroutine的生命周期
|
||
wss.ctx, wss.cancel = context.WithCancel(context.Background())
|
||
|
||
// 启动窗口吸附监听器
|
||
wss.StartWindowSnapMonitor()
|
||
}
|
||
|
||
// RegisterWindow 注册需要吸附管理的窗口
|
||
func (wss *WindowSnapService) RegisterWindow(documentID int64, window *application.WebviewWindow, title string) {
|
||
wss.mu.Lock()
|
||
defer wss.mu.Unlock()
|
||
|
||
wss.managedWindows[documentID] = &SnapWindowInfo{
|
||
Window: window,
|
||
DocumentID: documentID,
|
||
Title: title,
|
||
IsSnapped: false,
|
||
SnapOffset: models.SnapPosition{X: 0, Y: 0},
|
||
SnapEdge: models.SnapEdgeNone,
|
||
LastPos: models.WindowPosition{X: 0, Y: 0},
|
||
MoveTime: time.Now(),
|
||
}
|
||
}
|
||
|
||
// UnregisterWindow 取消注册窗口
|
||
func (wss *WindowSnapService) UnregisterWindow(documentID int64) {
|
||
wss.mu.Lock()
|
||
defer wss.mu.Unlock()
|
||
|
||
delete(wss.managedWindows, documentID)
|
||
delete(wss.changedWindows, documentID)
|
||
}
|
||
|
||
// SetSnapEnabled 设置是否启用窗口吸附
|
||
func (wss *WindowSnapService) SetSnapEnabled(enabled bool) {
|
||
wss.mu.Lock()
|
||
defer wss.mu.Unlock()
|
||
|
||
if wss.snapEnabled == enabled {
|
||
return
|
||
}
|
||
|
||
wss.snapEnabled = enabled
|
||
|
||
// 如果禁用吸附，解除所有吸附窗口
|
||
if !enabled {
|
||
for _, windowInfo := range wss.managedWindows {
|
||
if windowInfo.IsSnapped {
|
||
windowInfo.IsSnapped = false
|
||
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 设置窗口吸附阈值
|
||
func (wss *WindowSnapService) SetSnapThreshold(threshold int) {
|
||
wss.mu.Lock()
|
||
defer wss.mu.Unlock()
|
||
|
||
if threshold <= 0 || wss.snapThreshold == threshold {
|
||
return
|
||
}
|
||
|
||
wss.snapThreshold = threshold
|
||
}
|
||
|
||
// OnWindowSnapConfigChanged 处理窗口吸附配置变更
|
||
func (wss *WindowSnapService) OnWindowSnapConfigChanged(enabled bool, threshold int) error {
|
||
wss.SetSnapEnabled(enabled)
|
||
wss.SetSnapThreshold(threshold)
|
||
return nil
|
||
}
|
||
|
||
// StartWindowSnapMonitor 启动窗口吸附监听器
|
||
func (wss *WindowSnapService) StartWindowSnapMonitor() {
|
||
// 如果定时器已存在，先停止它
|
||
if wss.snapTicker != nil {
|
||
wss.snapTicker.Stop()
|
||
}
|
||
|
||
// 只有在吸附功能启用时才启动监听器
|
||
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 检测并应用窗口吸附（性能优化版本）
|
||
func (wss *WindowSnapService) checkAndApplySnapping() {
|
||
if !wss.snapEnabled {
|
||
return
|
||
}
|
||
|
||
// 性能优化：每3帧执行一次完整检测，其他时间只处理变化的窗口
|
||
wss.skipFrames++
|
||
fullCheck := wss.skipFrames%3 == 0
|
||
|
||
wss.mu.Lock()
|
||
defer wss.mu.Unlock()
|
||
|
||
// 检查主窗口是否存在且可见
|
||
if wss.mainWindow == nil || !wss.isMainWindowAvailable() {
|
||
// 主窗口不可用，解除所有吸附
|
||
for _, windowInfo := range wss.managedWindows {
|
||
if windowInfo.IsSnapped {
|
||
windowInfo.IsSnapped = false
|
||
windowInfo.SnapEdge = models.SnapEdgeNone
|
||
}
|
||
}
|
||
// 清空变化记录
|
||
wss.changedWindows = make(map[int64]bool)
|
||
return
|
||
}
|
||
|
||
mainPos, _ := wss.getWindowPosition(wss.mainWindow)
|
||
|
||
// 检查主窗口是否移动了
|
||
mainWindowMoved := mainPos.X != wss.lastMainWindowPos.X || mainPos.Y != wss.lastMainWindowPos.Y
|
||
if mainWindowMoved {
|
||
wss.lastMainWindowPos = mainPos
|
||
// 主窗口移动了，标记所有吸附的窗口为变化
|
||
for documentID, windowInfo := range wss.managedWindows {
|
||
if windowInfo.IsSnapped {
|
||
wss.changedWindows[documentID] = true
|
||
}
|
||
}
|
||
}
|
||
|
||
for documentID, windowInfo := range wss.managedWindows {
|
||
currentPos, _ := wss.getWindowPosition(windowInfo.Window)
|
||
|
||
// 检查窗口是否移动了
|
||
hasMoved := currentPos.X != windowInfo.LastPos.X || currentPos.Y != windowInfo.LastPos.Y
|
||
if hasMoved {
|
||
windowInfo.MoveTime = time.Now()
|
||
windowInfo.LastPos = currentPos
|
||
wss.changedWindows[documentID] = true
|
||
}
|
||
|
||
// 性能优化：只处理变化的窗口或进行完整检查时
|
||
if !fullCheck && !wss.changedWindows[documentID] {
|
||
continue
|
||
}
|
||
|
||
if windowInfo.IsSnapped {
|
||
// 窗口已吸附，检查是否需要更新位置或解除吸附
|
||
wss.handleSnappedWindow(windowInfo, mainPos, currentPos)
|
||
} else {
|
||
// 窗口未吸附，检查是否应该吸附
|
||
wss.handleUnsnappedWindow(windowInfo)
|
||
}
|
||
|
||
// 处理完成后清除变化标记
|
||
delete(wss.changedWindows, documentID)
|
||
}
|
||
}
|
||
|
||
// isMainWindowAvailable 检查主窗口是否可用
|
||
func (wss *WindowSnapService) isMainWindowAvailable() bool {
|
||
if wss.mainWindow == nil {
|
||
return false
|
||
}
|
||
|
||
// 检查主窗口是否可见和正常状态
|
||
return wss.mainWindow.IsVisible()
|
||
}
|
||
|
||
// handleSnappedWindow 处理已吸附的窗口
|
||
func (wss *WindowSnapService) handleSnappedWindow(windowInfo *SnapWindowInfo, mainPos models.WindowPosition, currentPos models.WindowPosition) {
|
||
// 计算预期位置基于主窗口的新位置
|
||
expectedX := mainPos.X + windowInfo.SnapOffset.X
|
||
expectedY := mainPos.Y + windowInfo.SnapOffset.Y
|
||
|
||
// 计算当前位置与预期位置的距离
|
||
distanceX := math.Abs(float64(currentPos.X - expectedX))
|
||
distanceY := math.Abs(float64(currentPos.Y - expectedY))
|
||
maxDistance := math.Max(distanceX, distanceY)
|
||
|
||
// 检测是否为用户主动拖拽：如果窗口移动幅度超过阈值且是最近移动的
|
||
userDragThreshold := float64(wss.snapThreshold)
|
||
isUserDrag := maxDistance > userDragThreshold && time.Since(windowInfo.MoveTime) < 100*time.Millisecond
|
||
|
||
if isUserDrag {
|
||
// 用户主动拖拽，立即解除吸附
|
||
windowInfo.IsSnapped = false
|
||
windowInfo.SnapEdge = models.SnapEdgeNone
|
||
return
|
||
}
|
||
|
||
// 对于主窗口移动导致的位置变化，立即跟随且不解除吸附
|
||
if maxDistance > 0 {
|
||
// 直接调整到预期位置，不使用平滑移动以提高响应速度
|
||
windowInfo.Window.SetPosition(expectedX, expectedY)
|
||
windowInfo.LastPos = models.WindowPosition{X: expectedX, Y: expectedY}
|
||
}
|
||
}
|
||
|
||
// handleUnsnappedWindow 处理未吸附的窗口
|
||
func (wss *WindowSnapService) handleUnsnappedWindow(windowInfo *SnapWindowInfo) {
|
||
// 检查是否应该吸附到主窗口
|
||
should, snapEdge := wss.shouldSnapToMainWindow(windowInfo)
|
||
if should {
|
||
// 获取主窗口位置用于计算偏移量
|
||
mainPos, _ := wss.getWindowPosition(wss.mainWindow)
|
||
|
||
// 设置吸附状态
|
||
windowInfo.IsSnapped = true
|
||
windowInfo.SnapEdge = snapEdge
|
||
|
||
// 执行即时吸附，产生明显的吸附效果
|
||
wss.snapWindowToMainWindow(windowInfo, snapEdge)
|
||
|
||
// 重新获取吸附后的位置来计算偏移量
|
||
newPos, _ := wss.getWindowPosition(windowInfo.Window)
|
||
windowInfo.SnapOffset.X = newPos.X - mainPos.X
|
||
windowInfo.SnapOffset.Y = newPos.Y - mainPos.Y
|
||
windowInfo.LastPos = newPos
|
||
}
|
||
}
|
||
|
||
// getWindowPosition 获取窗口的位置
|
||
func (wss *WindowSnapService) getWindowPosition(window *application.WebviewWindow) (models.WindowPosition, bool) {
|
||
x, y := window.Position()
|
||
return models.WindowPosition{X: x, Y: y}, true
|
||
}
|
||
|
||
// shouldSnapToMainWindow 检查窗口是否应该吸附到主窗口（支持角落吸附）
|
||
func (wss *WindowSnapService) shouldSnapToMainWindow(windowInfo *SnapWindowInfo) (bool, models.SnapEdge) {
|
||
// 降低防抖时间，提高吸附响应速度
|
||
if time.Since(windowInfo.MoveTime) < 50*time.Millisecond {
|
||
return false, models.SnapEdgeNone
|
||
}
|
||
|
||
// 获取两个窗口的位置
|
||
mainPos, _ := wss.getWindowPosition(wss.mainWindow)
|
||
windowPos, _ := wss.getWindowPosition(windowInfo.Window)
|
||
|
||
// 获取主窗口尺寸
|
||
mainWidth, mainHeight := wss.mainWindow.Size()
|
||
|
||
// 获取子窗口尺寸
|
||
windowWidth, windowHeight := windowInfo.Window.Size()
|
||
|
||
// 计算各个边缘的距离
|
||
threshold := float64(wss.snapThreshold)
|
||
cornerThreshold := threshold * 1.5 // 角落吸附需要更大的阈值
|
||
|
||
// 主窗口的四个边界
|
||
mainLeft := mainPos.X
|
||
mainTop := mainPos.Y
|
||
mainRight := mainPos.X + mainWidth
|
||
mainBottom := mainPos.Y + mainHeight
|
||
|
||
// 子窗口的四个边界
|
||
windowLeft := windowPos.X
|
||
windowTop := windowPos.Y
|
||
windowRight := windowPos.X + windowWidth
|
||
windowBottom := windowPos.Y + windowHeight
|
||
|
||
// 存储每个边缘的吸附信息
|
||
type snapCandidate struct {
|
||
edge models.SnapEdge
|
||
distance float64
|
||
overlap float64 // 重叠度，用于优先级判断
|
||
isCorner bool // 是否为角落吸附
|
||
}
|
||
|
||
var candidates []snapCandidate
|
||
|
||
// ==== 检查角落吸附（优先级最高） ====
|
||
|
||
// 1. 右上角 (SnapEdgeTopRight)
|
||
distToTopRight := math.Sqrt(math.Pow(float64(mainRight-windowLeft), 2) + math.Pow(float64(mainTop-windowBottom), 2))
|
||
if distToTopRight <= cornerThreshold {
|
||
// 检查是否接近右上角区域
|
||
horizDist := math.Abs(float64(mainRight - windowLeft))
|
||
vertDist := math.Abs(float64(mainTop - windowBottom))
|
||
if horizDist <= cornerThreshold && vertDist <= cornerThreshold {
|
||
candidates = append(candidates, snapCandidate{models.SnapEdgeTopRight, distToTopRight, 100, true})
|
||
}
|
||
}
|
||
|
||
// 2. 右下角 (SnapEdgeBottomRight)
|
||
distToBottomRight := math.Sqrt(math.Pow(float64(mainRight-windowLeft), 2) + math.Pow(float64(mainBottom-windowTop), 2))
|
||
if distToBottomRight <= cornerThreshold {
|
||
horizDist := math.Abs(float64(mainRight - windowLeft))
|
||
vertDist := math.Abs(float64(mainBottom - windowTop))
|
||
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
|
||
}
|
||
|
||
// snapWindowToMainWindow 将窗口精确吸附到主窗口边缘（支持角落吸附）
|
||
func (wss *WindowSnapService) snapWindowToMainWindow(windowInfo *SnapWindowInfo, snapEdge models.SnapEdge) {
|
||
// 获取主窗口位置和尺寸
|
||
mainPos, _ := wss.getWindowPosition(wss.mainWindow)
|
||
mainWidth, mainHeight := wss.mainWindow.Size()
|
||
|
||
// 获取子窗口位置和尺寸
|
||
windowPos, _ := wss.getWindowPosition(windowInfo.Window)
|
||
windowWidth, windowHeight := windowInfo.Window.Size()
|
||
|
||
// 计算目标位置
|
||
var targetX, targetY int
|
||
|
||
switch snapEdge {
|
||
case models.SnapEdgeRight:
|
||
// 吸附到主窗口右侧
|
||
targetX = mainPos.X + mainWidth
|
||
targetY = windowPos.Y // 保持当前 Y 位置
|
||
// 如果超出主窗口范围，调整到边界
|
||
if targetY < mainPos.Y {
|
||
targetY = mainPos.Y
|
||
} else if targetY+windowHeight > mainPos.Y+mainHeight {
|
||
targetY = mainPos.Y + mainHeight - windowHeight
|
||
}
|
||
|
||
case models.SnapEdgeLeft:
|
||
// 吸附到主窗口左侧
|
||
targetX = mainPos.X - windowWidth
|
||
targetY = windowPos.Y // 保持当前 Y 位置
|
||
// 如果超出主窗口范围，调整到边界
|
||
if targetY < mainPos.Y {
|
||
targetY = mainPos.Y
|
||
} else if targetY+windowHeight > mainPos.Y+mainHeight {
|
||
targetY = mainPos.Y + mainHeight - windowHeight
|
||
}
|
||
|
||
case models.SnapEdgeBottom:
|
||
// 吸附到主窗口底部
|
||
targetX = windowPos.X // 保持当前 X 位置
|
||
targetY = 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:
|
||
// 吸附到主窗口顶部
|
||
targetX = windowPos.X // 保持当前 X 位置
|
||
targetY = 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:
|
||
// 吸附到右上角
|
||
targetX = mainPos.X + mainWidth
|
||
targetY = mainPos.Y - windowHeight
|
||
|
||
case models.SnapEdgeBottomRight:
|
||
// 吸附到右下角
|
||
targetX = mainPos.X + mainWidth
|
||
targetY = mainPos.Y + mainHeight
|
||
|
||
case models.SnapEdgeBottomLeft:
|
||
// 吸附到左下角
|
||
targetX = mainPos.X - windowWidth
|
||
targetY = mainPos.Y + mainHeight
|
||
|
||
case models.SnapEdgeTopLeft:
|
||
// 吸附到左上角
|
||
targetX = mainPos.X - windowWidth
|
||
targetY = mainPos.Y - windowHeight
|
||
|
||
default:
|
||
// 不应该到达这里
|
||
return
|
||
}
|
||
|
||
// 直接移动到目标位置，不使用平滑过渡以产生明显的吸附效果
|
||
windowInfo.Window.SetPosition(targetX, targetY)
|
||
|
||
// 更新窗口信息
|
||
windowInfo.SnapEdge = snapEdge
|
||
windowInfo.LastPos = models.WindowPosition{X: targetX, Y: targetY}
|
||
}
|
||
|
||
// Cleanup 清理资源
|
||
func (wss *WindowSnapService) Cleanup() {
|
||
// 如果有取消函数，调用它来停止所有goroutine
|
||
if wss.cancel != nil {
|
||
wss.cancel()
|
||
}
|
||
|
||
// 停止定时器
|
||
if wss.snapTicker != nil {
|
||
wss.snapTicker.Stop()
|
||
wss.snapTicker = nil
|
||
}
|
||
}
|
||
|
||
// ServiceShutdown 实现服务关闭接口
|
||
func (wss *WindowSnapService) ServiceShutdown() error {
|
||
wss.Cleanup()
|
||
return nil
|
||
}
|