public static void SetTimer(HandleRef hWnd, int nIDEvent, int uElapse)
{
if (SafeNativeMethodsPrivate.SetTimer(hWnd, nIDEvent, uElapse, null) == IntPtr.Zero)
{
throw new Win32Exception();
}
}
public static void QueryPerformanceFrequency(out long lpFrequency)
{
if (!SafeNativeMethodsPrivate.QueryPerformanceFrequency(out lpFrequency))
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
}
internal static void GetWindowRect(HandleRef hWnd, [In, Out] ref NativeMethods.RECT rect)
{
if (!SafeNativeMethodsPrivate.IntGetWindowRect(hWnd, ref rect))
{
throw new Win32Exception();
}
}
internal static void GetMonitorInfo(HandleRef hmonitor, [In, Out] NativeMethods.MONITORINFOEX info)
{
if (SafeNativeMethodsPrivate.IntGetMonitorInfo(hmonitor, info) == false)
{
throw new Win32Exception();
}
}
// not used by compiler - don't include.
public static void ScreenToClient(HandleRef hWnd, [In, Out] NativeMethods.POINT pt)
{
if (SafeNativeMethodsPrivate.IntScreenToClient(hWnd, pt) == 0)
{
throw new Win32Exception();
}
}
// Note: this returns true or false for success. We still don't have an overload
// that returns the timer ID.
public static bool TrySetTimer(HandleRef hWnd, int nIDEvent, int uElapse)
{
if (SafeNativeMethodsPrivate.TrySetTimer(hWnd, nIDEvent, uElapse, null) == IntPtr.Zero)
{
return(false);
}
return(true);
}
public static int GetCaretBlinkTime()
{
// To be consistent with our other PInvoke wrappers
// we should "throw" a Win32Exception on error here.
// But we don't want to introduce new "throws" w/o
// time to follow up on any new problems that causes.
return(SafeNativeMethodsPrivate.GetCaretBlinkTime());
}
public static NativeMethods.CursorHandle LoadCursor(HandleRef hInst, IntPtr iconId)
{
NativeMethods.CursorHandle cursorHandle = SafeNativeMethodsPrivate.LoadCursor(hInst, iconId);
if (cursorHandle == null || cursorHandle.IsInvalid)
{
throw new Win32Exception();
}
return(cursorHandle);
}
internal static bool AdjustWindowRectEx(ref RECT lpRect, int dwStyle, bool bMenu, int dwExStyle)
{
var returnValue = SafeNativeMethodsPrivate.IntAdjustWindowRectEx(ref lpRect, dwStyle, bMenu, dwExStyle);
if (returnValue == false)
{
throw new Win32Exception();
}
return(returnValue);
}
internal static bool ReleaseCapture()
{
var returnValue = SafeNativeMethodsPrivate.IntReleaseCapture();
if (returnValue == false)
{
throw new Win32Exception();
}
return(returnValue);
}
public static bool TrackMouseEvent(NativeMethods.TRACKMOUSEEVENT tme)
{
bool retVal = SafeNativeMethodsPrivate.TrackMouseEvent(tme);
int win32Err = Marshal.GetLastWin32Error(); // Dance around FxCop
if (!retVal && win32Err != 0)
{
throw new System.ComponentModel.Win32Exception(win32Err);
}
return(retVal);
}
/// <summary>
/// Retrieves the dots per inch (dpi) awareness of the specified process
/// </summary>
/// <param name="hProcess">[in]
/// Handle of the process that is being queried. If this parameter
/// is null, the current process is queried.
/// </param>
/// <returns>The <see cref="NativeMethods.PROCESS_DPI_AWARENESS"/> of the specified process</returns>
/// <exception cref="ArgumentException">The handle <paramref name="hProcess"/> is not valid</exception>
/// <exception cref="UnauthorizedAccessException">The application does not have sufficient priviliges</exception>
/// <exception cref="COMException">
/// The call to Win32 GetProcessDpiAwareness function failed with some other error.
/// The error code in the exception object will contain the corresponding HRESULT
/// </exception>
/// <remarks>
/// - See remarks for <see cref="SafeNativeMethodsPrivate.GetProcessDpiAwareness(HandleRef, out IntPtr)"/>
/// - Minimum supported client: Windows 8.1
/// </remarks>
internal static NativeMethods.PROCESS_DPI_AWARENESS GetProcessDpiAwareness(HandleRef hProcess)
{
var ptrProcessDpiAwareness = IntPtr.Zero;
var hr = (int)SafeNativeMethodsPrivate.GetProcessDpiAwareness(hProcess, out ptrProcessDpiAwareness);
if (hr != NativeMethods.S_OK)
{
Marshal.ThrowExceptionForHR(hr);
}
return((NativeMethods.PROCESS_DPI_AWARENESS)NativeMethods.IntPtrToInt32(ptrProcessDpiAwareness));
}
public static bool GetStringTypeEx(uint locale, uint infoType, char[] sourceString, int count,
UInt16[] charTypes)
{
bool win32Return = SafeNativeMethodsPrivate.GetStringTypeEx(locale, infoType, sourceString, count, charTypes);
int win32Error = Marshal.GetLastWin32Error();
if (!win32Return)
{
throw new Win32Exception(win32Error);
}
return(win32Return);
}
/// <summary>
/// Returns the ID of the session under which the current process is running
/// </summary>
/// <returns>
/// The session id upon success, null on failure
/// </returns>
public static int?GetCurrentSessionId()
{
int?result = null;
int sessionId;
if (SafeNativeMethodsPrivate.ProcessIdToSessionId(
GetCurrentProcessId(), out sessionId))
{
result = sessionId;
}
return(result);
}
/// <summary>
/// Calculates the required size of the window rectangle, based on the desired size of the
/// client rectangle and the provided DPI. This window rectangle can then be passed to the CreateWindowEx
/// function to create a window with a client area of the desired size.
/// </summary>
/// <param name="lpRect">
/// A pointer to a RECT structure that contains the coordinates of the top-left and bottom-right
/// corners of the desired client area. When the function returns, the structure contains the coordinates
/// of the top-left and bottom-right corners of the window to accommodate the desired client area.
/// </param>
/// <param name="dwStyle">
/// The Window Style of the window whose required size is to be calculated. Note that
/// you cannot specify the WS_OVERLAPPED style.
/// </param>
/// <param name="bMenu">Indicates whether the window has a menu.</param>
/// <param name="dwExStyle">The Extended Window Style of the window whose required size is to be calculated.</param>
/// <param name="dpi">The DPI to use for scaling.</param>
/// <returns>
/// If the function succeeds, the return value is true.
/// If the function fails, the return value is false.
/// To get extended error information, call GetLastError
/// </returns>
/// <remarks>
/// Minimum supported client: Windows 10, version 1607 (RS1)
/// </remarks>
internal static bool AdjustWindowRectExForDpi(
ref NativeMethods.RECT lpRect,
int dwStyle,
bool bMenu,
int dwExStyle,
int dpi)
{
return
(SafeNativeMethodsPrivate.AdjustWindowRectExForDpi(
ref lpRect,
dwStyle,
bMenu,
dwExStyle,
dpi));
}
/// <summary>
/// Identifies whether the given workstation session ID has a WTSConnectState value
/// of WTSActive, or not.
/// </summary>
/// <param name="SessionId">
/// The ID of the workstation session to query. If this is null,
/// then this will default to WTS_CURRENT_SESSION. Note that the ID of the
/// current session will not be queried explicitly.
/// </param>
/// <param name="defaultResult">
/// The default result to return if this method is unable to identify the connection
/// state of the given session ID.
/// </param>
/// <returns>
/// True if the connection state for <paramref name="SessionId"/> is WTSActive;
/// false otherwise
/// <paramref name="defaultResult"/> is returned if WTSQuerySessionInformation
/// fails.
/// </returns>
public static bool IsCurrentSessionConnectStateWTSActive(int?SessionId = null, bool defaultResult = true)
{
IntPtr buffer = IntPtr.Zero;
int bytesReturned;
int sessionId = SessionId.HasValue ? SessionId.Value : NativeMethods.WTS_CURRENT_SESSION;
bool currentSessionConnectState = defaultResult;
try
{
if (SafeNativeMethodsPrivate.WTSQuerySessionInformation(
NativeMethods.WTS_CURRENT_SERVER_HANDLE,
sessionId,
NativeMethods.WTS_INFO_CLASS.WTSConnectState,
out buffer, out bytesReturned) && (bytesReturned >= sizeof(int)))
{
var data = Marshal.ReadInt32(buffer);
if (Enum.IsDefined(typeof(NativeMethods.WTS_CONNECTSTATE_CLASS), data))
{
var connectState = (NativeMethods.WTS_CONNECTSTATE_CLASS)data;
currentSessionConnectState = (connectState == NativeMethods.WTS_CONNECTSTATE_CLASS.WTSActive);
}
}
}
finally
{
try
{
if (buffer != IntPtr.Zero)
{
SafeNativeMethodsPrivate.WTSFreeMemory(buffer);
}
}
catch (Exception e) when(e is Win32Exception || e is SEHException)
{
// We will do nothing and return defaultResult
//
// Note that we don't want to catch and ignore SystemException types
// like AV, OOM etc.
}
}
return(currentSessionConnectState);
}
public static bool IsWindowUnicode(HandleRef hWnd)
{
return(SafeNativeMethodsPrivate.IsWindowUnicode(hWnd));
}
public static bool KillTimer(HandleRef hwnd, int idEvent)
{
return(SafeNativeMethodsPrivate.KillTimer(hwnd, idEvent));
}
public static bool IsWindowEnabled(HandleRef hWnd)
{
return(SafeNativeMethodsPrivate.IsWindowEnabled(hWnd));
}
public static int GetDoubleClickTime()
{
return(SafeNativeMethodsPrivate.GetDoubleClickTime());
}
public static int ShowCursor(bool show)
{
return(SafeNativeMethodsPrivate.ShowCursor(show));
}
public static IntPtr ActivateKeyboardLayout(HandleRef hkl, int uFlags)
{
return(SafeNativeMethodsPrivate.ActivateKeyboardLayout(hkl, uFlags));
}
public static IntPtr GetKeyboardLayout(int dwLayout)
{
return(SafeNativeMethodsPrivate.GetKeyboardLayout(dwLayout));
}
internal static int GetInputState()
{
return(SafeNativeMethodsPrivate.GetInputState());
}
public static IntPtr GetCapture()
{
return(SafeNativeMethodsPrivate.GetCapture());
}
public static int GetCurrentProcessId()
{
return(SafeNativeMethodsPrivate.GetCurrentProcessId());
}
public static int GetCurrentThreadId()
{
return(SafeNativeMethodsPrivate.GetCurrentThreadId());
}
internal static bool InSendMessage()
{
return(SafeNativeMethodsPrivate.InSendMessage());
}
public static int GetMessagePos()
{
return(SafeNativeMethodsPrivate.GetMessagePos());
}
public static int GetQueueStatus(uint flags)
{
return(SafeNativeMethodsPrivate.GetQueueStatus(flags));
}
