using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
namespace VDash.Utilities
{
public class User32
{
[StructLayout(LayoutKind.Sequential)]
public struct Rect
{
public int left;
public int top;
public int right;
public int bottom;
}
[StructLayout(LayoutKind.Sequential)]
public struct CURSORINFO
{
public Int32 cbSize;
public Int32 flags;
public IntPtr hCursor;
public Point ptScreenPos;
}
public const Int32 CURSOR_SHOWING = 0x00000001;
[DllImport("user32.dll")]
public static extern IntPtr GetWindowRect(IntPtr hWnd, ref Rect rect);
[DllImport("user32.dll")]
public static extern bool GetClientRect(IntPtr hWnd, ref Rect lpRect);
[DllImport("user32.dll")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool SetCursorPos(int x, int y);
[DllImport("user32.dll")]
public static extern bool ClientToScreen(IntPtr hwnd, ref System.Drawing.Point lpPoint);
[DllImport("user32.dll")]
public static extern bool ScreenToClient(IntPtr hWnd, ref System.Drawing.Point lpPoint);
[DllImport("user32.dll")]
public static extern bool GetCursorInfo(out CURSORINFO pci);
[DllImport("user32.dll")]
public static extern bool DrawIcon(IntPtr hDC, int X, int Y, IntPtr hIcon);
[DllImport("user32.dll")]
public static extern void mouse_event(MouseEventFlags dwFlags, int dx, int dy, uint dwData, UIntPtr dwExtraInfo);
public enum MouseEventFlags
{
MOUSEEVENTF_ABSOLUTE = 0x8000,
MOUSEEVENTF_LEFTDOWN = 0x0002,
MOUSEEVENTF_LEFTUP = 0x0004,
MOUSEEVENTF_MIDDLEDOWN = 0x0020,
MOUSEEVENTF_MIDDLEUP = 0x0040,
MOUSEEVENTF_MOVE = 0x0001,
MOUSEEVENTF_RIGHTDOWN = 0x0008,
MOUSEEVENTF_RIGHTUP = 0x0010,
MOUSEEVENTF_XDOWN = 0x0080,
MOUSEEVENTF_XUP = 0x0100,
MOUSEEVENTF_WHEEL = 0x0800,
MOUSEEVENTF_HWHEEL = 0x01000
}
public const int GCL_HICONSM = -34;
public const int GCL_HICON = -14;
public const int ICON_SMALL = 0;
public const int ICON_BIG = 1;
public const int ICON_SMALL2 = 2;
public const int WM_GETICON = 0x7F;
public static IntPtr GetClassLongPtr(IntPtr hWnd, int nIndex)
{
if (IntPtr.Size > 4)
return GetClassLongPtr64(hWnd, nIndex);
else
return new IntPtr(GetClassLongPtr32(hWnd, nIndex));
}
[DllImport("user32.dll", EntryPoint = "GetClassLong")]
public static extern uint GetClassLongPtr32(IntPtr hWnd, int nIndex);
[DllImport("user32.dll", EntryPoint = "GetClassLongPtr")]
public static extern IntPtr GetClassLongPtr64(IntPtr hWnd, int nIndex);
[DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = false)]
static extern IntPtr SendMessage(IntPtr hWnd, int Msg, int wParam, int lParam);
public static Icon GetAppIcon(IntPtr hwnd)
{
IntPtr iconHandle = SendMessage(hwnd, WM_GETICON, ICON_SMALL2, 0);
if (iconHandle == IntPtr.Zero)
iconHandle = SendMessage(hwnd, WM_GETICON, ICON_SMALL, 0);
if (iconHandle == IntPtr.Zero)
iconHandle = SendMessage(hwnd, WM_GETICON, ICON_BIG, 0);
if (iconHandle == IntPtr.Zero)
iconHandle = GetClassLongPtr(hwnd, GCL_HICON);
if (iconHandle == IntPtr.Zero)
iconHandle = GetClassLongPtr(hwnd, GCL_HICONSM);
if (iconHandle == IntPtr.Zero)
return null;
Icon icn = Icon.FromHandle(iconHandle);
return icn;
}
[Flags()]
public enum SetWindowPosFlags : uint
{
/// If the calling thread and the thread that owns the window are attached to different input queues,
/// the system posts the request to the thread that owns the window. This prevents the calling thread from
/// blocking its execution while other threads process the request.
/// SWP_ASYNCWINDOWPOS
AsynchronousWindowPosition = 0x4000,
/// Prevents generation of the WM_SYNCPAINT message.
/// SWP_DEFERERASE
DeferErase = 0x2000,
/// Draws a frame (defined in the window's class description) around the window.
/// SWP_DRAWFRAME
DrawFrame = 0x0020,
/// Applies new frame styles set using the SetWindowLong function. Sends a WM_NCCALCSIZE message to
/// the window, even if the window's size is not being changed. If this flag is not specified, WM_NCCALCSIZE
/// is sent only when the window's size is being changed.
/// SWP_FRAMECHANGED
FrameChanged = 0x0020,
/// Hides the window.
/// SWP_HIDEWINDOW
HideWindow = 0x0080,
/// Does not activate the window. If this flag is not set, the window is activated and moved to the
/// top of either the topmost or non-topmost group (depending on the setting of the hWndInsertAfter
/// parameter).
/// SWP_NOACTIVATE
DoNotActivate = 0x0010,
/// Discards the entire contents of the client area. If this flag is not specified, the valid
/// contents of the client area are saved and copied back into the client area after the window is sized or
/// repositioned.
/// SWP_NOCOPYBITS
DoNotCopyBits = 0x0100,
/// Retains the current position (ignores X and Y parameters).
/// SWP_NOMOVE
IgnoreMove = 0x0002,
/// Does not change the owner window's position in the Z order.
/// SWP_NOOWNERZORDER
DoNotChangeOwnerZOrder = 0x0200,
/// Does not redraw changes. If this flag is set, no repainting of any kind occurs. This applies to
/// the client area, the nonclient area (including the title bar and scroll bars), and any part of the parent
/// window uncovered as a result of the window being moved. When this flag is set, the application must
/// explicitly invalidate or redraw any parts of the window and parent window that need redrawing.
/// SWP_NOREDRAW
DoNotRedraw = 0x0008,
/// Same as the SWP_NOOWNERZORDER flag.
/// SWP_NOREPOSITION
DoNotReposition = 0x0200,
/// Prevents the window from receiving the WM_WINDOWPOSCHANGING message.
/// SWP_NOSENDCHANGING
DoNotSendChangingEvent = 0x0400,
/// Retains the current size (ignores the cx and cy parameters).
/// SWP_NOSIZE
IgnoreResize = 0x0001,
/// Retains the current Z order (ignores the hWndInsertAfter parameter).
/// SWP_NOZORDER
IgnoreZOrder = 0x0004,
/// Displays the window.
/// SWP_SHOWWINDOW
ShowWindow = 0x0040,
}
///
/// Changes the size, position, and Z order of a child, pop-up, or top-level window. These windows are ordered
/// according to their appearance on the screen. The topmost window receives the highest rank and is the first window
/// in the Z order.
/// See https://msdn.microsoft.com/en-us/library/windows/desktop/ms633545%28v=vs.85%29.aspx for more information.
///
/// C++ ( hWnd [in]. Type: HWND )
A handle to the window.
///
/// C++ ( hWndInsertAfter [in, optional]. Type: HWND )
A handle to the window to precede the positioned window in
/// the Z order. This parameter must be a window handle or one of the following values.
///
///
/// HWND placementWindow to precede placement
///
/// -
/// HWND_BOTTOM ((HWND)1)
///
/// Places the window at the bottom of the Z order. If the hWnd parameter identifies a topmost
/// window, the window loses its topmost status and is placed at the bottom of all other windows.
///
///
/// -
/// HWND_NOTOPMOST ((HWND)-2)
///
/// Places the window above all non-topmost windows (that is, behind all topmost windows). This
/// flag has no effect if the window is already a non-topmost window.
///
///
/// -
/// HWND_TOP ((HWND)0)Places the window at the top of the Z order.
///
/// -
/// HWND_TOPMOST ((HWND)-1)
///
/// Places the window above all non-topmost windows. The window maintains its topmost position
/// even when it is deactivated.
///
///
///
/// For more information about how this parameter is used, see the following Remarks section.
///
/// C++ ( X [in]. Type: int )
The new position of the left side of the window, in client coordinates.
/// C++ ( Y [in]. Type: int )
The new position of the top of the window, in client coordinates.
/// C++ ( cx [in]. Type: int )
The new width of the window, in pixels.
/// C++ ( cy [in]. Type: int )
The new height of the window, in pixels.
///
/// C++ ( uFlags [in]. Type: UINT )
The window sizing and positioning flags. This parameter can be a combination
/// of the following values.
///
///
/// HWND sizing and positioning flags
/// Where to place and size window. Can be a combination of any
///
/// -
/// SWP_ASYNCWINDOWPOS (0x4000)
///
/// If the calling thread and the thread that owns the window are attached to different input
/// queues, the system posts the request to the thread that owns the window. This prevents the calling
/// thread from blocking its execution while other threads process the request.
///
///
/// -
/// SWP_DEFERERASE (0x2000)
/// Prevents generation of the WM_SYNCPAINT message.
///
/// -
/// SWP_DRAWFRAME (0x0020)
/// Draws a frame (defined in the window's class description) around the window.
///
/// -
/// SWP_FRAMECHANGED (0x0020)
///
/// Applies new frame styles set using the SetWindowLong function. Sends a WM_NCCALCSIZE message
/// to the window, even if the window's size is not being changed. If this flag is not specified,
/// WM_NCCALCSIZE is sent only when the window's size is being changed
///
///
/// -
/// SWP_HIDEWINDOW (0x0080)Hides the window.
///
/// -
/// SWP_NOACTIVATE (0x0010)
///
/// Does not activate the window. If this flag is not set, the window is activated and moved to
/// the top of either the topmost or non-topmost group (depending on the setting of the hWndInsertAfter
/// parameter).
///
///
/// -
/// SWP_NOCOPYBITS (0x0100)
///
/// Discards the entire contents of the client area. If this flag is not specified, the valid
/// contents of the client area are saved and copied back into the client area after the window is sized or
/// repositioned.
///
///
/// -
/// SWP_NOMOVE (0x0002)
/// Retains the current position (ignores X and Y parameters).
///
/// -
/// SWP_NOOWNERZORDER (0x0200)
/// Does not change the owner window's position in the Z order.
///
/// -
/// SWP_NOREDRAW (0x0008)
///
/// Does not redraw changes. If this flag is set, no repainting of any kind occurs. This applies
/// to the client area, the nonclient area (including the title bar and scroll bars), and any part of the
/// parent window uncovered as a result of the window being moved. When this flag is set, the application
/// must explicitly invalidate or redraw any parts of the window and parent window that need redrawing.
///
///
/// -
/// SWP_NOREPOSITION (0x0200)Same as the SWP_NOOWNERZORDER flag.
///
/// -
/// SWP_NOSENDCHANGING (0x0400)
/// Prevents the window from receiving the WM_WINDOWPOSCHANGING message.
///
/// -
/// SWP_NOSIZE (0x0001)
/// Retains the current size (ignores the cx and cy parameters).
///
/// -
/// SWP_NOZORDER (0x0004)
/// Retains the current Z order (ignores the hWndInsertAfter parameter).
///
/// -
/// SWP_SHOWWINDOW (0x0040)Displays the window.
///
///
///
/// true or nonzero if the function succeeds, false or zero otherwise or if function fails.
///
///
/// As part of the Vista re-architecture, all services were moved off the interactive desktop into Session 0.
/// hwnd and window manager operations are only effective inside a session and cross-session attempts to manipulate
/// the hwnd will fail. For more information, see The Windows Vista Developer Story: Application Compatibility
/// Cookbook.
///
///
/// If you have changed certain window data using SetWindowLong, you must call SetWindowPos for the changes to
/// take effect. Use the following combination for uFlags: SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER |
/// SWP_FRAMECHANGED.
///
///
/// A window can be made a topmost window either by setting the hWndInsertAfter parameter to HWND_TOPMOST and
/// ensuring that the SWP_NOZORDER flag is not set, or by setting a window's position in the Z order so that it is
/// above any existing topmost windows. When a non-topmost window is made topmost, its owned windows are also made
/// topmost. Its owners, however, are not changed.
///
///
/// If neither the SWP_NOACTIVATE nor SWP_NOZORDER flag is specified (that is, when the application requests that
/// a window be simultaneously activated and its position in the Z order changed), the value specified in
/// hWndInsertAfter is used only in the following circumstances.
///
///
/// - Neither the HWND_TOPMOST nor HWND_NOTOPMOST flag is specified in hWndInsertAfter.
/// - The window identified by hWnd is not the active window.
///
///
/// An application cannot activate an inactive window without also bringing it to the top of the Z order.
/// Applications can change an activated window's position in the Z order without restrictions, or it can activate
/// a window and then move it to the top of the topmost or non-topmost windows.
///
///
/// If a topmost window is repositioned to the bottom (HWND_BOTTOM) of the Z order or after any non-topmost
/// window, it is no longer topmost. When a topmost window is made non-topmost, its owners and its owned windows
/// are also made non-topmost windows.
///
///
/// A non-topmost window can own a topmost window, but the reverse cannot occur. Any window (for example, a
/// dialog box) owned by a topmost window is itself made a topmost window, to ensure that all owned windows stay
/// above their owner.
///
///
/// If an application is not in the foreground, and should be in the foreground, it must call the
/// SetForegroundWindow function.
///
///
/// To use SetWindowPos to bring a window to the top, the process that owns the window must have
/// SetForegroundWindow permission.
///
///
[DllImport("user32.dll", SetLastError = true)]
public static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int X, int Y, int cx, int cy, SetWindowPosFlags uFlags);
///
/// Brings the thread that created the specified window into the foreground and activates the window. Keyboard input is
/// directed to the window, and various visual cues are changed for the user. The system assigns a slightly higher
/// priority to the thread that created the foreground window than it does to other threads.
/// See for https://msdn.microsoft.com/en-us/library/windows/desktop/ms633539%28v=vs.85%29.aspx more information.
///
///
/// C++ ( hWnd [in]. Type: HWND )
A handle to the window that should be activated and brought to the foreground.
///
///
/// true or nonzero if the window was brought to the foreground, false or zero If the window was not
/// brought to the foreground.
///
///
/// The system restricts which processes can set the foreground window. A process can set the foreground window only if
/// one of the following conditions is true:
///
///
/// Conditions
///
/// - The process is the foreground process.
/// - The process was started by the foreground process.
/// - The process received the last input event.
/// - There is no foreground process.
/// - The process is being debugged.
/// - The foreground process is not a Modern Application or the Start Screen.
/// - The foreground is not locked (see LockSetForegroundWindow).
/// - The foreground lock time-out has expired (see SPI_GETFOREGROUNDLOCKTIMEOUT in SystemParametersInfo).
/// - No menus are active.
///
///
/// An application cannot force a window to the foreground while the user is working with another window.
/// Instead, Windows flashes the taskbar button of the window to notify the user.
///
///
/// A process that can set the foreground window can enable another process to set the foreground window by
/// calling the AllowSetForegroundWindow function. The process specified by dwProcessId loses the ability to set
/// the foreground window the next time the user generates input, unless the input is directed at that process, or
/// the next time a process calls AllowSetForegroundWindow, unless that process is specified.
///
///
/// The foreground process can disable calls to SetForegroundWindow by calling the LockSetForegroundWindow
/// function.
///
///
// For Windows Mobile, replace user32.dll with coredll.dll
[DllImport("user32.dll")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool SetForegroundWindow(IntPtr hWnd);
///
/// Retrieves the show state and the restored, minimized, and maximized positions of the specified window.
///
///
/// A handle to the window.
///
///
/// A pointer to the WINDOWPLACEMENT structure that receives the show state and position information.
///
/// Before calling GetWindowPlacement, set the length member to sizeof(WINDOWPLACEMENT). GetWindowPlacement fails if lpwndpl-> length is not set correctly.
///
///
///
/// If the function succeeds, the return value is nonzero.
///
/// If the function fails, the return value is zero. To get extended error information, call GetLastError.
///
///
[DllImport("user32.dll", SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool GetWindowPlacement(IntPtr hWnd, ref WINDOWPLACEMENT lpwndpl);
///
/// Sets the show state and the restored, minimized, and maximized positions of the specified window.
///
///
/// A handle to the window.
///
///
/// A pointer to a WINDOWPLACEMENT structure that specifies the new show state and window positions.
///
/// Before calling SetWindowPlacement, set the length member of the WINDOWPLACEMENT structure to sizeof(WINDOWPLACEMENT). SetWindowPlacement fails if the length member is not set correctly.
///
///
///
/// If the function succeeds, the return value is nonzero.
///
/// If the function fails, the return value is zero. To get extended error information, call GetLastError.
///
///
[DllImport("user32.dll", SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool SetWindowPlacement(IntPtr hWnd, [In] ref WINDOWPLACEMENT lpwndpl);
///
/// Contains information about the placement of a window on the screen.
///
[Serializable]
[StructLayout(LayoutKind.Sequential)]
public struct WINDOWPLACEMENT
{
///
/// The length of the structure, in bytes. Before calling the GetWindowPlacement or SetWindowPlacement functions, set this member to sizeof(WINDOWPLACEMENT).
///
/// GetWindowPlacement and SetWindowPlacement fail if this member is not set correctly.
///
///
public int Length;
///
/// Specifies flags that control the position of the minimized window and the method by which the window is restored.
///
public int Flags;
///
/// The current show state of the window.
///
public ShowWindowCommands ShowCmd;
///
/// The coordinates of the window's upper-left corner when the window is minimized.
///
public Point MinPosition;
///
/// The coordinates of the window's upper-left corner when the window is maximized.
///
public Point MaxPosition;
///
/// The window's coordinates when the window is in the restored position.
///
public Rect NormalPosition;
///
/// Gets the default (empty) value.
///
public static WINDOWPLACEMENT Default
{
get
{
WINDOWPLACEMENT result = new WINDOWPLACEMENT();
result.Length = Marshal.SizeOf(result);
return result;
}
}
}
public enum ShowWindowCommands
{
///
/// Hides the window and activates another window.
///
Hide = 0,
///
/// Activates and displays a window. If the window is minimized or
/// maximized, the system restores it to its original size and position.
/// An application should specify this flag when displaying the window
/// for the first time.
///
Normal = 1,
///
/// Activates the window and displays it as a minimized window.
///
ShowMinimized = 2,
///
/// Maximizes the specified window.
///
Maximize = 3, // is this the right value?
///
/// Activates the window and displays it as a maximized window.
///
ShowMaximized = 3,
///
/// Displays a window in its most recent size and position. This value
/// is similar to , except
/// the window is not activated.
///
ShowNoActivate = 4,
///
/// Activates the window and displays it in its current size and position.
///
Show = 5,
///
/// Minimizes the specified window and activates the next top-level
/// window in the Z order.
///
Minimize = 6,
///
/// Displays the window as a minimized window. This value is similar to
/// , except the
/// window is not activated.
///
ShowMinNoActive = 7,
///
/// Displays the window in its current size and position. This value is
/// similar to , except the
/// window is not activated.
///
ShowNA = 8,
///
/// Activates and displays the window. If the window is minimized or
/// maximized, the system restores it to its original size and position.
/// An application should specify this flag when restoring a minimized window.
///
Restore = 9,
///
/// Sets the show state based on the SW_* value specified in the
/// STARTUPINFO structure passed to the CreateProcess function by the
/// program that started the application.
///
ShowDefault = 10,
///
/// Windows 2000/XP: Minimizes a window, even if the thread
/// that owns the window is not responding. This flag should only be
/// used when minimizing windows from a different thread.
///
ForceMinimize = 11
}
[DllImport("user32.dll")]
public static extern bool ShowWindow(IntPtr hWnd, ShowWindowCommands nCmdShow);
[DllImport("user32.dll")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool IsWindow(IntPtr hWnd);
}
}