static HWND()
{
NULL = new HWND(IntPtr.Zero);
BROADCAST = new HWND(new IntPtr(0xffff));
MESSAGE = new HWND(new IntPtr(-3));
DESKTOP = new HWND(new IntPtr(0));
TOP = new HWND(new IntPtr(0));
BOTTOM = new HWND(new IntPtr(1));
TOPMOST = new HWND(new IntPtr(-1));
NOTOPMOST = new HWND(new IntPtr(-2));
}
/// <summary>
/// Transform a point from "screen" coordinate space into the
/// "client" coordinate space of the window.
/// </summary>
public static Point TransformScreenToClient(this HwndSource hwndSource, Point point)
{
HWND hwnd = new HWND(hwndSource.Handle);
POINT pt = new POINT();
pt.x = (int)point.X;
pt.y = (int)point.Y;
NativeMethods.ScreenToClient(hwnd, ref pt);
return new Point(pt.x, pt.y);
}
/// <summary>
/// Hooks into the stream of messages that are dispatched to the
/// specified window.
/// </summary>
/// <remarks>
/// The window must be owned by the calling thread.
/// </remarks>
public WindowSubclass(HWND hwnd)
{
if (!IsCorrectThread(hwnd)) {
throw new InvalidOperationException("May not hook a window created by a different thread.");
}
_hwnd = hwnd;
_wndproc = WndProcStub;
_wndprocPtr = Marshal.GetFunctionPointerForDelegate(_wndproc);
// Because our window proc is an instance method, it is connected
// to this instance of WindowSubclass, where we can store state.
// We do not need to store any extra state in native memory.
NativeMethods.SetWindowSubclass(hwnd, _wndproc, IntPtr.Zero, IntPtr.Zero);
}
public static extern HWND SetParent(HWND hwndChild, HWND hwndNewParent);
protected override sealed HWND BuildWindowOverride(HWND hwndParent)
{
HwndSourceParameters hwndSourceParameters = new HwndSourceParameters();
hwndSourceParameters.WindowStyle = (int)(WS.VISIBLE | WS.CHILD | WS.CLIPSIBLINGS | WS.CLIPCHILDREN);
hwndSourceParameters.ParentWindow = hwndParent.DangerousGetHandle();
_hwndSource = new HwndSource(hwndSourceParameters);
_hwndSource.SizeToContent = SizeToContent.Manual;
// Set the root visual of the HwndSource to an instance of
// HwndSourceHostRoot. Hook it up as a logical child if
// we are on the same thread.
HwndSourceHostRoot root = new HwndSourceHostRoot();
_hwndSource.RootVisual = root;
root.OnMeasure += OnRootMeasured;
AddLogicalChild(_hwndSource.RootVisual);
SetRootVisual(Child);
return new HWND(_hwndSource.Handle);
}
internal void TransferHandleOwnership(StrongHWND hwnd)
{
Debug.Assert(hwnd == _hwnd); // equivalency, not reference equals
_hwnd = hwnd;
}
private IntPtr WndProc(HWND hwnd, WM msg, IntPtr wParam, IntPtr lParam, IntPtr id, IntPtr data)
{
IntPtr retval = IntPtr.Zero;
try {
retval = WndProcOverride(hwnd, msg, wParam, lParam, id, data);
} finally {
if (_hwnd != HWND.NULL) {
Debug.Assert(_hwnd == hwnd);
if (msg == WM.NCDESTROY) {
Dispose();
} else if (msg == _disposeMessage && wParam == _wndprocPtr) {
DisposeHelper(lParam == IntPtr.Zero ? false : true);
}
}
}
return retval;
}
protected virtual IntPtr WndProcOverride(HWND hwnd, WM msg, IntPtr wParam, IntPtr lParam, IntPtr id, IntPtr data)
{
// Call the next window proc in the subclass chain.
return NativeMethods.DefSubclassProc(hwnd, msg, wParam, lParam);
}
private static extern IntPtr _GetWindowLongPtr(HWND hwnd, GWL nIndex);
private static extern int _GetClassName(HWND hWnd, StringBuilder lpClassName, int nMaxCount);
public static extern bool ShowWindow(HWND hWnd, SW nCmdShow);
public static extern bool SetWindowSubclass(HWND hwnd, SUBCLASSPROC callback, IntPtr id, IntPtr data);
public static extern bool SetWindowPos(HWND hwnd, HWND hWndInsertAfter, int X, int Y, int cx, int cy, SWP uFlags);
public static IntPtr SetWindowLongPtr(HWND hwnd, GWL nIndex, IntPtr dwNewLong)
{
if (IntPtr.Size == 4) {
// The SetWindowLongPtr entrypoint may not exist on 32-bit
// OSes, so use the legacy SetWindowLong function instead.
return new IntPtr(SetWindowLong(hwnd, nIndex, dwNewLong.ToInt32()));
} else {
return _SetWindowLongPtr(hwnd, nIndex, dwNewLong);
}
}
public static extern int SetWindowLong(HWND hwnd, GWL nIndex, int dwNewLong);
private static extern IntPtr _SetWindowLongPtr(HWND hwnd, GWL nIndex, IntPtr dwNewLong);
protected virtual void Dispose(bool disposing)
{
if (_hwnd == null || !IsCorrectThread(_hwnd)) {
throw new InvalidOperationException("Dispose virtual should only be called by WindowSubclass once on the correct thread.");
}
NativeMethods.RemoveWindowSubclass(_hwnd, _wndproc, IntPtr.Zero);
_hwnd = null;
}
public static extern IntPtr CallWindowProc(WNDPROC lpPrevWndFunc, HWND hWnd, int Msg, IntPtr wParam, IntPtr lParam);
private bool IsCorrectThread(HWND hwnd)
{
int processId;
int threadId = NativeMethods.GetWindowThreadProcessId(hwnd, out processId);
return (processId == NativeMethods.GetCurrentProcessId() && threadId == NativeMethods.GetCurrentThreadId());
}
public static extern bool ClientToScreen(HWND hwnd, ref POINT lpPoint);
private IntPtr WndProcStub(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, IntPtr id, IntPtr data)
{
HWND hwnd2 = new HWND(hwnd);
return WndProc(hwnd2, (WM)msg, wParam, lParam, id, data);
}
public static extern HWND CreateWindowEx(WS_EX dwExStyle, string lpClassName, string lpWindowName, WS dwStyle, int x, int y, int nWidth, int nHeight, HWND hWndParent, IntPtr hMenu, IntPtr hInstance, IntPtr lpParam);
public bool Equals(HWND other)
{
if (Object.ReferenceEquals(other, null)) {
return handle == IntPtr.Zero;
} else {
return other.handle == handle;
}
}
public static extern IntPtr DefSubclassProc(HWND hwnd, WM msg, IntPtr wParam, IntPtr lParam);
/// <summary>
/// Called from WindowClass.CreateWindow to intialize this instance
/// when the HWND has been created.
/// </summary>
/// <param name="hwnd">
/// The HWND that was created.
/// </param>
/// <param name="param">
/// The creation parameter that was passsed to
/// WindowClass.CreateWindow.
/// </param>
internal IntPtr InitializeFromFirstMessage(IntPtr hwnd, int message, IntPtr wParam, IntPtr lParam)
{
_hwnd = new HWND(hwnd);
// Replace the window proceedure for this window instance.
IntPtr wndProc = Marshal.GetFunctionPointerForDelegate(_wndProc);
NativeMethods.SetWindowLongPtr(_hwnd, GWL.WNDPROC, wndProc);
// Give the window a chance to initialize.
Initialize();
// Manually invoke the window proceedure for this message.
return OnMessage((WM)message, wParam, lParam);
}
public static extern IntPtr DefWindowProc(HWND hWnd, WM Msg, IntPtr wParam, IntPtr lParam);
protected virtual void Dispose(bool disposing)
{
if (disposing) {
StrongHWND strongHwnd = _hwnd as StrongHWND;
if (strongHwnd != null) {
// Replace the StrongHWND reference with a regular "weak"
// HWND reference so that messages processed during
// disposing do not have to deal with a partially disposed
// SafeHandle.
_hwnd = new HWND(strongHwnd.DangerousGetHandle());
strongHwnd.Dispose();
// All done, replace the "weak" HWND reference with null.
_hwnd = null;
}
}
}
public static StrongHWND CreateWindowEx(WS_EX dwExStyle, string lpClassName, string lpWindowName, WS dwStyle, int x, int y, int nWidth, int nHeight, HWND hWndParent, IntPtr hMenu, IntPtr hInstance, IntPtr lpParam)
{
HWND hwnd = NativeMethods.CreateWindowEx(dwExStyle, lpClassName, lpWindowName, dwStyle, x, y, nWidth, nHeight, hWndParent, hMenu, hInstance, lpParam);
return new StrongHWND(hwnd.DangerousGetHandle());
}
protected override sealed void DestroyWindowOverride(HWND hwnd)
{
Debug.Assert(hwnd.DangerousGetHandle() == _hwndSource.Handle);
_hwndSource.Dispose();
_hwndSource = null;
}
public static extern bool SetLayeredWindowAttributes(HWND hwnd, uint crKey, byte bAlpha, LWA dwFlags);
