/// <summary> /// Gets the selected text of the given window, or the last activate window. /// </summary> /// <param name="sendKeys">The <c>SendKeys.SendWait</c> method.</param> /// <param name="windowHandle">The window.</param> /// <returns>The selected text.</returns> public async Task GetSelectedText(Action <string> sendKeys, IntPtr?windowHandle = null) { IntPtr hwnd = windowHandle ?? this.lastWindow; await Task.Run(() => { if (hwnd != IntPtr.Zero) { // Activate the window, if it's not already. IntPtr active = WindowsApi.GetForegroundWindow(); if (active != hwnd) { this.gotActiveWindow.Reset(); WindowsApi.SetForegroundWindow(hwnd); // Wait for it to be activated. this.gotActiveWindow.WaitOne(3000); } } // Copy the selected text to clipboard this.gotClipboard.Reset(); sendKeys("^c"); // Wait for the clipboard update. this.gotClipboard.WaitOne(3000); }); return; }
/// <summary> /// Gets or sets the current value of filter keys setting. /// </summary> /// <param name="newvalue"></param> /// <returns></returns> public static bool KeyRepeat(bool?newvalue = null) { WindowsApi.FILTERKEYS filterKeys = new WindowsApi.FILTERKEYS { cbSize = Marshal.SizeOf <WindowsApi.FILTERKEYS>() }; WindowsApi.SystemParametersInfoFilterKeys( WindowsApi.SPI_GETFILTERKEYS, filterKeys.cbSize, ref filterKeys, 0); if (newvalue != null) { if (newvalue == true) { filterKeys.dwFlags |= WindowsApi.FILTERKEYS.FKF_FILTERKEYSON; } else { filterKeys.dwFlags &= ~WindowsApi.FILTERKEYS.FKF_FILTERKEYSON; } WindowsApi.SystemParametersInfoFilterKeys( WindowsApi.SPI_SETFILTERKEYS, filterKeys.cbSize, ref filterKeys, 3); } return((filterKeys.dwFlags & WindowsApi.FILTERKEYS.FKF_FILTERKEYSON) == WindowsApi.FILTERKEYS.FKF_FILTERKEYSON); }
public static ProcessorArchitecture?GetProcessorArchitecture() { // var cSystemInfo = new WindowsApi.SYSTEM_INFO(); WindowsApi.SYSTEM_INFO cSystemInfo; WindowsApi.GetSystemInfo(out cSystemInfo); switch (cSystemInfo.dummyUnion.DUMMYSTRUCTNAME.wProcessorArchitecture) { case (UInt16)WindowsApi.ProcessorArchitecture.IA32: return(ProcessorArchitecture.X86); case (UInt16)WindowsApi.ProcessorArchitecture.ARM: return(ProcessorArchitecture.Arm32); //case 6: // PROCESSOR_ARCHITECTURE_IA64 // return ProcessorArchitecture.Itanium; case (UInt16)WindowsApi.ProcessorArchitecture.AMD64: return(ProcessorArchitecture.X64); //case 11: // return ProcessorArchitecture.Neutral; case (UInt16)WindowsApi.ProcessorArchitecture.ARM64: return(ProcessorArchitecture.Arm64); //case 14: // // NOTE: in our tests, x86 emulation on ARM64 just returned "PROCESSOR_ARCHITECTURE_INTEL" (0) // return ProcessorArchitecture.X86; case (UInt16)WindowsApi.ProcessorArchitecture.UNKNOWN: default: return(null); } }
public void Initialise(IntPtr hwnd) { if (this.shellMessage == 0) { this.shellMessage = WindowsApi.RegisterWindowMessage("SHELLHOOK"); WindowsApi.RegisterShellHookWindow(hwnd); WindowsApi.AddClipboardFormatListener(hwnd); } }
public void DeleteKey(String key, String section) { var success = WindowsApi.WritePrivateProfileString(section, key, null, _path); if (success == false) { var hresult = Marshal.GetHRForLastWin32Error(); throw Marshal.GetExceptionForHR(hresult); } }
public void ClearSection(String section) { var success = WindowsApi.WritePrivateProfileSection(section, "", _path); if (success == false) { var hresult = Marshal.GetHRForLastWin32Error(); throw Marshal.GetExceptionForHR(hresult); } }
public static Boolean?GetMouseButtonsAreSwapped() { // first, make sure that a mouse is present if (Mouse.GetMouseIsPresent() == false) { return(null); } var mouseButtonsAreSwapped = WindowsApi.GetSystemMetrics(WindowsApi.SystemMetricIndex.SM_SWAPBUTTON); return(mouseButtonsAreSwapped != 0 ? true : false); }
public static List <DisplayAdapterMonitorInfo> GetAllMonitorsForDisplayAdapter(String displayAdapterName) { var result = new List <DisplayAdapterMonitorInfo>(); var displayAdapterNameAsCharArray = ConvertStringToNullTerminatedCharArray(displayAdapterName); // get the monitors associated with this display adapter UInt32 iMonitor = 0; // var success = true; while (success == true) { var cDisplayDevice = new WindowsApi.DISPLAY_DEVICEW(); cDisplayDevice.Init(); success = WindowsApi.EnumDisplayDevices_Monitor(displayAdapterNameAsCharArray, iMonitor, ref cDisplayDevice, 0); if (success == false) { break; } var monitorDeviceNameAsString = Display.ConvertCharArrayToString(cDisplayDevice.DeviceName); var monitorDeviceStringAsString = Display.ConvertCharArrayToString(cDisplayDevice.DeviceString); var monitorStateFlags = (UInt32)cDisplayDevice.StateFlags; Boolean isAttached = false; if ((monitorStateFlags & (UInt32)WindowsApi.ChildDisplayDeviceStateFlags.DISPLAY_DEVICE_ATTACHED) != 0) { isAttached = true; } // if the monitor is not attached, do not include it in the enumeration; we may modify this logic in the future if/as desired if (isAttached == false) { iMonitor += 1; continue; } Boolean isActive = false; if ((monitorStateFlags & (UInt32)WindowsApi.ChildDisplayDeviceStateFlags.DISPLAY_DEVICE_ACTIVE) != 0) { isActive = true; } var monitorInfo = new DisplayAdapterMonitorInfo(monitorDeviceNameAsString, monitorDeviceStringAsString, isActive); result.Add(monitorInfo); iMonitor += 1; } return(result); }
public static UInt32?GetDpiForWindow(IntPtr handle) { var dpiForWindow = WindowsApi.GetDpiForWindow(handle); if (dpiForWindow == 0) { return(null); } else { return(dpiForWindow); } }
// //public static Size? GetMainDisplayMonitorSizeInPixels_DpiAware(UInt32 dpi) //{ // var width = WindowsApi.GetSystemMetricsForDpi(WindowsApi.SystemMetricIndex.SM_CXSCREEN, dpi); // var height = WindowsApi.GetSystemMetricsForDpi(WindowsApi.SystemMetricIndex.SM_CYSCREEN, dpi); // if (width == 0 || height == 0) // { // return null; // } // return new Size(width, height); //} // TODO: To get the coordinates of the portion of the screen that is not obscured by the system taskbar or by application desktop toolbars, call the SystemParametersInfo function with the SPI_GETWORKAREA value instead // NOTE: this function is not DPI aware (unless the app is DPI-aware) public static Size?GetMainDisplayMonitorFullScreenWindowSizeInPixels() { // TODO: use alternate GetSystemMetricsForDpi in dpi-aware apps // NOTE: GetSystemMetrics returns a scaled DPI value (not the physical number of pixels) var width = WindowsApi.GetSystemMetrics(WindowsApi.SystemMetricIndex.SM_CXFULLSCREEN); var height = WindowsApi.GetSystemMetrics(WindowsApi.SystemMetricIndex.SM_CYFULLSCREEN); if (width == 0 || height == 0) { return(null); } return(new Size(width, height)); }
public static List <DisplayAdapterInfo> GetAllDisplayAdapters() { var result = new List <DisplayAdapterInfo>(); // get a list of all display adapters UInt32 iDisplayAdapter = 0; // var success = true; while (success == true) { var cDisplayDevice = new WindowsApi.DISPLAY_DEVICEW(); cDisplayDevice.Init(); success = WindowsApi.EnumDisplayDevices_DisplayAdapter(IntPtr.Zero, iDisplayAdapter, ref cDisplayDevice, 0); if (success == false) { break; } // verify that the device is attached to the desktop if ((UInt32)(cDisplayDevice.StateFlags & WindowsApi.DisplayDeviceStateFlags.DISPLAY_DEVICE_ATTACHED_TO_DESKTOP) == 0) { iDisplayAdapter += 1; continue; } // verify that the device is not a mirroring psuedodevice if ((UInt32)(cDisplayDevice.StateFlags & WindowsApi.DisplayDeviceStateFlags.DISPLAY_DEVICE_MIRRORING_DRIVER) != 0) { iDisplayAdapter += 1; continue; } var deviceNameAsCharArray = cDisplayDevice.DeviceName; var deviceNameAsString = ConvertCharArrayToString(deviceNameAsCharArray); var isPrimaryDisplayAdapter = false; if ((UInt32)(cDisplayDevice.StateFlags & WindowsApi.DisplayDeviceStateFlags.DISPLAY_DEVICE_PRIMARY_DEVICE) != 0) { isPrimaryDisplayAdapter = true; } var displayAdapterInfo = new DisplayAdapterInfo(deviceNameAsString, isPrimaryDisplayAdapter); result.Add(displayAdapterInfo); iDisplayAdapter += 1; } return(result); }
// //public static Size? GetMainDisplayMonitorFullScreenWindowSizeInPixels_DpiAware(UInt32 dpi) //{ // // NOTE: GetSystemMetrics returns a scaled DPI value (not the physical number of pixels) // var width = WindowsApi.GetSystemMetricsForDpi(WindowsApi.SystemMetricIndex.SM_CXFULLSCREEN, dpi); // var height = WindowsApi.GetSystemMetricsForDpi(WindowsApi.SystemMetricIndex.SM_CYFULLSCREEN, dpi); // if (width == 0 || height == 0) // { // return null; // } // return new Size(width, height); //} // NOTE: this function is not DPI aware (unless the app is DPI-aware) public static Rectangle?GetVirtualScreenBoundsInPixels() { // NOTE: GetSystemMetrics returns a scaled DPI value (not the physical number of pixels) var x = WindowsApi.GetSystemMetrics(WindowsApi.SystemMetricIndex.SM_XVIRTUALSCREEN); var y = WindowsApi.GetSystemMetrics(WindowsApi.SystemMetricIndex.SM_YVIRTUALSCREEN); var width = WindowsApi.GetSystemMetrics(WindowsApi.SystemMetricIndex.SM_CXVIRTUALSCREEN); var height = WindowsApi.GetSystemMetrics(WindowsApi.SystemMetricIndex.SM_CYVIRTUALSCREEN); if (width == 0 || height == 0) { return(null); } return(new Rectangle(x, y, width, height)); }
// NOTE: this function returns True if the display settings can be set, False otherwise // NOTE: this _might_ let us detect if a display change requires a reboot (although we don't yet return a result indicating that reality) public static Boolean TestDisplaySettings(String displayAdapterName, DisplaySettings settings) { var displayAdapterNameAsCharArray = ConvertStringToNullTerminatedCharArray(displayAdapterName); var devmode = settings.devmode; var result = WindowsApi.ChangeDisplaySettingsEx(displayAdapterNameAsCharArray, ref devmode, IntPtr.Zero, (UInt32)WindowsApi.ChangeDisplaySettingsFlags.CDS_TEST, IntPtr.Zero); switch (result) { case WindowsApi.DISP_CHANGE_RESULT.DISP_CHANGE_SUCCESSFUL: return(true); //case WindowsApi.DISP_CHANGE_RESULT.DISP_CHANGE_RESTART: default: return(false); } }
/// <summary> /// A Window procedure - handles window messages for a window. /// Pass this method to HwndSource.AddHook(). /// </summary> /// <param name="hwnd">The window handle.</param> /// <param name="msg">The message.</param> /// <param name="wParam">Message data.</param> /// <param name="lParam">Message data.</param> /// <param name="handled">Set to true if the message has been handled</param> /// <returns>The message result.</returns> public IntPtr WindowProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled) { switch ((WindowsApi.WindowMessages)msg) { case WindowsApi.WindowMessages.WM_CLIPBOARDUPDATE: // The clipboard has been updated. this.gotClipboard.Set(); handled = true; break; default: if (msg == this.shellMessage) { // A window has been activated. if (wParam.ToInt32() == WindowsApi.HSHELL_WINDOWACTIVATED || wParam.ToInt32() == WindowsApi.HSHELL_RUDEAPPACTIVATED) { // The activated window is passed via lParam, but this wasn't accurate // for Modern UI apps. IntPtr window = WindowsApi.GetForegroundWindow(); if (this.activeWindow != window) { this.activeWindow = window; // Ignore the application's window WindowsApi.GetWindowThreadProcessId(window, out uint pid); if (pid != this.processId && pid != 0) { this.lastWindow = window; } this.activeWindowChanged.Set(); } } } break; } return(IntPtr.Zero); }
public String ReadValue(String key, String section) { // NOTE: we are using a maximum value length of 255 characters + null; this is somewhat arbitrary, so enlarge maxValueLength if necessary var maxValueLength = 256; var value = new String(' ', maxValueLength); var actualLength = WindowsApi.GetPrivateProfileString(section, key, "", out value, (UInt32)maxValueLength, _path); var lastWin32Error = Marshal.GetLastWin32Error(); if (lastWin32Error == 0x2) /* file not found*/ { var hresult = Marshal.GetHRForLastWin32Error(); throw Marshal.GetExceptionForHR(hresult); } var result = value.Substring(0, (Int32)actualLength); return(result); }
// NOTE: this function throws an exception if the settings could not be set successfully public static void SetCurrentDisplaySettings(String displayAdapterName, DisplaySettings settings) { /* OPTIONAL FLAGS: * CDS_GLOBAL | CDS_UPDATEREGISTRY // save the updated resolution for all users * CDS_RESET // update the settings even if they're the same as the current settings * CDS_SET_PRIMARY // make this display adapter the primary display adapter * CDS_TEST // tests if the change would be valid [NOTE: this _might_ let us detect if a display change requires a reboot] * CDS_UPDATEREGISTRY // save the display change in the system registry (for the user, unless also using CDS_GLOBAL) * CDS_DISABLE_UNSAFE_MODES // prohibits us from accidentally using unsafe display modes */ var displayAdapterNameAsCharArray = ConvertStringToNullTerminatedCharArray(displayAdapterName); var devmode = settings.devmode; var result = WindowsApi.ChangeDisplaySettingsEx(displayAdapterNameAsCharArray, ref devmode, IntPtr.Zero, 0, IntPtr.Zero); switch (result) { case WindowsApi.DISP_CHANGE_RESULT.DISP_CHANGE_SUCCESSFUL: return; default: throw new Exception("Could not change screen settings; result: " + result); } }
/// <summary> /// Activates a window, does not return until it is activated. /// </summary> /// <param name="hwnd">The handle of the window to activate.</param> private void ActivateWindow(IntPtr hwnd) { if (hwnd != IntPtr.Zero) { // Activate the window, if it's not already. IntPtr active = WindowsApi.GetForegroundWindow(); if (active != hwnd) { // Wait for it to be activated. For unknown reasons, activating the window the first time causes // no window to be activated. The second attempt works. const int timeout = 2000; int start = Environment.TickCount; int timespent = 0; do { WindowsApi.SetForegroundWindow(hwnd); this.activeWindowChanged.Reset(); this.activeWindowChanged.WaitOne(timeout - timespent); timespent = Environment.TickCount - start; } while (this.activeWindow != hwnd && timespent <= timeout); } } }
// NOTE: this function is not DPI aware (unless the app is DPI-aware) public static Size?GetMainDisplayMonitorSizeInPixels() { // implementation option 1: // TODO: use alternate GetSystemMetricsForDpi in dpi-aware apps // NOTE: GetSystemMetrics returns a scaled DPI value (not the physical number of pixels) var width = WindowsApi.GetSystemMetrics(WindowsApi.SystemMetricIndex.SM_CXSCREEN); var height = WindowsApi.GetSystemMetrics(WindowsApi.SystemMetricIndex.SM_CYSCREEN); if (width == 0 || height == 0) { return(null); } // implementation option 2: // TODO: ... width = GetDeviceCaps(hdcPrimaryMonitor, HORZRES); // TODO: ... height = GetDeviceCaps(hdcPrimaryMonitor, VERTRES); //if (width == 0 || height == 0) //{ // return null; //} return(new Size(width, height)); }
public static List <DisplaySettings> GetAllDisplaySettingsForDisplayAdapter(String displayAdapterName) { var result = new List <DisplaySettings>(); var displayAdapterNameAsCharArray = ConvertStringToNullTerminatedCharArray(displayAdapterName); // get the display settings for each graphics mode of this display adapter UInt32 iGraphicsMode = 0; var success = true; while (success == true) { var devmode = new WindowsApi.DEVMODEW(); devmode.Init(); success = WindowsApi.EnumDisplaySettingsEx(displayAdapterNameAsCharArray, iGraphicsMode, ref devmode, 0); if (success == false) { break; } var displaySettings = DisplaySettings.CreateNew(devmode); if (displaySettings == null) { iGraphicsMode += 1; continue; } result.Add(displaySettings.Value); iGraphicsMode += 1; } return(result); }
public static DisplaySettings?GetCurrentDisplaySettingsForDisplayAdapter(String displayAdapterName) { var displayAdapterNameAsCharArray = ConvertStringToNullTerminatedCharArray(displayAdapterName); var success = true; var devmode = new WindowsApi.DEVMODEW(); devmode.Init(); success = WindowsApi.EnumDisplaySettingsEx(displayAdapterNameAsCharArray, WindowsApi.ENUM_CURRENT_SETTINGS, ref devmode, 0); if (success == false) { return(null); } var displaySettings = DisplaySettings.CreateNew(devmode); if (displaySettings == null) { return(null); } return(displaySettings); }
/// <summary> /// Press or depress a key. /// </summary> /// <param name="virtualKey">The virtual key code.</param> /// <param name="pressed">true to press the key, false to release.</param> public static void PressKey(uint virtualKey, bool pressed) { const uint KEYEVENTF_KEYUP = 0x2; WindowsApi.keybd_event((byte)virtualKey, 0, pressed ? 0 : KEYEVENTF_KEYUP, UIntPtr.Zero); }
// NOTE: historically, virtually all Windows machines will believe that a mouse is present: even if no mouse is plugged in, the presence of a "mouse port" can also register as presence of a mouse public static Boolean GetMouseIsPresent() { var mouseIsPresent = WindowsApi.GetSystemMetrics(WindowsApi.SystemMetricIndex.SM_MOUSEPRESENT); return(mouseIsPresent != 0 ? true : false); }
public static Int32 GetNumberOfVisibleDisplayMonitors() { var numberOfVisibleDisplayMonitors = WindowsApi.GetSystemMetrics(WindowsApi.SystemMetricIndex.SM_CMONITORS); return(numberOfVisibleDisplayMonitors); }