480 lines
17 KiB
C#
480 lines
17 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Linq;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using System.Windows;
|
|
|
|
namespace Ink_Canvas.Helpers
|
|
{
|
|
/// <summary>
|
|
/// 矩形结构体（用于窗口位置和大小）
|
|
/// </summary>
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct WindowRect
|
|
{
|
|
public int Left;
|
|
public int Top;
|
|
public int Right;
|
|
public int Bottom;
|
|
|
|
public int Width => Right - Left;
|
|
public int Height => Bottom - Top;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 窗口信息结构
|
|
/// </summary>
|
|
public class WindowInfo
|
|
{
|
|
public IntPtr Handle { get; set; }
|
|
public string Title { get; set; }
|
|
public string ClassName { get; set; }
|
|
public string ProcessName { get; set; }
|
|
public string ProcessPath { get; set; }
|
|
public WindowRect Rect { get; set; }
|
|
public bool IsVisible { get; set; }
|
|
public bool IsMinimized { get; set; }
|
|
public bool IsMaximized { get; set; }
|
|
public int ZOrder { get; set; }
|
|
public uint ProcessId { get; set; }
|
|
public bool IsFullScreen { get; set; }
|
|
|
|
/// <summary>
|
|
/// 计算窗口是否覆盖指定区域
|
|
/// </summary>
|
|
public bool CoversArea(WindowRect area)
|
|
{
|
|
if (!IsVisible || IsMinimized) return false;
|
|
|
|
// 计算交集
|
|
int left = Math.Max(Rect.Left, area.Left);
|
|
int top = Math.Max(Rect.Top, area.Top);
|
|
int right = Math.Min(Rect.Right, area.Right);
|
|
int bottom = Math.Min(Rect.Bottom, area.Bottom);
|
|
|
|
// 如果有交集，说明窗口覆盖了该区域
|
|
return left < right && top < bottom;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 计算窗口覆盖指定区域的比例
|
|
/// </summary>
|
|
public double GetCoverageRatio(WindowRect area)
|
|
{
|
|
if (!IsVisible || IsMinimized) return 0.0;
|
|
|
|
// 计算交集
|
|
int left = Math.Max(Rect.Left, area.Left);
|
|
int top = Math.Max(Rect.Top, area.Top);
|
|
int right = Math.Min(Rect.Right, area.Right);
|
|
int bottom = Math.Min(Rect.Bottom, area.Bottom);
|
|
|
|
if (left >= right || top >= bottom) return 0.0;
|
|
|
|
// 计算交集面积
|
|
double intersectionArea = (right - left) * (bottom - top);
|
|
// 计算目标区域面积
|
|
double targetArea = area.Width * area.Height;
|
|
|
|
if (targetArea == 0) return 0.0;
|
|
|
|
return intersectionArea / targetArea;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 窗口概览模型 - 实时监控桌面所有可见窗口并计算遮挡情况
|
|
/// </summary>
|
|
public class WindowOverviewModel : IDisposable
|
|
{
|
|
#region Win32 API Declarations
|
|
[DllImport("user32.dll")]
|
|
private static extern bool EnumWindows(EnumWindowsProc lpEnumFunc, IntPtr lParam);
|
|
|
|
[DllImport("user32.dll")]
|
|
private static extern int GetWindowText(IntPtr hWnd, StringBuilder lpString, int nMaxCount);
|
|
|
|
[DllImport("user32.dll")]
|
|
private static extern int GetClassName(IntPtr hWnd, StringBuilder lpClassName, int nMaxCount);
|
|
|
|
[DllImport("user32.dll")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
private static extern bool GetWindowRect(IntPtr hWnd, out WindowRect lpRect);
|
|
|
|
[DllImport("user32.dll")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
private static extern bool IsWindowVisible(IntPtr hWnd);
|
|
|
|
[DllImport("user32.dll")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
private static extern bool IsIconic(IntPtr hWnd);
|
|
|
|
[DllImport("user32.dll")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
private static extern bool IsZoomed(IntPtr hWnd);
|
|
|
|
[DllImport("user32.dll")]
|
|
private static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint lpdwProcessId);
|
|
|
|
[DllImport("user32.dll")]
|
|
private static extern IntPtr GetForegroundWindow();
|
|
|
|
[DllImport("user32.dll")]
|
|
private static extern IntPtr GetWindow(IntPtr hWnd, uint uCmd);
|
|
|
|
private const uint GW_HWNDNEXT = 2;
|
|
private const uint GW_HWNDPREV = 3;
|
|
|
|
private delegate bool EnumWindowsProc(IntPtr hWnd, IntPtr lParam);
|
|
#endregion
|
|
|
|
private readonly object _lockObject = new object();
|
|
private List<WindowInfo> _windows = new List<WindowInfo>();
|
|
private Timer _updateTimer;
|
|
private bool _isDisposed = false;
|
|
private readonly int _updateInterval = 200; // 更新间隔（毫秒）
|
|
|
|
/// <summary>
|
|
/// 窗口列表更新事件
|
|
/// </summary>
|
|
public event EventHandler<List<WindowInfo>> WindowsUpdated;
|
|
|
|
/// <summary>
|
|
/// 当前窗口列表（按Z顺序排序，最上层在前）
|
|
/// </summary>
|
|
public List<WindowInfo> Windows
|
|
{
|
|
get
|
|
{
|
|
lock (_lockObject)
|
|
{
|
|
return new List<WindowInfo>(_windows);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 构造函数
|
|
/// </summary>
|
|
public WindowOverviewModel()
|
|
{
|
|
// 立即执行一次更新
|
|
UpdateWindows();
|
|
|
|
// 启动定时器，定期更新窗口列表
|
|
_updateTimer = new Timer(OnUpdateTimer, null, _updateInterval, _updateInterval);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 定时器回调
|
|
/// </summary>
|
|
private void OnUpdateTimer(object state)
|
|
{
|
|
if (_isDisposed) return;
|
|
|
|
try
|
|
{
|
|
UpdateWindows();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
LogHelper.WriteLogToFile($"窗口概览模型更新失败: {ex.Message}", LogHelper.LogType.Error);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 更新窗口列表
|
|
/// </summary>
|
|
public void UpdateWindows()
|
|
{
|
|
var windows = new List<WindowInfo>();
|
|
var zOrder = 0;
|
|
|
|
EnumWindows((hWnd, lParam) =>
|
|
{
|
|
try
|
|
{
|
|
// 检查窗口是否可见
|
|
if (!IsWindowVisible(hWnd)) return true;
|
|
|
|
// 检查窗口是否最小化
|
|
bool isMinimized = IsIconic(hWnd);
|
|
if (isMinimized) return true;
|
|
|
|
// 获取窗口矩形
|
|
if (!GetWindowRect(hWnd, out WindowRect rect)) return true;
|
|
|
|
// 过滤掉无效的窗口（太小或位置异常的窗口）
|
|
if (rect.Width <= 0 || rect.Height <= 0) return true;
|
|
if (rect.Right < rect.Left || rect.Bottom < rect.Top) return true;
|
|
|
|
// 获取窗口标题
|
|
const int nChars = 256;
|
|
StringBuilder windowTitle = new StringBuilder(nChars);
|
|
GetWindowText(hWnd, windowTitle, nChars);
|
|
string title = windowTitle.ToString();
|
|
|
|
// 获取窗口类名
|
|
StringBuilder className = new StringBuilder(nChars);
|
|
GetClassName(hWnd, className, nChars);
|
|
string classNameStr = className.ToString();
|
|
|
|
// 获取进程信息
|
|
GetWindowThreadProcessId(hWnd, out uint processId);
|
|
string processName = "Unknown";
|
|
string processPath = "Unknown";
|
|
|
|
try
|
|
{
|
|
Process process = Process.GetProcessById((int)processId);
|
|
processName = process.ProcessName;
|
|
try
|
|
{
|
|
processPath = process.MainModule?.FileName ?? "Unknown";
|
|
}
|
|
catch
|
|
{
|
|
processPath = "Unknown";
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// 进程可能已退出
|
|
}
|
|
|
|
// 检查是否最大化
|
|
bool isMaximized = IsZoomed(hWnd);
|
|
|
|
// 检查是否全屏（窗口大小接近屏幕大小）
|
|
bool isFullScreen = false;
|
|
try
|
|
{
|
|
var screen = System.Windows.Forms.Screen.FromHandle(hWnd);
|
|
var screenBounds = screen.Bounds;
|
|
// 如果窗口大小接近屏幕大小（允许10像素误差），认为是全屏
|
|
isFullScreen = rect.Width >= screenBounds.Width - 10 &&
|
|
rect.Height >= screenBounds.Height - 10 &&
|
|
Math.Abs(rect.Left - screenBounds.Left) <= 10 &&
|
|
Math.Abs(rect.Top - screenBounds.Top) <= 10;
|
|
}
|
|
catch
|
|
{
|
|
// 无法获取屏幕信息，使用默认值
|
|
}
|
|
|
|
// 跳过当前应用程序的窗口（避免检测到自己）
|
|
if (processName == "InkCanvasForClass" || processName == "Ink Canvas")
|
|
{
|
|
return true;
|
|
}
|
|
|
|
var windowInfo = new WindowInfo
|
|
{
|
|
Handle = hWnd,
|
|
Title = title,
|
|
ClassName = classNameStr,
|
|
ProcessName = processName,
|
|
ProcessPath = processPath,
|
|
Rect = rect,
|
|
IsVisible = true,
|
|
IsMinimized = false,
|
|
IsMaximized = isMaximized,
|
|
ZOrder = zOrder++,
|
|
ProcessId = processId,
|
|
IsFullScreen = isFullScreen
|
|
};
|
|
|
|
windows.Add(windowInfo);
|
|
}
|
|
catch
|
|
{
|
|
// 忽略单个窗口的错误，继续枚举其他窗口
|
|
}
|
|
|
|
return true; // 继续枚举
|
|
}, IntPtr.Zero);
|
|
|
|
// 按Z顺序排序（从最上层到最下层）
|
|
// 注意：EnumWindows返回的顺序可能不是严格的Z顺序，但我们可以通过GetWindow来获取更准确的顺序
|
|
windows = windows.OrderByDescending(w => w.ZOrder).ToList();
|
|
|
|
lock (_lockObject)
|
|
{
|
|
_windows = windows;
|
|
}
|
|
|
|
// 触发更新事件
|
|
WindowsUpdated?.Invoke(this, windows);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 检查指定区域是否被其他窗口覆盖
|
|
/// </summary>
|
|
/// <param name="area">要检查的区域</param>
|
|
/// <param name="excludeProcessNames">要排除的进程名列表（例如当前应用程序）</param>
|
|
/// <param name="coverageThreshold">覆盖阈值（0.0-1.0），超过此阈值认为被覆盖</param>
|
|
/// <returns>如果被覆盖返回true</returns>
|
|
public bool IsAreaCovered(WindowRect area, List<string> excludeProcessNames = null, double coverageThreshold = 0.5)
|
|
{
|
|
lock (_lockObject)
|
|
{
|
|
excludeProcessNames = excludeProcessNames ?? new List<string>();
|
|
|
|
// 从最上层窗口开始检查
|
|
foreach (var window in _windows)
|
|
{
|
|
// 跳过排除的进程
|
|
if (excludeProcessNames.Contains(window.ProcessName)) continue;
|
|
|
|
// 计算覆盖比例
|
|
double coverage = window.GetCoverageRatio(area);
|
|
if (coverage >= coverageThreshold)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 检查指定区域是否被全屏窗口覆盖
|
|
/// </summary>
|
|
/// <param name="area">要检查的区域</param>
|
|
/// <param name="excludeProcessNames">要排除的进程名列表</param>
|
|
/// <returns>如果被全屏窗口覆盖返回true</returns>
|
|
public bool IsAreaCoveredByFullScreenWindow(WindowRect area, List<string> excludeProcessNames = null)
|
|
{
|
|
lock (_lockObject)
|
|
{
|
|
excludeProcessNames = excludeProcessNames ?? new List<string>();
|
|
|
|
// 查找全屏窗口
|
|
foreach (var window in _windows)
|
|
{
|
|
// 跳过排除的进程
|
|
if (excludeProcessNames.Contains(window.ProcessName)) continue;
|
|
|
|
// 只检查全屏窗口
|
|
if (window.IsFullScreen && window.CoversArea(area))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获取覆盖指定区域的所有窗口
|
|
/// </summary>
|
|
/// <param name="area">要检查的区域</param>
|
|
/// <param name="excludeProcessNames">要排除的进程名列表</param>
|
|
/// <param name="coverageThreshold">覆盖阈值</param>
|
|
/// <returns>覆盖该区域的窗口列表（按Z顺序，最上层在前）</returns>
|
|
public List<WindowInfo> GetCoveringWindows(WindowRect area, List<string> excludeProcessNames = null, double coverageThreshold = 0.1)
|
|
{
|
|
lock (_lockObject)
|
|
{
|
|
excludeProcessNames = excludeProcessNames ?? new List<string>();
|
|
var coveringWindows = new List<WindowInfo>();
|
|
|
|
foreach (var window in _windows)
|
|
{
|
|
// 跳过排除的进程
|
|
if (excludeProcessNames.Contains(window.ProcessName)) continue;
|
|
|
|
// 计算覆盖比例
|
|
double coverage = window.GetCoverageRatio(area);
|
|
if (coverage >= coverageThreshold)
|
|
{
|
|
coveringWindows.Add(window);
|
|
}
|
|
}
|
|
|
|
return coveringWindows;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 检查是否有全屏窗口
|
|
/// </summary>
|
|
/// <param name="excludeProcessNames">要排除的进程名列表</param>
|
|
/// <returns>如果有全屏窗口返回true</returns>
|
|
public bool HasFullScreenWindow(List<string> excludeProcessNames = null)
|
|
{
|
|
lock (_lockObject)
|
|
{
|
|
excludeProcessNames = excludeProcessNames ?? new List<string>();
|
|
|
|
return _windows.Any(w => !excludeProcessNames.Contains(w.ProcessName) && w.IsFullScreen);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获取所有全屏窗口
|
|
/// </summary>
|
|
/// <param name="excludeProcessNames">要排除的进程名列表</param>
|
|
/// <returns>全屏窗口列表</returns>
|
|
public List<WindowInfo> GetFullScreenWindows(List<string> excludeProcessNames = null)
|
|
{
|
|
lock (_lockObject)
|
|
{
|
|
excludeProcessNames = excludeProcessNames ?? new List<string>();
|
|
|
|
return _windows.Where(w => !excludeProcessNames.Contains(w.ProcessName) && w.IsFullScreen).ToList();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 根据进程名查找窗口
|
|
/// </summary>
|
|
/// <param name="processName">进程名</param>
|
|
/// <returns>匹配的窗口列表</returns>
|
|
public List<WindowInfo> FindWindowsByProcessName(string processName)
|
|
{
|
|
lock (_lockObject)
|
|
{
|
|
return _windows.Where(w => w.ProcessName.Equals(processName, StringComparison.OrdinalIgnoreCase)).ToList();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 根据窗口标题查找窗口
|
|
/// </summary>
|
|
/// <param name="title">窗口标题（支持部分匹配）</param>
|
|
/// <returns>匹配的窗口列表</returns>
|
|
public List<WindowInfo> FindWindowsByTitle(string title)
|
|
{
|
|
lock (_lockObject)
|
|
{
|
|
return _windows.Where(w => w.Title.IndexOf(title, StringComparison.OrdinalIgnoreCase) >= 0).ToList();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 释放资源
|
|
/// </summary>
|
|
public void Dispose()
|
|
{
|
|
if (_isDisposed) return;
|
|
|
|
_isDisposed = true;
|
|
_updateTimer?.Dispose();
|
|
_updateTimer = null;
|
|
|
|
lock (_lockObject)
|
|
{
|
|
_windows.Clear();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|