public static void DestroyPhysicalMonitors(PHYSICAL_MONITOR[] physicalMonitorArray) { if (!DestroyPhysicalMonitors((uint)physicalMonitorArray.Length, physicalMonitorArray)) { throw new Win32Exception(Marshal.GetLastWin32Error()); } }
public static void SetMonitorBrightness(PHYSICAL_MONITOR physicalMonitor, double brightness, uint dwMinimumBrightness, uint dwMaximumBrightness) { if (!SetMonitorBrightness(physicalMonitor.hPhysicalMonitor, (uint)(dwMinimumBrightness + (dwMaximumBrightness - dwMinimumBrightness) * brightness))) { throw new Win32Exception(Marshal.GetLastWin32Error()); } }
public static void GetDevices(Action <List <PHYSICAL_MONITOR> > handleCallback) { var handles = new List <PHYSICAL_MONITOR>(); // Iterate monitors and retrieve their physical monitor instances EnumDisplayMonitors(IntPtr.Zero, IntPtr.Zero, delegate(IntPtr hMonitor, IntPtr hdcMonitor, ref Rect lprcMonitor, IntPtr dwData) { var supported = GetNumberOfPhysicalMonitorsFromHMONITOR(hMonitor, out uint arrSize); if (!supported) { return(true); } var arr = new PHYSICAL_MONITOR[arrSize]; supported = GetPhysicalMonitorsFromHMONITOR(hMonitor, arrSize, arr); if (!supported) { return(true); } handles.AddRange(arr); return(true); }, IntPtr.Zero); // Callback handleCallback(handles); // Cleanup DestroyPhysicalMonitors((uint)handles.Count, handles.ToArray()); }
private static PHYSICAL_MONITOR[] GetPhysicalMonitors(IntPtr displayMonitorPtr) { Dvxa2.GetNumberOfPhysicalMonitorsFromHMONITOR(displayMonitorPtr, out uint nrPhysicalMonitors); var physMonitors = new PHYSICAL_MONITOR[nrPhysicalMonitors]; Dvxa2.GetPhysicalMonitorsFromHMONITOR(displayMonitorPtr, nrPhysicalMonitors, physMonitors); return(physMonitors); }
public static double GetMonitorBrightness(PHYSICAL_MONITOR physicalMonitor) { if (!GetMonitorBrightness(physicalMonitor.hPhysicalMonitor, out uint dwMinimumBrightness, out uint dwCurrentBrightness, out uint dwMaximumBrightness)) { throw new Win32Exception(Marshal.GetLastWin32Error()); } return((double)(dwCurrentBrightness - dwMinimumBrightness) / (double)(dwMaximumBrightness - dwMinimumBrightness)); }
public static IEnumerable <PhysicalItem> EnumeratePhysicalMonitors(IntPtr monitorHandle) { if (!GetNumberOfPhysicalMonitorsFromHMONITOR( monitorHandle, out uint count)) { Debug.WriteLine($"Failed to get the number of physical monitors. ({Error.CreateMessage()})"); yield break; } if (count == 0) { yield break; } var physicalMonitors = new PHYSICAL_MONITOR[count]; try { if (!GetPhysicalMonitorsFromHMONITOR( monitorHandle, count, physicalMonitors)) { Debug.WriteLine($"Failed to get an array of physical monitors. ({Error.CreateMessage()})"); yield break; } int monitorIndex = 0; foreach (var physicalMonitor in physicalMonitors) { var handle = new SafePhysicalMonitorHandle(physicalMonitor.hPhysicalMonitor); bool isSupported = GetMonitorCapabilities( handle, out MC_CAPS caps, out MC_SUPPORTED_COLOR_TEMPERATURE temperature) && caps.HasFlag(MC_CAPS.MC_CAPS_BRIGHTNESS); //Debug.WriteLine($"Handle: {physicalMonitor.hPhysicalMonitor}"); //Debug.WriteLine($"Description: {physicalMonitor.szPhysicalMonitorDescription}"); //Debug.WriteLine($"IsSupported: {isSupported}"); if (isSupported) { yield return(new PhysicalItem( description: physicalMonitor.szPhysicalMonitorDescription, handle: handle, monitorIndex: monitorIndex)); } monitorIndex++; } } finally { // The physical monitor handles should be destroyed at a later stage. } }
public static double GetMonitorContrast(PHYSICAL_MONITOR physicalMonitor) { uint dwMinimumContrast, dwCurrentContrast, dwMaximumContrast; if (!GetMonitorContrast(physicalMonitor.hPhysicalMonitor, out dwMinimumContrast, out dwCurrentContrast, out dwMaximumContrast)) { throw new Win32Exception(Marshal.GetLastWin32Error()); } return (double)(dwCurrentContrast - dwMinimumContrast) / (double)(dwMaximumContrast - dwMinimumContrast); }
public static double GetMonitorBrightness(PHYSICAL_MONITOR physicalMonitor) { uint dwMinimumBrightness, dwCurrentBrightness, dwMaximumBrightness; if (!GetMonitorBrightness(physicalMonitor.hPhysicalMonitor, out dwMinimumBrightness, out dwCurrentBrightness, out dwMaximumBrightness)) { throw new Win32Exception(Marshal.GetLastWin32Error()); } return (double)(dwCurrentBrightness - dwMinimumBrightness) / (double)(dwMaximumBrightness - dwMinimumBrightness); }
public static uint GetMonitorCapabilities(PHYSICAL_MONITOR physicalMonitor) { uint dwMonitorCapabilities, dwSupportedColorTemperatures; if (!GetMonitorCapabilities(physicalMonitor.hPhysicalMonitor, out dwMonitorCapabilities, out dwSupportedColorTemperatures)) { throw new Win32Exception(Marshal.GetLastWin32Error()); } return(dwMonitorCapabilities); }
public static double GetMonitorContrast(PHYSICAL_MONITOR physicalMonitor) { uint dwMinimumContrast, dwCurrentContrast, dwMaximumContrast; if (!GetMonitorContrast(physicalMonitor.hPhysicalMonitor, out dwMinimumContrast, out dwCurrentContrast, out dwMaximumContrast)) { throw new Win32Exception(Marshal.GetLastWin32Error()); } return((double)(dwCurrentContrast - dwMinimumContrast) / (double)(dwMaximumContrast - dwMinimumContrast)); }
private double GetBrightness(PHYSICAL_MONITOR pHYSICAL_MONITOR) { uint dwMinimumBrightness, dwCurrentBrightness, dwMaximumBrightness; if (!GetMonitorBrightness(pHYSICAL_MONITOR.hPhysicalMonitor, out dwMinimumBrightness, out dwCurrentBrightness, out dwMaximumBrightness)) { throw new Win32Exception(Marshal.GetLastWin32Error()); } return((double)(dwCurrentBrightness - dwMinimumBrightness) / (double)(dwMaximumBrightness - dwMinimumBrightness)); }
public static IEnumerable <PhysicalItem> EnumeratePhysicalMonitors(IntPtr monitorHandle) { if (!GetNumberOfPhysicalMonitorsFromHMONITOR( monitorHandle, out uint count)) { Debug.WriteLine($"Failed to get the number of physical monitors. "); yield break; } if (count == 0) { yield break; } var physicalMonitors = new PHYSICAL_MONITOR[count]; try { if (!GetPhysicalMonitorsFromHMONITOR( monitorHandle, count, physicalMonitors)) { Debug.WriteLine($"Failed to get an array of physical monitors. "); yield break; } int monitorIndex = 0; foreach (var physicalMonitor in physicalMonitors) { var handle = new SafePhysicalMonitorHandle(physicalMonitor.hPhysicalMonitor); bool isHighLevelSupported = GetMonitorCapabilities( handle, out MC_CAPS caps, out _) && caps.HasFlag(MC_CAPS.MC_CAPS_BRIGHTNESS); yield return(new PhysicalItem( description: physicalMonitor.szPhysicalMonitorDescription, monitorIndex: monitorIndex, handle: handle, isHighLevelSupported: isHighLevelSupported)); monitorIndex++; } } finally { // The physical monitor handles should be destroyed at a later stage. } }
public static void SetMonitorEnable(IntPtr windowHandle, bool enable) { uint pdwNumberOfPhysicalMonitors = 0; IntPtr hMonitor = MonitorFromWindow(windowHandle, 1); bool numberOfPhysicalMonitorsFromHmonitor = GetNumberOfPhysicalMonitorsFromHMONITOR(hMonitor, ref pdwNumberOfPhysicalMonitors); var pPhysicalMonitorArray = new PHYSICAL_MONITOR[pdwNumberOfPhysicalMonitors]; GetPhysicalMonitorsFromHMONITOR(hMonitor, pdwNumberOfPhysicalMonitors, pPhysicalMonitorArray); SetVCPFeature(pPhysicalMonitorArray[0].hPhysicalMonitor, PowerMode, enable ? PowerOn : PowerOff); }
public static void SetMonitorBrightness(PHYSICAL_MONITOR physicalMonitor, double brightness) { uint dwMinimumBrightness, dwCurrentBrightness, dwMaximumBrightness; if (!GetMonitorBrightness(physicalMonitor.hPhysicalMonitor, out dwMinimumBrightness, out dwCurrentBrightness, out dwMaximumBrightness)) { throw new Win32Exception(Marshal.GetLastWin32Error()); } if (!SetMonitorBrightness(physicalMonitor.hPhysicalMonitor, (uint)(dwMinimumBrightness + (dwMaximumBrightness - dwMinimumBrightness) * brightness))) { throw new Win32Exception(Marshal.GetLastWin32Error()); } }
public static void Main(string[] args) { var hMonitorList = new List <IntPtr>(); var monitorList = new List <PHYSICAL_MONITOR>(); var gcHandle = GCHandle.Alloc(hMonitorList); NativeInterop.MonitorEnumProc lpfnEnum = delegate(IntPtr hMonitor, IntPtr hDCMonitor, ref RECT lprcMonitor, IntPtr dwData) { var list = (List <IntPtr>)GCHandle.FromIntPtr(dwData).Target; list.Add(hMonitor); return(true); }; if (NativeInterop.EnumDisplayMonitors(IntPtr.Zero, IntPtr.Zero, lpfnEnum, GCHandle.ToIntPtr(gcHandle))) { foreach (var hMonitor in hMonitorList) { var numberOfMonitors = uint.MinValue; if (NativeInterop.GetNumberOfPhysicalMonitorsFromHMONITOR(hMonitor, ref numberOfMonitors)) { var monitors = new PHYSICAL_MONITOR[numberOfMonitors]; if (NativeInterop.GetPhysicalMonitorsFromHMONITOR(hMonitor, numberOfMonitors, monitors)) { foreach (var monitor in monitors) { monitorList.Add(monitor); } } else { throw new Win32Exception(Marshal.GetLastWin32Error()); } } else { throw new Win32Exception(Marshal.GetLastWin32Error()); } } } else { throw new Win32Exception(Marshal.GetLastWin32Error()); } foreach (var monitor in monitorList) { var brightness = NativeInterop.GetMonitorBrightness(monitor); //NativeInterop.SetMonitorBrightness(monitor, (brightness - 0.5)); Console.WriteLine(monitor.MonitorDescription); } NativeInterop.DestroyPhysicalMonitors((uint)monitorList.Count, monitorList.ToArray()); }
public static void SetMonitorContrast(PHYSICAL_MONITOR physicalMonitor, double contrast) { uint dwMinimumContrast, dwCurrentContrast, dwMaximumContrast; if (!GetMonitorContrast(physicalMonitor.hPhysicalMonitor, out dwMinimumContrast, out dwCurrentContrast, out dwMaximumContrast)) { throw new Win32Exception(Marshal.GetLastWin32Error()); } if (!SetMonitorContrast(physicalMonitor.hPhysicalMonitor, (uint)(dwMinimumContrast + (dwMaximumContrast - dwMinimumContrast) * contrast))) { throw new Win32Exception(Marshal.GetLastWin32Error()); } }
public static IEnumerable <PhysicalItem> EnumeratePhysicalMonitors(IntPtr monitorHandle, bool verbose = false) { if (!GetNumberOfPhysicalMonitorsFromHMONITOR( monitorHandle, out uint count)) { Debug.WriteLine($"Failed to get the number of physical monitors. {Error.GetMessage()}"); yield break; } if (count == 0) { yield break; } var physicalMonitors = new PHYSICAL_MONITOR[count]; try { if (!GetPhysicalMonitorsFromHMONITOR( monitorHandle, count, physicalMonitors)) { Debug.WriteLine($"Failed to get an array of physical monitors. {Error.GetMessage()}"); yield break; } int monitorIndex = 0; foreach (var physicalMonitor in physicalMonitors) { var handle = new SafePhysicalMonitorHandle(physicalMonitor.hPhysicalMonitor); //Debug.WriteLine($"Description: {physicalMonitor.szPhysicalMonitorDescription}"); //Debug.WriteLine($"Handle: {physicalMonitor.hPhysicalMonitor}"); yield return(new PhysicalItem( description: physicalMonitor.szPhysicalMonitorDescription, monitorIndex: monitorIndex, handle: handle, capability: GetMonitorCapability(handle, verbose))); monitorIndex++; } } finally { // The physical monitor handles should be destroyed at a later stage. } }
public static PHYSICAL_MONITOR[] GetPhysicalMonitors(IntPtr hMonitor) { uint dwNumberOfPhysicalMonitors; if (!GetNumberOfPhysicalMonitorsFromHMONITOR(hMonitor, out dwNumberOfPhysicalMonitors)) { throw new Win32Exception(Marshal.GetLastWin32Error()); } PHYSICAL_MONITOR[] physicalMonitorArray = new PHYSICAL_MONITOR[dwNumberOfPhysicalMonitors]; if (!GetPhysicalMonitorsFromHMONITOR(hMonitor, dwNumberOfPhysicalMonitors, physicalMonitorArray)) { throw new Win32Exception(Marshal.GetLastWin32Error()); } return physicalMonitorArray; }
public static MonitorExtremums GetMonitorExtremums(PHYSICAL_MONITOR physicalMonitor) { if (!GetMonitorBrightness(physicalMonitor.hPhysicalMonitor, out uint dwMinimumBrightness, out uint dwCurrentBrightness, out uint dwMaximumBrightness)) { throw new Win32Exception(Marshal.GetLastWin32Error()); } return(new MonitorExtremums { Min = dwMinimumBrightness, Max = dwMaximumBrightness, Current = dwCurrentBrightness }); }
private void BTNConnectMonitor_Click(object sender, RoutedEventArgs e) { uint cPhysicalMonitors; var hwnd = new WindowInteropHelper(this).EnsureHandle(); IntPtr CurrentMonitor = MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST); //TBLog.Text += "CurMonitor: " + CurrentMonitor.ToString() + "\n"; //GetMonitorDetailedInformation(CurrentMonitor); if (GetNumberOfPhysicalMonitorsFromHMONITOR(CurrentMonitor, out cPhysicalMonitors) == false) { TBLog.Text += "GetNumberOfPhysicalMonitorsFromHMONITOR Error \n"; return; } TBLog.Text += "Number of Monitor: " + cPhysicalMonitors.ToString() + "\n"; PHYSICAL_MONITOR[] physicalMonitorArray = new PHYSICAL_MONITOR[cPhysicalMonitors]; Array.Clear(physicalMonitorArray, 0, (int)cPhysicalMonitors); if (!GetPhysicalMonitorsFromHMONITOR(CurrentMonitor, cPhysicalMonitors, physicalMonitorArray)) { TBLog.Text += "GetPhysicalMonitorsFromHMONITOR Error \n"; return; } String mystring = new String(physicalMonitorArray[0].szPhysicalMonitorDescription); TBLog.Text += "Name: " + mystring + "\n"; uint uiCapabilityies = 0, uiColorTemp = 0; if (!GetMonitorCapabilities(physicalMonitorArray[0].hPhysicalMonitor, ref uiCapabilityies, ref uiColorTemp)) { TBLog.Text += "Don't Support the MSDN provide API to get Brightness..etc. \nUse the VCP API to get the customize data\n"; } DistinguishCaps(uiCapabilityies, uiColorTemp, physicalMonitorArray); if (CBInternalFunction.IsChecked == true) { ShowInternalCaps(physicalMonitorArray[0].hPhysicalMonitor); } SendVCPCommand(physicalMonitorArray[0].hPhysicalMonitor); DestroyPhysicalMonitors(cPhysicalMonitors, physicalMonitorArray); }
private PHYSICAL_MONITOR[] GetPhysicalMonitors(IntPtr ptr) { var physicalMonitorCount = GetPhysicalMonitorCount(ptr); var monitors = new PHYSICAL_MONITOR[physicalMonitorCount]; if (GetPhysicalMonitorsFromHMONITOR(ptr, physicalMonitorCount, monitors)) { return(monitors); } var error = Marshal.GetLastWin32Error(); throw new Exception($"Cannot get phisical monitor handle! {error}"); }
public static PHYSICAL_MONITOR[] GetPhysicalMonitors(IntPtr hMonitor) { uint dwNumberOfPhysicalMonitors; if (!GetNumberOfPhysicalMonitorsFromHMONITOR(hMonitor, out dwNumberOfPhysicalMonitors)) { throw new Win32Exception(Marshal.GetLastWin32Error()); } PHYSICAL_MONITOR[] physicalMonitorArray = new PHYSICAL_MONITOR[dwNumberOfPhysicalMonitors]; if (!GetPhysicalMonitorsFromHMONITOR(hMonitor, dwNumberOfPhysicalMonitors, physicalMonitorArray)) { throw new Win32Exception(Marshal.GetLastWin32Error()); } return(physicalMonitorArray); }
public static bool SetVCPFeatureByMonitor(IntPtr hMonitor, byte bVCPCode, short dwNewValue) { uint pdwNumberOfPhysicalMonitors = 0; bool res = GetNumberOfPhysicalMonitorsFromHMONITOR(hMonitor, ref pdwNumberOfPhysicalMonitors); if (!res || pdwNumberOfPhysicalMonitors == 0) { return(false); } var pPhysicalMonitorArray = new PHYSICAL_MONITOR[pdwNumberOfPhysicalMonitors]; GetPhysicalMonitorsFromHMONITOR(hMonitor, pdwNumberOfPhysicalMonitors, pPhysicalMonitorArray); res = _SetVCPFeature(pPhysicalMonitorArray[0].hPhysicalMonitor, bVCPCode, dwNewValue); DestroyPhysicalMonitors(pdwNumberOfPhysicalMonitors, ref pPhysicalMonitorArray); return(res); }
private void UpdateMonitors() { DisposeMonitors(this.Monitors); var monitors = new List <MonitorInfo>(); EnumDisplayMonitors(IntPtr.Zero, IntPtr.Zero, (IntPtr hMonitor, IntPtr hdcMonitor, ref Rect lprcMonitor, IntPtr dwData) => { uint physicalMonitorsCount = 0; if (!GetNumberOfPhysicalMonitorsFromHMONITOR(hMonitor, ref physicalMonitorsCount)) { // Cannot get monitor count return(true); } var physicalMonitors = new PHYSICAL_MONITOR[physicalMonitorsCount]; if (!GetPhysicalMonitorsFromHMONITOR(hMonitor, physicalMonitorsCount, physicalMonitors)) { // Cannot get physical monitor handle return(true); } foreach (PHYSICAL_MONITOR physicalMonitor in physicalMonitors) { uint minValue = 0, currentValue = 0, maxValue = 0; if (!GetMonitorBrightness(physicalMonitor.hPhysicalMonitor, ref minValue, ref currentValue, ref maxValue)) { DestroyPhysicalMonitor(physicalMonitor.hPhysicalMonitor); continue; } var info = new MonitorInfo { Handle = physicalMonitor.hPhysicalMonitor, MinValue = minValue, CurrentValue = currentValue, MaxValue = maxValue, }; monitors.Add(info); } return(true); }, IntPtr.Zero); this.Monitors = monitors; }
private static MonitorResult VerifyMonitorCapabilities(IntPtr inMonitor) { IntPtr hMonitor = inMonitor; EnumDisplayMonitors( inMonitor, inMonitor, delegate(IntPtr monitor, IntPtr hdcMonitor, ref Rect lprcMonitor, IntPtr dwData) { hMonitor = monitor; return(true); }, inMonitor); int lastWin32Error = Marshal.GetLastWin32Error(); uint pdwNumberOfPhysicalMonitors = 0u; bool numberOfPhysicalMonitorsFromHmonitor = GetNumberOfPhysicalMonitorsFromHMONITOR( hMonitor, ref pdwNumberOfPhysicalMonitors); lastWin32Error = Marshal.GetLastWin32Error(); PHYSICAL_MONITOR[] pPhysicalMonitorArray = new PHYSICAL_MONITOR[pdwNumberOfPhysicalMonitors]; bool physicalMonitorsFromHmonitor = GetPhysicalMonitorsFromHMONITOR( hMonitor, pdwNumberOfPhysicalMonitors, pPhysicalMonitorArray); lastWin32Error = Marshal.GetLastWin32Error(); uint pdwMonitorCapabilities = 0u; uint pdwSupportedColorTemperatures = 0u; var monitorCapabilities = GetMonitorCapabilities( pPhysicalMonitorArray[0].hPhysicalMonitor, ref pdwMonitorCapabilities, ref pdwSupportedColorTemperatures); lastWin32Error = Marshal.GetLastWin32Error(); bool hasMonitorCapabilities = (((int)MC_CAPS_BRIGHTNESS & pdwMonitorCapabilities) > 0); MonitorResult monitorResult = new MonitorResult(); monitorResult.success = hasMonitorCapabilities; monitorResult.hMonitor = pPhysicalMonitorArray[0].hPhysicalMonitor; return(monitorResult); }
public static void SetBrightnessOffset(PHYSICAL_MONITOR physicalMonitor, double offset, double CurrentBrightness, uint dwMinimumBrightness, uint dwMaximumBrightness) { double brightness = CurrentBrightness + offset; if (brightness > 1) { brightness = 1; } else if (brightness < 0) { brightness = 0; } if (!SetMonitorBrightness(physicalMonitor.hPhysicalMonitor, (uint)(dwMinimumBrightness + (dwMaximumBrightness - dwMinimumBrightness) * brightness))) { throw new Win32Exception(Marshal.GetLastWin32Error()); } }
private static Monitor GetMonitorInternal(IntPtr hMonitor, bool additionalRetrive = false) { var info = new MONITORINFOEX(); info.cbSize = Marshal.SizeOf(info); if (NativeMethods.GetMonitorInfo(hMonitor, ref info)) { var name = info.szDevice; if (additionalRetrive) { var cPhysicalMonitors = 0; if (NativeMethods.GetNumberOfPhysicalMonitorsFromHMONITOR(hMonitor, ref cPhysicalMonitors)) { var closing = false; var numberOfMonitors = 1u; var physicalMonitors = new PHYSICAL_MONITOR[numberOfMonitors]; try { if (NativeMethods.GetPhysicalMonitorsFromHMONITOR(hMonitor, numberOfMonitors, physicalMonitors)) { name = physicalMonitors[0].szPhysicalMonitorDescription; closing = true; } } finally { if (closing) { NativeMethods.DestroyPhysicalMonitors(numberOfMonitors, physicalMonitors); } } } } return(new Monitor(name, info.rcMonitor.ToRect(), info.rcWork.ToRect())); } throw new Win32Exception(Marshal.GetLastWin32Error()); }
public static bool GetContrastSupport(PHYSICAL_MONITOR physicalMonitor) { return((GetMonitorCapabilities(physicalMonitor) & MC_CAPS_CONTRAST) != 0); }
public static IEnumerable <PhysicalItem> EnumeratePhysicalMonitors(IntPtr monitorHandle) { if (!GetNumberOfPhysicalMonitorsFromHMONITOR( monitorHandle, out uint count)) { Debug.WriteLine($"Failed to get the number of physical monitors. ({Error.CreateMessage()})"); yield break; } if (count == 0) { yield break; } var physicalMonitors = new PHYSICAL_MONITOR[count]; try { if (!GetPhysicalMonitorsFromHMONITOR( monitorHandle, count, physicalMonitors)) { Debug.WriteLine($"Failed to get an array of physical monitors. ({Error.CreateMessage()})"); yield break; } int monitorIndex = 0; foreach (var physicalMonitor in physicalMonitors) { var handle = new SafePhysicalMonitorHandle(physicalMonitor.hPhysicalMonitor); bool isBrightnessSupported = GetMonitorCapabilities( handle, out MC_CAPS caps, out MC_SUPPORTED_COLOR_TEMPERATURE _) && caps.HasFlag(MC_CAPS.MC_CAPS_BRIGHTNESS); bool isLowLevel = false; if (!isBrightnessSupported) { if (GetCapabilitiesStringLength( handle, out uint capabilitiesStringLength)) { var capabilitiesString = new StringBuilder((int)capabilitiesStringLength); isLowLevel = isBrightnessSupported = CapabilitiesRequestAndCapabilitiesReply( handle, capabilitiesString, capabilitiesStringLength) && IsLowLevelBrightnessSupported(capabilitiesString.ToString()); } } //Debug.WriteLine($"Description: {physicalMonitor.szPhysicalMonitorDescription}"); //Debug.WriteLine($"Handle: {physicalMonitor.hPhysicalMonitor}"); //Debug.WriteLine($"IsBrighnessSupported: {isBrightnessSupported}"); //Debug.WriteLine($"IsLowLevel: {isLowLevel}"); yield return(new PhysicalItem( description: physicalMonitor.szPhysicalMonitorDescription, monitorIndex: monitorIndex, handle: handle, isBrightnessSupported: isBrightnessSupported, isLowLevel: isLowLevel)); monitorIndex++; } } finally { // The physical monitor handles should be destroyed at a later stage. } }
public static bool GetBrightnessSupport(PHYSICAL_MONITOR physicalMonitor) { return (GetMonitorCapabilities(physicalMonitor) & MC_CAPS_BRIGHTNESS) != 0; }
internal static extern bool DestroyPhysicalMonitors(uint dwPhysicalMonitorArraySize, ref PHYSICAL_MONITOR[] pPhysicalMonitorArray);
public static IEnumerable <PhysicalItem> EnumeratePhysicalMonitors(IntPtr monitorHandle, bool verbose = false) { if (!GetNumberOfPhysicalMonitorsFromHMONITOR( monitorHandle, out uint count)) { Debug.WriteLine($"Failed to get the number of physical monitors. {Error.GetMessage()}"); yield break; } if (count == 0) { yield break; } var physicalMonitors = new PHYSICAL_MONITOR[count]; try { if (!GetPhysicalMonitorsFromHMONITOR( monitorHandle, count, physicalMonitors)) { Debug.WriteLine($"Failed to get an array of physical monitors. {Error.GetMessage()}"); yield break; } int monitorIndex = 0; foreach (var physicalMonitor in physicalMonitors) { var handle = new SafePhysicalMonitorHandle(physicalMonitor.hPhysicalMonitor); bool isHighLevelSupported = GetMonitorCapabilities( handle, out MC_CAPS caps, out _) && caps.HasFlag(MC_CAPS.MC_CAPS_BRIGHTNESS); bool isLowLevelSupported = false; string capabilities = null; if (!isHighLevelSupported || verbose) { if (GetCapabilitiesStringLength( handle, out uint capabilitiesStringLength)) { var capabilitiesString = new StringBuilder((int)capabilitiesStringLength); if (CapabilitiesRequestAndCapabilitiesReply( handle, capabilitiesString, capabilitiesStringLength)) { capabilities = capabilitiesString.ToString(); isLowLevelSupported = IsLowLevelSupported(capabilities); } } } //Debug.WriteLine($"Description: {physicalMonitor.szPhysicalMonitorDescription}"); //Debug.WriteLine($"Handle: {physicalMonitor.hPhysicalMonitor}"); //Debug.WriteLine($"IsHighLevelSupported: {isHighLevelSupported}"); //Debug.WriteLine($"IsLowLevelSupported: {isLowLevelSupported}"); //Debug.WriteLine($"Capabilities: {capabilities}"); yield return(new PhysicalItem( description: physicalMonitor.szPhysicalMonitorDescription, monitorIndex: monitorIndex, handle: handle, isHighLevelSupported: isHighLevelSupported, isLowLevelSupported: isLowLevelSupported, capabilities: verbose ? capabilities : null)); monitorIndex++; } } finally { // The physical monitor handles should be destroyed at a later stage. } }
public static bool GetBrightnessSupport(PHYSICAL_MONITOR physicalMonitor) { return((GetMonitorCapabilities(physicalMonitor) & MC_CAPS_BRIGHTNESS) != 0); }
public static void SetMonitorContrast(PHYSICAL_MONITOR physicalMonitor, double contrast) { uint dwMinimumContrast, dwCurrentContrast, dwMaximumContrast; if (!GetMonitorContrast(physicalMonitor.hPhysicalMonitor, out dwMinimumContrast, out dwCurrentContrast, out dwMaximumContrast)) { throw new Win32Exception(Marshal.GetLastWin32Error()); } if (!SetMonitorContrast(physicalMonitor.hPhysicalMonitor, (uint)(dwMinimumContrast + (dwMaximumContrast - dwMinimumContrast) * contrast))) { throw new Win32Exception(Marshal.GetLastWin32Error()); } }
public static bool GetContrastSupport(PHYSICAL_MONITOR physicalMonitor) { return (GetMonitorCapabilities(physicalMonitor) & MC_CAPS_CONTRAST) != 0; }
internal static extern bool GetPhysicalMonitorsFromHMONITOR(HMONITOR hMonitor, DWORD dwPhysicalMonitorArraySize, ref PHYSICAL_MONITOR pPhysicalMonitorArray);
internal static extern bool GetPhysicalMonitorsFromHMONITOR(IntPtr hMonitor, int physicalMonitorArraySize, ref PHYSICAL_MONITOR physicalMonitorArray);
internal static extern bool DestroyPhysicalMonitors(int physicalMonitorArraySize, ref PHYSICAL_MONITOR physicalMonitorArray);
private void EvBrightnessChange(object sender, EventArrivedEventArgs e) { var arrhMonitor = new List <IntPtr>(); EnumDisplayMonitors(IntPtr.Zero, IntPtr.Zero, (IntPtr hMonitor, IntPtr hdcMonitor, ref Rect lprcMonitor, IntPtr dwData) => { arrhMonitor.Add(hMonitor); return(true); }, IntPtr.Zero); var arrPhysicalMonitor = new List <PHYSICAL_MONITOR>(); foreach (var hMonitor in arrhMonitor) { uint sz; if (!GetNumberOfPhysicalMonitorsFromHMONITOR(hMonitor, out sz)) { var lastError = Marshal.GetLastWin32Error(); Text.PushTextError("BrightnessSync::GetNumberOfPhysicalMonitorsFromHMONITOR failed (0x" + lastError.ToString("X8") + ": " + new Win32Exception(lastError).Message + ")"); return; } PHYSICAL_MONITOR[] pPhysicalMonitorArray = new PHYSICAL_MONITOR[sz]; if (!GetPhysicalMonitorsFromHMONITOR(hMonitor, sz, pPhysicalMonitorArray)) { var lastError = Marshal.GetLastWin32Error(); Text.PushTextError("BrightnessSync::GetPhysicalMonitorsFromHMONITOR failed (0x" + lastError.ToString("X8") + ": " + new Win32Exception(lastError).Message + ")"); return; } arrPhysicalMonitor.AddRange(pPhysicalMonitorArray); } var brightnessPercent = (byte)e.NewEvent.Properties["Brightness"].Value; foreach (var physicalMonitor in arrPhysicalMonitor) { /*MONITOR_CAPABILITIES caps; * MONITOR_SUPPORTED_COLOR_TEMPERATURE temp; * if (!GetMonitorCapabilities(physicalMonitor.hPhysicalMonitor, out caps, out temp)) { * var lastError = Marshal.GetLastWin32Error(); * Text.PushTextError("BrightnessSync::GetMonitorCapabilities failed (0x" + lastError.ToString("X8") + ": " + new Win32Exception(lastError).Message + ")"); * continue; * } * * if (!caps.HasFlag(MONITOR_CAPABILITIES.MC_CAPS_BRIGHTNESS)) { * Text.PushText("Monitor " + physicalMonitor.szPhysicalMonitorDescription + " (0x" + physicalMonitor.hPhysicalMonitor.ToString("X8") + ") doesn't support brightness set/get", ConsoleColor.DarkYellow); * continue; * }*/ uint minBrightness, curBrightness, maxBrightness; if (!GetMonitorBrightness(physicalMonitor.hPhysicalMonitor, out minBrightness, out curBrightness, out maxBrightness)) { var lastError = Marshal.GetLastWin32Error(); Text.PushTextError("BrightnessSync::GetMonitorBrightness failed (0x" + lastError.ToString("X8") + ": " + new Win32Exception(lastError).Message + ")"); continue; } if (!SetMonitorBrightness(physicalMonitor.hPhysicalMonitor, (uint)(brightnessPercent * ((float)maxBrightness / 100)))) { var lastError = Marshal.GetLastWin32Error(); Text.PushTextError("BrightnessSync::SetMonitorBrightness failed (0x" + lastError.ToString("X8") + ": " + new Win32Exception(lastError).Message + ")"); continue; } Text.ImportantMessageAddTimeout(physicalMonitor.szPhysicalMonitorDescription + " -> " + (uint)(brightnessPercent * ((float)maxBrightness / 100)), TimeSpan.FromMilliseconds(500)); //Text.PushTextNormal(physicalMonitor.szPhysicalMonitorDescription + " -> min: " + minBrightness + ", cur: " + curBrightness + ", max: " + maxBrightness); } if (!DestroyPhysicalMonitors((uint)arrPhysicalMonitor.Count, arrPhysicalMonitor.ToArray())) { var lastError = Marshal.GetLastWin32Error(); Text.PushTextError("BrightnessSync::DestroyPhysicalMonitors failed (0x" + lastError.ToString("X8") + ": " + new Win32Exception(lastError).Message + ")"); } }
private static uint GetMonitorCapabilities(PHYSICAL_MONITOR physicalMonitor) { uint dwMonitorCapabilities, dwSupportedColorTemperatures; if (!GetMonitorCapabilities(physicalMonitor.hPhysicalMonitor, out dwMonitorCapabilities, out dwSupportedColorTemperatures)) { throw new Win32Exception(Marshal.GetLastWin32Error()); } return dwMonitorCapabilities; }