private void TestBrightness()
{
var(isGetSuccess, minimum, current, maximum) = MonitorConfiguration.GetBrightness(Handle, IsLowLevelSupported);
var isValid = (minimum < maximum) && (minimum <= current) && (current <= maximum);
GetBrightness = $"Success: {isGetSuccess}" + (isGetSuccess ? $", Valid: {isValid} (Minimum: {minimum}, Current: {current}, Maximum: {maximum})" : string.Empty);
var difference = (uint)(DateTime.Now.Ticks % 6 + 5); // Integer from 5 to 10
var expected = difference;
if (isGetSuccess && isValid)
{
expected = (current - minimum > maximum - current) ? current - difference : current + difference;
expected = Math.Min(maximum, Math.Max(minimum, expected));
}
var isSetSuccess = MonitorConfiguration.SetBrightness(Handle, expected, IsLowLevelSupported);
var(_, _, actual, _) = MonitorConfiguration.GetBrightness(Handle, IsLowLevelSupported);
SetBrightness = $"Success: {isSetSuccess}" + (isSetSuccess ? $", Match: {expected == actual} (Expected: {expected}, Actual: {actual})" : string.Empty);
if (isSetSuccess)
{
MonitorConfiguration.SetBrightness(Handle, current, IsLowLevelSupported);
}
}
private void TestBrightness()
{
var(success, _, current, maximum) = MonitorConfiguration.GetBrightness(Handle, IsLowLevelSupported);
GetBrightness = success;
SetBrightness = MonitorConfiguration.SetBrightness(Handle, Math.Min(maximum, current + 5), IsLowLevelSupported);
if (SetBrightness)
{
MonitorConfiguration.SetBrightness(Handle, current, IsLowLevelSupported);
}
}
private uint _maximum = 100; // Raw maximum brightness (not always 100)
public override bool UpdateBrightness(int brightness = -1)
{
var(success, minimum, current, maximum) = MonitorConfiguration.GetBrightness(_handle, _useLowLevel);
if (!success || !(minimum < maximum) || !(minimum <= current) || !(current <= maximum))
{
this.Brightness = -1;
return(false);
}
this.Brightness = (int)Math.Round((double)(current - minimum) / (maximum - minimum) * 100D, MidpointRounding.AwayFromZero);
this._minimum = minimum;
this._maximum = maximum;
return(true);
}
public async Task PopulateAsync()
{
System = GetSystem();
var sw = new Stopwatch();
var tasks = new[]
{
GetTask(nameof(DeviceItems), () =>
DeviceItems = DeviceContext.EnumerateMonitorDevices().ToArray()),
GetTask(nameof(DisplayMonitorItems), async() =>
{
if (OsVersion.Is10Redstone4OrNewer)
{
DisplayMonitorItems = await DisplayMonitor.GetDisplayMonitorsAsync();
}
}),
GetTask(nameof(DisplayConfigItems), () =>
DisplayConfigItems = DisplayConfig.EnumerateDisplayConfigs().ToArray()),
GetTask(nameof(InstalledItems), () =>
InstalledItems = DeviceInformation.EnumerateInstalledMonitors().ToArray()),
GetTask(nameof(PhysicalItems), () =>
PhysicalItems = DeviceContext.GetMonitorHandles().ToDictionary(
x => x,
x => MonitorConfiguration.EnumeratePhysicalMonitors(x.MonitorHandle, true)
.Select(x => new PhysicalItemPlus(x))
.ToArray())),
GetTask(nameof(DesktopItems), () =>
DesktopItems = MSMonitor.EnumerateDesktopMonitors().ToArray())
};
sw.Start();
ElapsedTime = await Task.WhenAll(tasks);
sw.Stop();
Task <string> GetTask(string name, Action action) =>
Task.Run(() =>
{
action.Invoke();
var elapsed = sw.Elapsed;
return($@"{name,-14} -> {elapsed.ToString($@"{(elapsed.Minutes > 0 ? @"m\:" : string.Empty)}s\.fff")}");
});
}
public override bool SetBrightness(int brightness)
{
if ((brightness < 0) || (100 < brightness))
{
throw new ArgumentOutOfRangeException(nameof(brightness), brightness, "The brightness must be within 0 to 100.");
}
var buffer = (uint)Math.Round(brightness / 100D * (_maximum - _minimum) + _minimum, MidpointRounding.AwayFromZero);
if (MonitorConfiguration.SetBrightness(_handle, buffer, _useLowLevel))
{
this.Brightness = brightness;
return(true);
}
return(false);
}
private uint _maximumContrast = 100; // Raw maximum contrast (not always 100)
public override AccessResult UpdateContrast()
{
var(result, minimum, current, maximum) = MonitorConfiguration.GetContrast(_handle);
if ((result.Status == AccessStatus.Succeeded) && (minimum < maximum) && (minimum <= current) && (current <= maximum))
{
this.Contrast = (int)Math.Round((double)(current - minimum) / (maximum - minimum) * 100D, MidpointRounding.AwayFromZero);
this._minimumContrast = minimum;
this._maximumContrast = maximum;
}
else
{
this.Contrast = -1; // Default
}
return(result);
}
private uint _maximumBrightness = 100; // Raw maximum brightness (not always 100)
public override AccessResult UpdateBrightness(int brightness = -1)
{
var(result, minimum, current, maximum) = MonitorConfiguration.GetBrightness(_handle, _capability.IsHighLevelBrightnessSupported);
if ((result.Status == AccessStatus.Succeeded) && (minimum < maximum) && (minimum <= current) && (current <= maximum))
{
this.Brightness = (int)Math.Round((double)(current - minimum) / (maximum - minimum) * 100D, MidpointRounding.AwayFromZero);
this._minimumBrightness = minimum;
this._maximumBrightness = maximum;
}
else
{
this.Brightness = -1; // Default
}
return(result);
}
private uint _maximum = 100; // Raw maximum brightness (not always 100)
public override AccessResult UpdateBrightness(int brightness = -1)
{
var(result, minimum, current, maximum) = MonitorConfiguration.GetBrightness(_handle, _useLowLevel);
if ((result == AccessResult.Succeeded) && (minimum < maximum) && (minimum <= current) && (current <= maximum))
{
this.Brightness = (int)Math.Round((double)(current - minimum) / (maximum - minimum) * 100D, MidpointRounding.AwayFromZero);
this._minimum = minimum;
this._maximum = maximum;
}
else
{
this.Brightness = -1;
}
return(result);
}
public override AccessResult SetContrast(int contrast)
{
if (contrast is < 0 or > 100)
{
throw new ArgumentOutOfRangeException(nameof(contrast), contrast, "The contrast must be within 0 to 100.");
}
var buffer = (uint)Math.Round(contrast / 100D * (_maximumContrast - _minimumContrast) + _minimumContrast, MidpointRounding.AwayFromZero);
var result = MonitorConfiguration.SetContrast(_handle, buffer);
if (result.Status == AccessStatus.Succeeded)
{
this.Contrast = contrast;
}
return(result);
}
public override AccessResult SetBrightness(int brightness)
{
if (brightness is < 0 or > 100)
{
throw new ArgumentOutOfRangeException(nameof(brightness), brightness, "The brightness must be within 0 to 100.");
}
var buffer = (uint)Math.Round(brightness / 100D * (_maximumBrightness - _minimumBrightness) + _minimumBrightness, MidpointRounding.AwayFromZero);
var result = MonitorConfiguration.SetBrightness(_handle, buffer, _capability.IsHighLevelBrightnessSupported);
if (result.Status == AccessStatus.Succeeded)
{
this.Brightness = brightness;
}
return(result);
}
public async Task PopulateAsync()
{
var sw = new Stopwatch();
var actions = new[]
{
GetAction(nameof(DeviceItems), () =>
DeviceItems = DeviceContext.EnumerateMonitorDevices().ToArray()),
GetAction(nameof(PhysicalItems), () =>
PhysicalItems = DeviceContext.GetMonitorHandles().ToDictionary(
x => x,
x => MonitorConfiguration.EnumeratePhysicalMonitors(x.MonitorHandle, true).ToArray())),
GetAction(nameof(InstalledItems), () =>
InstalledItems = DeviceInstallation.EnumerateInstalledMonitors().ToArray()),
GetAction(nameof(DesktopItems), () =>
DesktopItems = MSMonitor.EnumerateDesktopMonitors().ToArray()),
GetAction(nameof(DisplayItems), async() =>
{
if (OsVersion.Is10Redstone4OrNewer)
{
DisplayItems = await DisplayInformation.GetDisplayMonitorsAsync();
}
})
};
ElapsedTime = new string[actions.Length];
sw.Start();
await Task.WhenAll(actions.Select((x, index) => Task.Run(() => x.Invoke(index))));
sw.Stop();
Action <int> GetAction(string name, Action action) =>
new Action <int>((index) =>
{
action.Invoke();
ElapsedTime[index] = $"{name} -> {sw.ElapsedMilliseconds}";
});
}
public override bool IsInvalid => false; // The validity cannot be checked by the handle.
protected override bool ReleaseHandle()
{
return(MonitorConfiguration.DestroyPhysicalMonitor(handle));
}
private static IEnumerable <IMonitor> EnumerateMonitors(List <DeviceItemPlus> deviceItems)
{
if (!(deviceItems?.Any() == true))
{
yield break;
}
// Obtained by DDC/CI
foreach (var handleItem in DeviceContext.GetMonitorHandles())
{
foreach (var physicalItem in MonitorConfiguration.EnumeratePhysicalMonitors(handleItem.MonitorHandle))
{
int index = -1;
if (physicalItem.IsSupported)
{
index = deviceItems.FindIndex(x =>
(x.DisplayIndex == handleItem.DisplayIndex) &&
(x.MonitorIndex == physicalItem.MonitorIndex) &&
string.Equals(x.Description, physicalItem.Description, StringComparison.OrdinalIgnoreCase));
}
if (index < 0)
{
physicalItem.Handle.Dispose();
continue;
}
var deviceItem = deviceItems[index];
yield return(new DdcMonitorItem(
deviceInstanceId: deviceItem.DeviceInstanceId,
description: deviceItem.AlternateDescription,
displayIndex: deviceItem.DisplayIndex,
monitorIndex: deviceItem.MonitorIndex,
handle: physicalItem.Handle,
useLowLevel: physicalItem.IsLowLevelSupported));
deviceItems.RemoveAt(index);
if (deviceItems.Count == 0)
{
yield break;
}
}
}
// Obtained by WMI
var installedItems = DeviceInstallation.EnumerateInstalledMonitors().ToArray();
foreach (var desktopItem in MSMonitor.EnumerateDesktopMonitors())
{
foreach (var installedItem in installedItems)
{
int index = -1;
if (desktopItem.BrightnessLevels.Any())
{
index = deviceItems.FindIndex(x =>
string.Equals(x.DeviceInstanceId, desktopItem.DeviceInstanceId, StringComparison.OrdinalIgnoreCase) &&
string.Equals(x.DeviceInstanceId, installedItem.DeviceInstanceId, StringComparison.OrdinalIgnoreCase));
}
if (index < 0)
{
continue;
}
var deviceItem = deviceItems[index];
yield return(new WmiMonitorItem(
deviceInstanceId: deviceItem.DeviceInstanceId,
description: deviceItem.AlternateDescription,
displayIndex: deviceItem.DisplayIndex,
monitorIndex: deviceItem.MonitorIndex,
brightnessLevels: desktopItem.BrightnessLevels,
isRemovable: installedItem.IsRemovable));
deviceItems.RemoveAt(index);
if (deviceItems.Count == 0)
{
yield break;
}
}
}
// Unreachable neither by DDC/CI nor by WMI
foreach (var deviceItem in deviceItems)
{
yield return(new UnreachableMonitorItem(
deviceInstanceId: deviceItem.DeviceInstanceId,
description: deviceItem.AlternateDescription,
displayIndex: deviceItem.DisplayIndex,
monitorIndex: deviceItem.MonitorIndex,
isInternal: deviceItem.IsInternal));
}
}
