jrhodnik
/
VRDash
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
VRDash/VDash/Utilities/User32.cs

597 lines
30 KiB
C#
Raw Blame History

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
{
/// <summary>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.</summary>
/// <remarks>SWP_ASYNCWINDOWPOS</remarks>
AsynchronousWindowPosition = 0x4000,
/// <summary>Prevents generation of the WM_SYNCPAINT message.</summary>
/// <remarks>SWP_DEFERERASE</remarks>
DeferErase = 0x2000,
/// <summary>Draws a frame (defined in the window's class description) around the window.</summary>
/// <remarks>SWP_DRAWFRAME</remarks>
DrawFrame = 0x0020,
/// <summary>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.</summary>
/// <remarks>SWP_FRAMECHANGED</remarks>
FrameChanged = 0x0020,
/// <summary>Hides the window.</summary>
/// <remarks>SWP_HIDEWINDOW</remarks>
HideWindow = 0x0080,
/// <summary>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).</summary>
/// <remarks>SWP_NOACTIVATE</remarks>
DoNotActivate = 0x0010,
/// <summary>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.</summary>
/// <remarks>SWP_NOCOPYBITS</remarks>
DoNotCopyBits = 0x0100,
/// <summary>Retains the current position (ignores X and Y parameters).</summary>
/// <remarks>SWP_NOMOVE</remarks>
IgnoreMove = 0x0002,
/// <summary>Does not change the owner window's position in the Z order.</summary>
/// <remarks>SWP_NOOWNERZORDER</remarks>
DoNotChangeOwnerZOrder = 0x0200,
/// <summary>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.</summary>
/// <remarks>SWP_NOREDRAW</remarks>
DoNotRedraw = 0x0008,
/// <summary>Same as the SWP_NOOWNERZORDER flag.</summary>
/// <remarks>SWP_NOREPOSITION</remarks>
DoNotReposition = 0x0200,
/// <summary>Prevents the window from receiving the WM_WINDOWPOSCHANGING message.</summary>
/// <remarks>SWP_NOSENDCHANGING</remarks>
DoNotSendChangingEvent = 0x0400,
/// <summary>Retains the current size (ignores the cx and cy parameters).</summary>
/// <remarks>SWP_NOSIZE</remarks>
IgnoreResize = 0x0001,
/// <summary>Retains the current Z order (ignores the hWndInsertAfter parameter).</summary>
/// <remarks>SWP_NOZORDER</remarks>
IgnoreZOrder = 0x0004,
/// <summary>Displays the window.</summary>
/// <remarks>SWP_SHOWWINDOW</remarks>
ShowWindow = 0x0040,
}
/// <summary>
/// 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.
/// <para>See https://msdn.microsoft.com/en-us/library/windows/desktop/ms633545%28v=vs.85%29.aspx for more information.</para>
/// </summary>
/// <param name="hWnd">C++ ( hWnd [in]. Type: HWND )<br />A handle to the window.</param>
/// <param name="hWndInsertAfter">
/// C++ ( hWndInsertAfter [in, optional]. Type: HWND )<br />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.
/// <list type="table">
/// <itemheader>
/// <term>HWND placement</term><description>Window to precede placement</description>
/// </itemheader>
/// <item>
/// <term>HWND_BOTTOM ((HWND)1)</term>
/// <description>
/// 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.
/// </description>
/// </item>
/// <item>
/// <term>HWND_NOTOPMOST ((HWND)-2)</term>
/// <description>
/// 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.
/// </description>
/// </item>
/// <item>
/// <term>HWND_TOP ((HWND)0)</term><description>Places the window at the top of the Z order.</description>
/// </item>
/// <item>
/// <term>HWND_TOPMOST ((HWND)-1)</term>
/// <description>
/// Places the window above all non-topmost windows. The window maintains its topmost position
/// even when it is deactivated.
/// </description>
/// </item>
/// </list>
/// <para>For more information about how this parameter is used, see the following Remarks section.</para>
/// </param>
/// <param name="X">C++ ( X [in]. Type: int )<br />The new position of the left side of the window, in client coordinates.</param>
/// <param name="Y">C++ ( Y [in]. Type: int )<br />The new position of the top of the window, in client coordinates.</param>
/// <param name="cx">C++ ( cx [in]. Type: int )<br />The new width of the window, in pixels.</param>
/// <param name="cy">C++ ( cy [in]. Type: int )<br />The new height of the window, in pixels.</param>
/// <param name="uFlags">
/// C++ ( uFlags [in]. Type: UINT )<br />The window sizing and positioning flags. This parameter can be a combination
/// of the following values.
/// <list type="table">
/// <itemheader>
/// <term>HWND sizing and positioning flags</term>
/// <description>Where to place and size window. Can be a combination of any</description>
/// </itemheader>
/// <item>
/// <term>SWP_ASYNCWINDOWPOS (0x4000)</term>
/// <description>
/// 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.
/// </description>
/// </item>
/// <item>
/// <term>SWP_DEFERERASE (0x2000)</term>
/// <description>Prevents generation of the WM_SYNCPAINT message. </description>
/// </item>
/// <item>
/// <term>SWP_DRAWFRAME (0x0020)</term>
/// <description>Draws a frame (defined in the window's class description) around the window.</description>
/// </item>
/// <item>
/// <term>SWP_FRAMECHANGED (0x0020)</term>
/// <description>
/// 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
/// </description>
/// </item>
/// <item>
/// <term>SWP_HIDEWINDOW (0x0080)</term><description>Hides the window.</description>
/// </item>
/// <item>
/// <term>SWP_NOACTIVATE (0x0010)</term>
/// <description>
/// 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).
/// </description>
/// </item>
/// <item>
/// <term>SWP_NOCOPYBITS (0x0100)</term>
/// <description>
/// 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.
/// </description>
/// </item>
/// <item>
/// <term>SWP_NOMOVE (0x0002)</term>
/// <description>Retains the current position (ignores X and Y parameters).</description>
/// </item>
/// <item>
/// <term>SWP_NOOWNERZORDER (0x0200)</term>
/// <description>Does not change the owner window's position in the Z order.</description>
/// </item>
/// <item>
/// <term>SWP_NOREDRAW (0x0008)</term>
/// <description>
/// 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.
/// </description>
/// </item>
/// <item>
/// <term>SWP_NOREPOSITION (0x0200)</term><description>Same as the SWP_NOOWNERZORDER flag.</description>
/// </item>
/// <item>
/// <term>SWP_NOSENDCHANGING (0x0400)</term>
/// <description>Prevents the window from receiving the WM_WINDOWPOSCHANGING message.</description>
/// </item>
/// <item>
/// <term>SWP_NOSIZE (0x0001)</term>
/// <description>Retains the current size (ignores the cx and cy parameters).</description>
/// </item>
/// <item>
/// <term>SWP_NOZORDER (0x0004)</term>
/// <description>Retains the current Z order (ignores the hWndInsertAfter parameter).</description>
/// </item>
/// <item>
/// <term>SWP_SHOWWINDOW (0x0040)</term><description>Displays the window.</description>
/// </item>
/// </list>
/// </param>
/// <returns><c>true</c> or nonzero if the function succeeds, <c>false</c> or zero otherwise or if function fails.</returns>
/// <remarks>
/// <para>
/// 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.
/// </para>
/// <para>
/// 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.
/// </para>
/// <para>
/// 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.
/// </para>
/// <para>
/// 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.
/// </para>
/// <list type="bullet">
/// <item>Neither the HWND_TOPMOST nor HWND_NOTOPMOST flag is specified in hWndInsertAfter. </item>
/// <item>The window identified by hWnd is not the active window. </item>
/// </list>
/// <para>
/// 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.
/// </para>
/// <para>
/// 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.
/// </para>
/// <para>
/// 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.
/// </para>
/// <para>
/// If an application is not in the foreground, and should be in the foreground, it must call the
/// SetForegroundWindow function.
/// </para>
/// <para>
/// To use SetWindowPos to bring a window to the top, the process that owns the window must have
/// SetForegroundWindow permission.
/// </para>
/// </remarks>
[DllImport("user32.dll", SetLastError = true)]
public static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int X, int Y, int cx, int cy, SetWindowPosFlags uFlags);
/// <summary>
/// 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.
/// <para>See for https://msdn.microsoft.com/en-us/library/windows/desktop/ms633539%28v=vs.85%29.aspx more information.</para>
/// </summary>
/// <param name="hWnd">
/// C++ ( hWnd [in]. Type: HWND )<br />A handle to the window that should be activated and brought to the foreground.
/// </param>
/// <returns>
/// <c>true</c> or nonzero if the window was brought to the foreground, <c>false</c> or zero If the window was not
/// brought to the foreground.
/// </returns>
/// <remarks>
/// 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:
/// <list type="bullet">
/// <listheader>
/// <term>Conditions</term><description></description>
/// </listheader>
/// <item>The process is the foreground process.</item>
/// <item>The process was started by the foreground process.</item>
/// <item>The process received the last input event.</item>
/// <item>There is no foreground process.</item>
/// <item>The process is being debugged.</item>
/// <item>The foreground process is not a Modern Application or the Start Screen.</item>
/// <item>The foreground is not locked (see LockSetForegroundWindow).</item>
/// <item>The foreground lock time-out has expired (see SPI_GETFOREGROUNDLOCKTIMEOUT in SystemParametersInfo).</item>
/// <item>No menus are active.</item>
/// </list>
/// <para>
/// 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.
/// </para>
/// <para>
/// 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.
/// </para>
/// <para>
/// The foreground process can disable calls to SetForegroundWindow by calling the LockSetForegroundWindow
/// function.
/// </para>
/// </remarks>
// For Windows Mobile, replace user32.dll with coredll.dll
[DllImport("user32.dll")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool SetForegroundWindow(IntPtr hWnd);
/// <summary>
/// Retrieves the show state and the restored, minimized, and maximized positions of the specified window.
/// </summary>
/// <param name="hWnd">
/// A handle to the window.
/// </param>
/// <param name="lpwndpl">
/// A pointer to the WINDOWPLACEMENT structure that receives the show state and position information.
/// <para>
/// Before calling GetWindowPlacement, set the length member to sizeof(WINDOWPLACEMENT). GetWindowPlacement fails if lpwndpl-> length is not set correctly.
/// </para>
/// </param>
/// <returns>
/// If the function succeeds, the return value is nonzero.
/// <para>
/// If the function fails, the return value is zero. To get extended error information, call GetLastError.
/// </para>
/// </returns>
[DllImport("user32.dll", SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool GetWindowPlacement(IntPtr hWnd, ref WINDOWPLACEMENT lpwndpl);
/// <summary>
/// Sets the show state and the restored, minimized, and maximized positions of the specified window.
/// </summary>
/// <param name="hWnd">
/// A handle to the window.
/// </param>
/// <param name="lpwndpl">
/// A pointer to a WINDOWPLACEMENT structure that specifies the new show state and window positions.
/// <para>
/// Before calling SetWindowPlacement, set the length member of the WINDOWPLACEMENT structure to sizeof(WINDOWPLACEMENT). SetWindowPlacement fails if the length member is not set correctly.
/// </para>
/// </param>
/// <returns>
/// If the function succeeds, the return value is nonzero.
/// <para>
/// If the function fails, the return value is zero. To get extended error information, call GetLastError.
/// </para>
/// </returns>
[DllImport("user32.dll", SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool SetWindowPlacement(IntPtr hWnd, [In] ref WINDOWPLACEMENT lpwndpl);
/// <summary>
/// Contains information about the placement of a window on the screen.
/// </summary>
[Serializable]
[StructLayout(LayoutKind.Sequential)]
public struct WINDOWPLACEMENT
{
/// <summary>
/// The length of the structure, in bytes. Before calling the GetWindowPlacement or SetWindowPlacement functions, set this member to sizeof(WINDOWPLACEMENT).
/// <para>
/// GetWindowPlacement and SetWindowPlacement fail if this member is not set correctly.
/// </para>
/// </summary>
public int Length;
/// <summary>
/// Specifies flags that control the position of the minimized window and the method by which the window is restored.
/// </summary>
public int Flags;
/// <summary>
/// The current show state of the window.
/// </summary>
public ShowWindowCommands ShowCmd;
/// <summary>
/// The coordinates of the window's upper-left corner when the window is minimized.
/// </summary>
public Point MinPosition;
/// <summary>
/// The coordinates of the window's upper-left corner when the window is maximized.
/// </summary>
public Point MaxPosition;
/// <summary>
/// The window's coordinates when the window is in the restored position.
/// </summary>
public Rect NormalPosition;
/// <summary>
/// Gets the default (empty) value.
/// </summary>
public static WINDOWPLACEMENT Default
{
get
{
WINDOWPLACEMENT result = new WINDOWPLACEMENT();
result.Length = Marshal.SizeOf(result);
return result;
}
}
}
public enum ShowWindowCommands
{
/// <summary>
/// Hides the window and activates another window.
/// </summary>
Hide = 0,
/// <summary>
/// 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.
/// </summary>
Normal = 1,
/// <summary>
/// Activates the window and displays it as a minimized window.
/// </summary>
ShowMinimized = 2,
/// <summary>
/// Maximizes the specified window.
/// </summary>
Maximize = 3, // is this the right value?
/// <summary>
/// Activates the window and displays it as a maximized window.
/// </summary>
ShowMaximized = 3,
/// <summary>
/// Displays a window in its most recent size and position. This value
/// is similar to <see cref="Win32.ShowWindowCommand.Normal"/>, except
/// the window is not activated.
/// </summary>
ShowNoActivate = 4,
/// <summary>
/// Activates the window and displays it in its current size and position.
/// </summary>
Show = 5,
/// <summary>
/// Minimizes the specified window and activates the next top-level
/// window in the Z order.
/// </summary>
Minimize = 6,
/// <summary>
/// Displays the window as a minimized window. This value is similar to
/// <see cref="Win32.ShowWindowCommand.ShowMinimized"/>, except the
/// window is not activated.
/// </summary>
ShowMinNoActive = 7,
/// <summary>
/// Displays the window in its current size and position. This value is
/// similar to <see cref="Win32.ShowWindowCommand.Show"/>, except the
/// window is not activated.
/// </summary>
ShowNA = 8,
/// <summary>
/// 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.
/// </summary>
Restore = 9,
/// <summary>
/// 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.
/// </summary>
ShowDefault = 10,
/// <summary>
/// <b>Windows 2000/XP:</b> 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.
/// </summary>
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);
}
}
Reference in New Issue View Git Blame Copy Permalink