mirror of
https://github.com/openhardwaremonitor/openhardwaremonitor
synced 2025-08-22 18:07:09 +00:00
580 lines
19 KiB
C#
580 lines
19 KiB
C#
/*
|
|
|
|
This Source Code Form is subject to the terms of the Mozilla Public
|
|
License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
|
|
Copyright (C) 2010-2011 Michael Möller <mmoeller@openhardwaremonitor.org>
|
|
Copyright (C) 2010 Paul Werelds <paul@werelds.net>
|
|
|
|
*/
|
|
|
|
using System;
|
|
using System.Drawing;
|
|
using System.Drawing.Drawing2D;
|
|
using System.Drawing.Text;
|
|
using System.Reflection;
|
|
using System.Runtime.InteropServices;
|
|
using System.Windows.Forms;
|
|
|
|
namespace OpenHardwareMonitor.GUI {
|
|
|
|
public class GadgetWindow : NativeWindow, IDisposable {
|
|
|
|
private bool visible = false;
|
|
private bool lockPositionAndSize = false;
|
|
private bool alwaysOnTop = false;
|
|
private byte opacity = 255;
|
|
private Point location = new Point(100, 100);
|
|
private Size size = new Size(130, 84);
|
|
private ContextMenu contextMenu = null;
|
|
private MethodInfo commandDispatch;
|
|
private IntPtr handleBitmapDC;
|
|
private Size bufferSize;
|
|
private Graphics graphics;
|
|
|
|
public GadgetWindow() {
|
|
Type commandType =
|
|
typeof(Form).Assembly.GetType("System.Windows.Forms.Command");
|
|
commandDispatch = commandType.GetMethod("DispatchID",
|
|
BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public,
|
|
null, new Type[]{ typeof(int) }, null);
|
|
|
|
this.CreateHandle(CreateParams);
|
|
|
|
// move window to the bottom
|
|
MoveToBottom(Handle);
|
|
|
|
// prevent window from fading to a glass sheet when peek is invoked
|
|
try {
|
|
bool value = true;
|
|
NativeMethods.DwmSetWindowAttribute(Handle,
|
|
WindowAttribute.DWMWA_EXCLUDED_FROM_PEEK, ref value,
|
|
Marshal.SizeOf(value));
|
|
} catch (DllNotFoundException) { } catch (EntryPointNotFoundException) { }
|
|
|
|
CreateBuffer();
|
|
}
|
|
|
|
private void ShowDesktopChanged(bool showDesktop) {
|
|
if (showDesktop) {
|
|
MoveToTopMost(Handle);
|
|
} else {
|
|
MoveToBottom(Handle);
|
|
}
|
|
}
|
|
|
|
private void MoveToBottom(IntPtr handle) {
|
|
NativeMethods.SetWindowPos(handle, HWND_BOTTOM, 0, 0, 0, 0,
|
|
SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOSENDCHANGING);
|
|
}
|
|
|
|
private void MoveToTopMost(IntPtr handle) {
|
|
NativeMethods.SetWindowPos(handle, HWND_TOPMOST, 0, 0, 0, 0,
|
|
SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOSENDCHANGING);
|
|
}
|
|
|
|
private void ShowContextMenu(Point position) {
|
|
NativeMethods.TrackPopupMenuEx(contextMenu.Handle,
|
|
TPM_RIGHTBUTTON | TPM_VERTICAL, position.X,
|
|
position.Y, Handle, IntPtr.Zero);
|
|
}
|
|
|
|
protected virtual CreateParams CreateParams {
|
|
get {
|
|
CreateParams cp = new CreateParams();
|
|
cp.Width = 4096;
|
|
cp.Height = 4096;
|
|
cp.X = location.X;
|
|
cp.Y = location.Y;
|
|
cp.ExStyle = WS_EX_LAYERED | WS_EX_TOOLWINDOW;
|
|
return cp;
|
|
}
|
|
}
|
|
|
|
protected override void WndProc(ref Message message) {
|
|
switch (message.Msg) {
|
|
case WM_COMMAND: {
|
|
// need to dispatch the message for the context menu
|
|
if (message.LParam == IntPtr.Zero)
|
|
commandDispatch.Invoke(null, new object[] {
|
|
message.WParam.ToInt32() & 0xFFFF });
|
|
} break;
|
|
case WM_NCHITTEST: {
|
|
message.Result = (IntPtr)HitResult.Caption;
|
|
if (HitTest != null) {
|
|
Point p = new Point(
|
|
Macros.GET_X_LPARAM(message.LParam) - location.X,
|
|
Macros.GET_Y_LPARAM(message.LParam) - location.Y
|
|
);
|
|
HitTestEventArgs e = new HitTestEventArgs(p, HitResult.Caption);
|
|
HitTest(this, e);
|
|
message.Result = (IntPtr)e.HitResult;
|
|
}
|
|
} break;
|
|
case WM_NCLBUTTONDBLCLK: {
|
|
if (MouseDoubleClick != null) {
|
|
MouseDoubleClick(this, new MouseEventArgs(MouseButtons.Left, 2,
|
|
Macros.GET_X_LPARAM(message.LParam) - location.X,
|
|
Macros.GET_Y_LPARAM(message.LParam) - location.Y, 0));
|
|
}
|
|
message.Result = IntPtr.Zero;
|
|
} break;
|
|
case WM_NCRBUTTONDOWN: {
|
|
message.Result = IntPtr.Zero;
|
|
} break;
|
|
case WM_NCRBUTTONUP: {
|
|
if (contextMenu != null)
|
|
ShowContextMenu(new Point(
|
|
Macros.GET_X_LPARAM(message.LParam),
|
|
Macros.GET_Y_LPARAM(message.LParam)
|
|
));
|
|
message.Result = IntPtr.Zero;
|
|
} break;
|
|
case WM_WINDOWPOSCHANGING: {
|
|
WindowPos wp = (WindowPos)Marshal.PtrToStructure(
|
|
message.LParam, typeof(WindowPos));
|
|
|
|
if (!lockPositionAndSize) {
|
|
// prevent the window from leaving the screen
|
|
if ((wp.flags & SWP_NOMOVE) == 0) {
|
|
Rectangle rect = Screen.GetWorkingArea(
|
|
new Rectangle(wp.x, wp.y, wp.cx, wp.cy));
|
|
const int margin = 16;
|
|
wp.x = Math.Max(wp.x, rect.Left - wp.cx + margin);
|
|
wp.x = Math.Min(wp.x, rect.Right - margin);
|
|
wp.y = Math.Max(wp.y, rect.Top - wp.cy + margin);
|
|
wp.y = Math.Min(wp.y, rect.Bottom - margin);
|
|
}
|
|
|
|
// update location and fire event
|
|
if ((wp.flags & SWP_NOMOVE) == 0) {
|
|
if (location.X != wp.x || location.Y != wp.y) {
|
|
location = new Point(wp.x, wp.y);
|
|
if (LocationChanged != null)
|
|
LocationChanged(this, EventArgs.Empty);
|
|
}
|
|
}
|
|
|
|
// update size and fire event
|
|
if ((wp.flags & SWP_NOSIZE) == 0) {
|
|
if (size.Width != wp.cx || size.Height != wp.cy) {
|
|
size = new Size(wp.cx, wp.cy);
|
|
if (SizeChanged != null)
|
|
SizeChanged(this, EventArgs.Empty);
|
|
}
|
|
}
|
|
|
|
// update the size of the layered window
|
|
if ((wp.flags & SWP_NOSIZE) == 0) {
|
|
NativeMethods.UpdateLayeredWindow(Handle, IntPtr.Zero,
|
|
IntPtr.Zero, ref size, IntPtr.Zero, IntPtr.Zero, 0,
|
|
IntPtr.Zero, 0);
|
|
}
|
|
|
|
// update the position of the layered window
|
|
if ((wp.flags & SWP_NOMOVE) == 0) {
|
|
NativeMethods.SetWindowPos(Handle, IntPtr.Zero,
|
|
location.X, location.Y, 0, 0, SWP_NOSIZE | SWP_NOACTIVATE |
|
|
SWP_NOZORDER | SWP_NOSENDCHANGING);
|
|
}
|
|
}
|
|
|
|
// do not forward any move or size messages
|
|
wp.flags |= SWP_NOSIZE | SWP_NOMOVE;
|
|
|
|
// suppress any frame changed events
|
|
wp.flags &= ~SWP_FRAMECHANGED;
|
|
|
|
Marshal.StructureToPtr(wp, message.LParam, false);
|
|
message.Result = IntPtr.Zero;
|
|
} break;
|
|
default: {
|
|
base.WndProc(ref message);
|
|
} break;
|
|
}
|
|
}
|
|
|
|
private BlendFunction CreateBlendFunction() {
|
|
BlendFunction blend = new BlendFunction();
|
|
blend.BlendOp = AC_SRC_OVER;
|
|
blend.BlendFlags = 0;
|
|
blend.SourceConstantAlpha = opacity;
|
|
blend.AlphaFormat = AC_SRC_ALPHA;
|
|
return blend;
|
|
}
|
|
|
|
private void CreateBuffer() {
|
|
IntPtr handleScreenDC = NativeMethods.GetDC(IntPtr.Zero);
|
|
handleBitmapDC = NativeMethods.CreateCompatibleDC(handleScreenDC);
|
|
NativeMethods.ReleaseDC(IntPtr.Zero, handleScreenDC);
|
|
bufferSize = size;
|
|
|
|
BitmapInfo info = new BitmapInfo();
|
|
info.Size = Marshal.SizeOf(info);
|
|
info.Width = size.Width;
|
|
info.Height = -size.Height;
|
|
info.BitCount = 32;
|
|
info.Planes = 1;
|
|
|
|
IntPtr ptr;
|
|
IntPtr hBmp = NativeMethods.CreateDIBSection(handleBitmapDC, ref info, 0,
|
|
out ptr, IntPtr.Zero, 0);
|
|
IntPtr hBmpOld = NativeMethods.SelectObject(handleBitmapDC, hBmp);
|
|
NativeMethods.DeleteObject(hBmpOld);
|
|
|
|
graphics = Graphics.FromHdc(handleBitmapDC);
|
|
|
|
if (Environment.OSVersion.Version.Major > 5) {
|
|
this.graphics.TextRenderingHint = TextRenderingHint.SystemDefault;
|
|
this.graphics.SmoothingMode = SmoothingMode.HighQuality;
|
|
}
|
|
}
|
|
|
|
private void DisposeBuffer() {
|
|
graphics.Dispose();
|
|
NativeMethods.DeleteDC(handleBitmapDC);
|
|
}
|
|
|
|
public virtual void Dispose() {
|
|
DisposeBuffer();
|
|
}
|
|
|
|
public PaintEventHandler Paint;
|
|
|
|
public void Redraw() {
|
|
if (!visible || Paint == null)
|
|
return;
|
|
|
|
if (size != bufferSize) {
|
|
DisposeBuffer();
|
|
CreateBuffer();
|
|
}
|
|
|
|
Paint(this,
|
|
new PaintEventArgs(graphics, new Rectangle(Point.Empty, size)));
|
|
|
|
Point pointSource = Point.Empty;
|
|
BlendFunction blend = CreateBlendFunction();
|
|
|
|
NativeMethods.UpdateLayeredWindow(Handle, IntPtr.Zero, IntPtr.Zero,
|
|
ref size, handleBitmapDC, ref pointSource, 0, ref blend, ULW_ALPHA);
|
|
|
|
// make sure the window is at the right location
|
|
NativeMethods.SetWindowPos(Handle, IntPtr.Zero,
|
|
location.X, location.Y, 0, 0, SWP_NOSIZE | SWP_NOACTIVATE |
|
|
SWP_NOZORDER | SWP_NOSENDCHANGING);
|
|
}
|
|
|
|
public byte Opacity {
|
|
get {
|
|
return opacity;
|
|
}
|
|
set {
|
|
if (opacity != value) {
|
|
opacity = value;
|
|
BlendFunction blend = CreateBlendFunction();
|
|
NativeMethods.UpdateLayeredWindow(Handle, IntPtr.Zero, IntPtr.Zero,
|
|
IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, 0, ref blend, ULW_ALPHA);
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool Visible {
|
|
get {
|
|
return visible;
|
|
}
|
|
set {
|
|
if (visible != value) {
|
|
visible = value;
|
|
NativeMethods.SetWindowPos(Handle, IntPtr.Zero, 0, 0, 0, 0,
|
|
SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOZORDER |
|
|
(value ? SWP_SHOWWINDOW : SWP_HIDEWINDOW));
|
|
if (value) {
|
|
if (!alwaysOnTop)
|
|
ShowDesktop.Instance.ShowDesktopChanged += ShowDesktopChanged;
|
|
} else {
|
|
if (!alwaysOnTop)
|
|
ShowDesktop.Instance.ShowDesktopChanged -= ShowDesktopChanged;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// if locked, the window can not be moved or resized
|
|
public bool LockPositionAndSize {
|
|
get {
|
|
return lockPositionAndSize;
|
|
}
|
|
set {
|
|
lockPositionAndSize = value;
|
|
}
|
|
}
|
|
|
|
public bool AlwaysOnTop {
|
|
get {
|
|
return alwaysOnTop;
|
|
}
|
|
set {
|
|
if (value != alwaysOnTop) {
|
|
alwaysOnTop = value;
|
|
if (alwaysOnTop) {
|
|
if (visible)
|
|
ShowDesktop.Instance.ShowDesktopChanged -= ShowDesktopChanged;
|
|
MoveToTopMost(Handle);
|
|
} else {
|
|
MoveToBottom(Handle);
|
|
if (visible)
|
|
ShowDesktop.Instance.ShowDesktopChanged += ShowDesktopChanged;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public Size Size {
|
|
get {
|
|
return size;
|
|
}
|
|
set {
|
|
if (size != value) {
|
|
size = value;
|
|
NativeMethods.UpdateLayeredWindow(Handle, IntPtr.Zero, IntPtr.Zero,
|
|
ref size, IntPtr.Zero, IntPtr.Zero, 0, IntPtr.Zero, 0);
|
|
if (SizeChanged != null)
|
|
SizeChanged(this, EventArgs.Empty);
|
|
}
|
|
}
|
|
}
|
|
|
|
public event EventHandler SizeChanged;
|
|
|
|
public Point Location {
|
|
get {
|
|
return location;
|
|
}
|
|
set {
|
|
if (location != value) {
|
|
location = value;
|
|
NativeMethods.SetWindowPos(Handle, IntPtr.Zero,
|
|
location.X, location.Y, 0, 0,
|
|
SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOSENDCHANGING);
|
|
if (LocationChanged != null)
|
|
LocationChanged(this, EventArgs.Empty);
|
|
}
|
|
}
|
|
}
|
|
|
|
public event EventHandler LocationChanged;
|
|
|
|
public ContextMenu ContextMenu {
|
|
get {
|
|
return contextMenu;
|
|
}
|
|
set {
|
|
this.contextMenu = value;
|
|
}
|
|
}
|
|
|
|
public event HitTestEventHandler HitTest;
|
|
|
|
public event MouseEventHandler MouseDoubleClick;
|
|
|
|
[StructLayout(LayoutKind.Sequential, Pack = 1)]
|
|
private struct BlendFunction {
|
|
public byte BlendOp;
|
|
public byte BlendFlags;
|
|
public byte SourceConstantAlpha;
|
|
public byte AlphaFormat;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential, Pack = 1)]
|
|
private struct WindowPos {
|
|
public IntPtr hwnd;
|
|
public IntPtr hwndInsertAfter;
|
|
public int x;
|
|
public int y;
|
|
public int cx;
|
|
public int cy;
|
|
public uint flags;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct BitmapInfo {
|
|
public Int32 Size;
|
|
public Int32 Width;
|
|
public Int32 Height;
|
|
public Int16 Planes;
|
|
public Int16 BitCount;
|
|
public Int32 Compression;
|
|
public Int32 SizeImage;
|
|
public Int32 XPelsPerMeter;
|
|
public Int32 YPelsPerMeter;
|
|
public Int32 ClrUsed;
|
|
public Int32 ClrImportant;
|
|
public Int32 Colors;
|
|
}
|
|
|
|
public static readonly IntPtr HWND_BOTTOM = (IntPtr)1;
|
|
public static readonly IntPtr HWND_TOPMOST = (IntPtr)(-1);
|
|
|
|
public const int WS_EX_LAYERED = 0x00080000;
|
|
public const int WS_EX_TOOLWINDOW = 0x00000080;
|
|
|
|
public const uint SWP_NOSIZE = 0x0001;
|
|
public const uint SWP_NOMOVE = 0x0002;
|
|
public const uint SWP_NOACTIVATE = 0x0010;
|
|
public const uint SWP_FRAMECHANGED = 0x0020;
|
|
public const uint SWP_HIDEWINDOW = 0x0080;
|
|
public const uint SWP_SHOWWINDOW = 0x0040;
|
|
public const uint SWP_NOZORDER = 0x0004;
|
|
public const uint SWP_NOSENDCHANGING = 0x0400;
|
|
|
|
public const int ULW_COLORKEY = 0x00000001;
|
|
public const int ULW_ALPHA = 0x00000002;
|
|
public const int ULW_OPAQUE = 0x00000004;
|
|
|
|
public const byte AC_SRC_OVER = 0x00;
|
|
public const byte AC_SRC_ALPHA = 0x01;
|
|
|
|
public const int WM_NCHITTEST = 0x0084;
|
|
public const int WM_NCLBUTTONDBLCLK = 0x00A3;
|
|
public const int WM_NCLBUTTONDOWN = 0x00A1;
|
|
public const int WM_NCLBUTTONUP = 0x00A2;
|
|
public const int WM_NCRBUTTONDOWN = 0x00A4;
|
|
public const int WM_NCRBUTTONUP = 0x00A5;
|
|
public const int WM_WINDOWPOSCHANGING = 0x0046;
|
|
public const int WM_COMMAND = 0x0111;
|
|
|
|
public const int TPM_RIGHTBUTTON = 0x0002;
|
|
public const int TPM_VERTICAL = 0x0040;
|
|
|
|
private enum WindowAttribute : int {
|
|
DWMWA_NCRENDERING_ENABLED = 1,
|
|
DWMWA_NCRENDERING_POLICY,
|
|
DWMWA_TRANSITIONS_FORCEDISABLED,
|
|
DWMWA_ALLOW_NCPAINT,
|
|
DWMWA_CAPTION_BUTTON_BOUNDS,
|
|
DWMWA_NONCLIENT_RTL_LAYOUT,
|
|
DWMWA_FORCE_ICONIC_REPRESENTATION,
|
|
DWMWA_FLIP3D_POLICY,
|
|
DWMWA_EXTENDED_FRAME_BOUNDS,
|
|
DWMWA_HAS_ICONIC_BITMAP,
|
|
DWMWA_DISALLOW_PEEK,
|
|
DWMWA_EXCLUDED_FROM_PEEK,
|
|
DWMWA_LAST
|
|
}
|
|
|
|
/// <summary>
|
|
/// Some macros imported and converted from the Windows SDK
|
|
/// </summary>
|
|
private static class Macros {
|
|
public static ushort LOWORD(IntPtr l) {
|
|
return (ushort) ((ulong)l & 0xFFFF);
|
|
}
|
|
|
|
public static UInt16 HIWORD(IntPtr l) {
|
|
return (ushort) (((ulong)l >> 16) & 0xFFFF);
|
|
}
|
|
|
|
public static int GET_X_LPARAM(IntPtr lp) {
|
|
return (short) LOWORD(lp);
|
|
}
|
|
|
|
public static int GET_Y_LPARAM(IntPtr lp) {
|
|
return (short) HIWORD(lp);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Imported native methods
|
|
/// </summary>
|
|
private static class NativeMethods {
|
|
private const string USER = "user32.dll";
|
|
private const string GDI = "gdi32.dll";
|
|
public const string DWMAPI = "dwmapi.dll";
|
|
|
|
[DllImport(USER, CallingConvention = CallingConvention.Winapi)]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool UpdateLayeredWindow(IntPtr hwnd, IntPtr hdcDst,
|
|
IntPtr pptDst, ref Size psize, IntPtr hdcSrc, IntPtr pprSrc,
|
|
int crKey, IntPtr pblend, int dwFlags);
|
|
|
|
[DllImport(USER, CallingConvention = CallingConvention.Winapi)]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool UpdateLayeredWindow(IntPtr hwnd, IntPtr hdcDst,
|
|
IntPtr pptDst, ref Size psize, IntPtr hdcSrc, ref Point pprSrc,
|
|
int crKey, ref BlendFunction pblend, int dwFlags);
|
|
|
|
[DllImport(USER, CallingConvention = CallingConvention.Winapi)]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool UpdateLayeredWindow(IntPtr hwnd, IntPtr hdcDst,
|
|
IntPtr pptDst, IntPtr psize, IntPtr hdcSrc, IntPtr pprSrc,
|
|
int crKey, ref BlendFunction pblend, int dwFlags);
|
|
|
|
[DllImport(USER, CallingConvention = CallingConvention.Winapi)]
|
|
public static extern IntPtr GetDC(IntPtr hWnd);
|
|
|
|
[DllImport(USER, CallingConvention = CallingConvention.Winapi)]
|
|
public static extern int ReleaseDC(IntPtr hWnd, IntPtr hDC);
|
|
|
|
[DllImport(USER, CallingConvention = CallingConvention.Winapi)]
|
|
public static extern bool SetWindowPos(IntPtr hWnd,
|
|
IntPtr hWndInsertAfter, int X, int Y, int cx, int cy, uint uFlags);
|
|
|
|
[DllImport(USER, CallingConvention = CallingConvention.Winapi)]
|
|
public static extern bool TrackPopupMenuEx(IntPtr hMenu, uint uFlags,
|
|
int x, int y, IntPtr hWnd, IntPtr tpmParams);
|
|
|
|
[DllImport(GDI, CallingConvention = CallingConvention.Winapi)]
|
|
public static extern IntPtr CreateCompatibleDC(IntPtr hDC);
|
|
|
|
[DllImport(GDI, CallingConvention = CallingConvention.Winapi)]
|
|
public static extern IntPtr CreateDIBSection(IntPtr hdc,
|
|
[In] ref BitmapInfo pbmi, uint pila, out IntPtr ppvBits,
|
|
IntPtr hSection, uint dwOffset);
|
|
|
|
[DllImport(GDI, CallingConvention = CallingConvention.Winapi)]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool DeleteDC(IntPtr hdc);
|
|
|
|
[DllImport(GDI, CallingConvention = CallingConvention.Winapi)]
|
|
public static extern IntPtr SelectObject(IntPtr hDC, IntPtr hObject);
|
|
|
|
[DllImport(GDI, CallingConvention = CallingConvention.Winapi)]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool DeleteObject(IntPtr hObject);
|
|
|
|
[DllImport(DWMAPI, CallingConvention = CallingConvention.Winapi)]
|
|
public static extern int DwmSetWindowAttribute(IntPtr hwnd,
|
|
WindowAttribute dwAttribute, ref bool pvAttribute, int cbAttribute);
|
|
}
|
|
}
|
|
|
|
public enum HitResult {
|
|
Transparent = -1,
|
|
Nowhere = 0,
|
|
Client = 1,
|
|
Caption = 2,
|
|
Left = 10,
|
|
Right = 11,
|
|
Top = 12,
|
|
TopLeft = 13,
|
|
TopRight = 14,
|
|
Bottom = 15,
|
|
BottomLeft = 16,
|
|
BottomRight = 17,
|
|
Border = 18
|
|
}
|
|
|
|
public delegate void HitTestEventHandler(object sender, HitTestEventArgs e);
|
|
|
|
public class HitTestEventArgs : EventArgs {
|
|
public HitTestEventArgs(Point location, HitResult hitResult) {
|
|
Location = location;
|
|
HitResult = hitResult;
|
|
}
|
|
public Point Location { get; private set; }
|
|
public HitResult HitResult { get; set; }
|
|
}
|
|
}
|