Updated `OpenSettings` and `OnSettingsClick` methods in the
`PowerDisplay` namespace to handle the deployment structure
of PowerDisplay as a WinUI 3 app in a subfolder. The
`mainExecutableIsOnTheParentFolder` parameter is set to `true`
to reflect this structure.
Added a new case for `PowerDisplay` in the `Microsoft.PowerToys.Settings.UI`
namespace to enable navigation to the `PowerDisplayPage` in the
PowerToys Settings UI.
Added `IsTabStop="True"` to `RootGrid` in `MainWindow.xaml` to make it focusable. Updated `DispatcherQueue.TryEnqueue` in `MainWindow.xaml.cs` to clear focus from interactive elements (e.g., sliders) on window open, preventing unwanted tooltips and ensuring a cleaner initial state.
Introduced support for input source control across the app.
- Added `SupportsInputSource` and `EnableInputSource` properties to data models (`FeatureSupportResult`, `MonitorInfo`, etc.).
- Updated `MainViewModel` and `MonitorViewModel` to handle input source visibility (`ShowInputSource`) and initialization.
- Modified XAML bindings to reflect the new `ShowInputSource` property.
- Enhanced `PowerDisplayPage.xaml` with a checkbox for enabling/disabling input source control.
- Added localization for the input source control checkbox.
- Implemented signaling (`SignalSettingsUpdated`) to notify `PowerDisplay` of feature visibility changes.
- Improved logging to include input source feature status.
- Performed general code cleanup and added clarifying comments.
These changes ensure the input source control feature is configurable, persists user preferences, and integrates seamlessly with the existing application.
Removed unused methods across multiple files, including `GetContrastAsync`, `GetVolumeAsync`, and `SaveCurrentSettingsAsync` in `DdcCiController.cs` and `WmiController.cs`. Simplified the `IMonitorController` interface by removing redundant methods.
Replaced `ProcessThemeChangeAsync` with a synchronous `ProcessThemeChange` in `LightSwitchListener.cs`. Changed `ParseVcpCodesToIntegers` visibility to private in `MonitorFeatureHelper.cs` and removed related helper methods.
Eliminated retry logic by removing `ExecuteWithRetryAsync` in `RetryHelper.cs`. Simplified `SetBrightnessAsync` in `MonitorManager.cs` using a generic helper. Streamlined `DisplayName` in `MonitorViewModel.cs` and removed unnecessary property change notifications.
These changes reduce complexity, improve maintainability, and streamline the codebase by removing unused or redundant functionality.
Replaced CsWin32-generated types and P/Invoke methods with
custom `LibraryImport` declarations and primitive types (`nint`,
`nuint`) to improve accessibility and reduce reliance on
CsWin32. Updated `TrayIconService` to use `nint` for handles
and replaced safe handle types. Simplified `WindowProc` logic
and updated methods like `SetupTrayIcon` and `Destroy` to use
new interop methods.
Added custom constants, enums, and structs for window messages
and menu flags. Removed obsolete entries from `NativeMethods.txt`.
These changes enhance maintainability and ensure compatibility
with standard .NET interop practices.
Introduced a `TrayIconService` to manage the system tray icon, enabling quick access to settings and exit options. Added a new `ShowSystemTrayIcon` setting to control tray icon visibility, with UI integration in the settings page.
Implemented `SettingsDeepLink` to open PowerDisplay settings directly in the PowerToys Settings UI. Updated `App.xaml.cs` to integrate tray icon lifecycle management and refresh behavior.
Replaced `ManagedCsWin32` with `CsWin32` for Windows API interop. Added localized strings for tray menu options and updated default settings to enable the tray icon by default. Improved resilience by handling `WM_TASKBAR_RESTART` for tray icon recreation.
Updated the `WmiSetBrightness` method to pass `Timeout` and
`Brightness` parameters as strings instead of numeric types
to ensure compatibility with WMI driver implementations
that require string values. Updated comments to reflect
this change and clarify the reasoning behind it.
Updated the `Brightness` parameter in the `WmiSetBrightness` method to use `int` instead of casting to `byte`, addressing potential `WBEM_E_TYPE_MISMATCH` errors (0x80041005) caused by certain WMI driver implementations expecting `VT_I4` instead of `VT_UI1`.
Added comments to clarify the rationale for this change. Applied the fix in two sections of `WmiController.cs`, including both dynamic and hardcoded `Brightness` values.
Simplified the codebase by removing unused or redundant functionality:
- Removed `State` and `Lifetime` nested classes from `AppConstants`.
- Deleted unused constants from the `UI` nested class in `AppConstants`.
- Removed the `MonitorStatusChangedEventArgs` class from `PowerDisplay.Core.Interfaces`.
- Deleted the `SettingsDeepLink` helper class from `PowerDisplay.Helpers`.
- Cleaned up `WindowHelper` by removing unused constants, P/Invoke declarations, and the `MakeWindowTransparent` method.
These changes improve maintainability and reduce code complexity.
Refactored `CanControlMonitorAsync` in `DdcCiController.cs`:
- Updated XML documentation to reflect that monitor capabilities
are always cached during discovery, enabling quick connection
checks exclusively.
- Removed fallback logic for full validation and obsolete code
related to `ValidateDdcCiConnection`.
Removed the "Disable" button from `MainWindow.xaml` and its
associated `OnDisableClick` event handler in `MainWindow.xaml.cs`:
- Deleted the button and its properties from the XAML file.
- Removed the event handler logic for toggling monitor control
availability and updating the status text.
These changes simplify the codebase, align with the updated
behavior of cached capabilities, and deprecate unused features.
Refactored monitor discovery to a two-phase process, enabling
parallel capability fetching and reducing total discovery time.
Introduced caching of monitor capabilities to avoid redundant
I2C operations, improving performance during initialization
and runtime validation.
Added `DdcCiValidationResult` to encapsulate validation status
and cached capabilities. Replaced `ValidateDdcCiConnection`
with `FetchCapabilities` for capability retrieval, marking the
former as obsolete. Introduced `QuickConnectionCheck` for fast
runtime validation.
Updated `CanControlMonitorAsync`, `GetCapabilitiesStringAsync`,
and `InitializeMonitorCapabilitiesAsync` to leverage cached
data. Improved logging for better insights into discovery and
validation processes.
Replaced `VcpCodeNewControlValue` with `VcpCodeContrast` and
added `VcpCodeVolume` to the `testCodes` array in
`DdcCiNative.cs` within the `PowerDisplay.Common.Drivers.DDC`
namespace. This change enhances the connection validation
process by including additional VCP features such as contrast
and volume.
Previously, DDC/CI validation was skipped for reused handles.
This change ensures validation is performed for all handles,
excluding monitors that do not support DDC/CI (e.g., internal
laptop displays).
Additionally, the log message for failed validation now
includes whether the handle was reused and uses `LogDebug`
instead of `LogWarning` to adjust the logging level.
Added dynamic visibility binding to the input source button. Updated the `ListView` to bind to `AvailableInputSources` and replaced hardcoded items with a `DataTemplate` for better flexibility. Introduced `InputSourceListView_SelectionChanged` to handle selection changes, update the monitor's input source, and close the flyout after selection. Added logging for improved debugging and error handling.
Introduced functionality to get and set monitor input sources using VESA MCCS VCP code 0x60. This includes backend logic, UI integration, and error handling.
Backend changes:
- Added `GetInputSourceAsync` and `SetInputSourceAsync` in `DdcCiController.cs` for input source management.
- Defined `VcpCodeInputSource` constant in `NativeConstants.cs`.
- Updated `Monitor.cs` to include `CurrentInputSource`, `InputSourceName`, and support detection for input sources.
- Enhanced `MonitorManager.cs` to initialize and manage input source capabilities.
UI changes:
- Added a "More Actions" button in `MainWindow.xaml` for input source switching.
- Implemented a flyout menu to display and select available input sources.
- Added `InputSourceItem_Click` handler in `MainWindow.xaml.cs`.
ViewModel changes:
- Introduced `InputSourceItem` class for UI representation of input sources.
- Updated `MonitorViewModel.cs` to expose input source properties and handle switching.
Other improvements:
- Added detailed logging for input source operations.
- Implemented fallback mechanisms for robust behavior.
- Enhanced user experience with dynamic UI updates for input source changes.
- Renamed project entries in `PowerToys.sln` for consistency.
- Added new projects: "runner," "NewShellExtensionContextMenu," and "BgcodePreviewHandlerCpp."
- Introduced `MonitorMatchingHelper` to centralize monitor identification logic.
- Added unit tests for `MonitorMatchingHelper` to validate parsing and matching.
- Updated `MonitorInfo` with `MonitorNumber`, `TotalMonitorCount`, and `DisplayName` for dynamic formatting.
- Enhanced WMI monitor matching with pre-fetched display devices.
- Updated UI components to use dynamic `DisplayName` for monitors.
- Added `PowerDisplay.Lib.UnitTests` project for testing.
- Improved serialization, logging, and null handling in `PowerDisplayViewModel`.
- Removed redundant parsing logic from `MonitorDiscoveryHelper`.
Enhanced multi-monitor support by introducing a `MonitorNumber` property in the `Monitor` model to represent the Windows DISPLAY number. Updated the `MonitorViewModel` to include a `DisplayName` property that appends the monitor number to the name when multiple monitors are visible.
Modified `MainWindow.xaml` to bind to `DisplayName` instead of `Name`, ensuring the UI reflects the updated naming convention. Added logic to update `DisplayName` dynamically when the monitor count changes, improving clarity in multi-monitor setups.
Included comments in `MonitorViewModel` for better code readability and maintainability.
Refactor and enhance the "Identify Monitors" feature:
- Added constants, P/Invoke methods, and `MakeWindowTransparent` in `WindowHelper.cs` to support layered windows and transparency.
- Redesigned `IdentifyWindow` with WinUI 3 features (`AppWindow`, `DesktopAcrylicController`) for a polished, transparent appearance.
- Simplified `IdentifyWindow.xaml` UI for a cleaner design.
- Fully implemented monitor identification in `MainViewModel.cs`:
- Created and positioned windows for each monitor.
- Handled DPI scaling and display coordinates.
- Added detailed logging and error handling.
Enhanced monitor discovery to include monitor numbers and orientations.
- Added `ParseMonitorNumber` and `GetMonitorOrientation` in `MonitorDiscoveryHelper.cs`.
- Introduced `DevMode` structure and `EnumDisplaySettings` P/Invoke for retrieving display settings.
- Updated `IMonitorData` and `Monitor.cs` to support new properties.
- Sorted monitors by number in `MonitorManager.cs`.
Implemented a new "Identify Monitors" feature:
- Added `IdentifyWindow.xaml` to display monitor numbers visually.
- Added `IdentifyMonitorsCommand` in `MainViewModel.cs` to trigger identification.
- Updated `MainWindow.xaml` to include an "Identify Monitors" button.
Improved code readability with comments and updated license headers.
- Consolidated brightness and capabilities retrieval logic with `GetBrightnessInfoCore` and `RetryHelper` for improved modularity and resiliency.
- Introduced `LockedDictionary` for thread-safe dictionary operations, replacing manual locking in `PhysicalMonitorHandleManager` and `MonitorStateManager`.
- Refactored monitor discovery in `MonitorManager` to separate discovery, initialization, and validation steps for better maintainability.
- Simplified event registration in `App.xaml.cs` with helper methods to reduce repetitive code.
- Enhanced VCP code handling with new methods for formatted and sorted VCP code retrieval.
- Added `SuspendNotifications` in `MonitorInfo` to optimize batch property updates and improve UI performance.
- Simplified parameter update methods in `MonitorViewModel` by removing redundant `fromProfile` logic.
- Improved state management with synchronous save support and reusable JSON building logic in `MonitorStateManager`.
- Updated UI bindings in `ProfileEditorDialog.xaml` and improved VCP code display in `MainViewModel`.
- Cleaned up redundant code, improved logging, and standardized method naming for better readability and maintainability.
Enhanced logging for event handling, settings updates, and process management to improve traceability and debugging.
- Added detailed logging and exception handling in `NativeEventWaiter.cs` for event listener setup and execution.
- Updated `MainViewModel.Settings.cs` to synchronize monitor settings and save changes after applying color temperature.
- Improved process management in `dllmain.cpp` to ensure `PowerDisplay` is running before signaling events, with added race condition prevention.
- Removed redundant settings update signaling in `dllmain.cpp` to avoid excessive UI refreshes and dropdown closures.
- Enhanced monitor synchronization in `PowerDisplayViewModel.cs` to handle pending operations and prevent stale data overwrites.
- General improvements in error handling and logging across all changes.
Refactored `PowerDisplayPage.xaml` and `ProfileEditorDialog.xaml` to use `SettingsExpander` and `SettingsCard` components for a cleaner, modular design. Added dynamic monitor icons via the new `MonitorIconGlyph` property in `MonitorInfo.cs`.
Optimized `VcpCodesFormatted` property with a comparison method to prevent unnecessary updates. Enhanced color temperature handling with confirmation dialogs and improved event handling to prevent re-entrant logic.
Updated resource strings for consistency and improved layout, spacing, and visual hierarchy across the UI. Removed redundant code and improved maintainability.
Replaced `WindowEx.Backdrop` using `AcrylicSystemBackdrop` with
`WindowEx.SystemBackdrop` using `DesktopAcrylicBackdrop`.
Simplified configuration by removing detailed dark and light
theme properties such as fallback colors, luminosity opacity,
and tint settings.
Removed logic for resizing the window when height differences
are negligible (<1px), including associated debug logs and
DPI-aware height conversion. Eliminated the `LogActualSizes`
method, which logged detailed UI element sizes and layout
information. Simplified `GetContentHeight` by replacing
`RootGrid.FindName` with a direct `MainContainer` check and
removing debug logs. These changes streamline the code and
reduce logging verbosity.
Refactored `WindowHelper.cs` to add DPI-aware utilities for scaling, positioning, and converting units. Updated `MainWindow.xaml` to modernize the UI with better structure, scrolling, and visibility bindings. Enhanced window resizing logic in `MainWindow.xaml.cs` with DPI scaling, logging, and layout diagnostics.
Simplified `AdjustWindowSizeToContent` and `GetContentHeight` methods for precise content measurement. Replaced redundant positioning logic with a unified DPI-aware approach. Improved settings handling in `MainViewModel.Settings.cs` by consolidating monitor filtering logic.
Added minimum size constraints to `MainWindow.xaml` for layout stability. Introduced detailed logging for debugging layout and scaling issues. Overall, these changes enhance maintainability, scalability, and user experience.
Added detailed logging for skipped hidden monitors in `MainViewModel.Monitors.cs`.
Implemented functionality in `MainViewModel.Settings.cs` to remove hidden monitors
from the `Monitors` collection during settings updates. Triggered UI updates to
reflect changes in monitor visibility and ensure proper messaging when no monitors
are available. Enhanced maintainability and traceability through improved logging
and UI notifications.
Enhanced logging in Slider_PointerCaptureLost for better traceability and error handling. Added debug and warning logs to capture state and handle null checks for `slider`, `monitorVm`, and `propertyName`.
Introduced new Slider controls in MainWindow.xaml for `BrightnessAutomation`, `ContrastAutomation`, and `VolumeAutomation` with proper bindings, localization support, and layout adjustments. Improved user experience and dynamic control behavior.
Refactored profile name generation by centralizing logic in `ProfileHelper` with overloads for flexibility. Simplified folder creation logic in `PathConstants` using a reusable helper method.
Improved profile loading and saving in `ProfileService` with internal helper methods for better error handling and reduced duplication. Optimized monitor key generation and lookup with concise expressions and dictionary-based retrieval for O(1) performance.
Introduced caching for color presets in `MonitorInfo` to avoid redundant computations and added a helper for range validation in `MainViewModel.Settings`. Centralized percentage formatting and property change handling to reduce duplication.
Removed redundant methods in `PowerDisplayViewModel` and streamlined event unsubscription in `MainWindow`. Enhanced logging, readability, and maintainability across the codebase.
Refactored namespaces to improve modularity, including moving `PowerDisplay.Native` to `PowerDisplay.Common.Drivers`. Introduced the `IMonitorData` interface for better abstraction of monitor hardware data. Replaced `ColorTemperature` with `ColorTemperatureVcp` for precise VCP-based color temperature control, adding utilities for Kelvin conversion.
Enhanced monitor state management with a new `MonitorStateFile` for JSON persistence and updated `MonitorStateManager` for debounced saves. Added `MonitorMatchingHelper` for consistent monitor identification and `ProfileHelper` for profile management operations.
Refactored P/Invoke declarations into helper classes, updated UI bindings for `ColorTemperatureVcp`, and improved logging for better runtime visibility. Removed redundant code, added new utility classes (`MonitorValueConverter`, `MonitorMatchingHelper`), and ensured backward compatibility.
These changes improve code organization, maintainability, and extensibility while aligning with hardware-level control standards.
Introduced `PowerDisplay.Lib` to centralize shared logic and models, improving modularity and reusability. Refactored namespaces, moving classes to `PowerDisplay.Common`. Added utilities like `ColorTemperatureHelper` and `MonitorFeatureHelper` for consistent logic.
Replaced `ProfileManager` with `ProfileService` for centralized profile management. Enhanced event handling, monitor state management, and settings synchronization. Improved color temperature handling and feature detection.
Removed redundant code and converters. Updated `Settings.UI.Library` and XAML bindings to use shared models. Enhanced logging, serialization, and disposal logic. Updated project files and added documentation for better maintainability.
Removed `ShowPowerDisplayEvent`, `TerminatePowerDisplayEvent`,
`SettingsUpdatedPowerDisplayEvent`, and
`ApplyColorTemperaturePowerDisplayEvent` methods from the
`Constants` class in `Constants.cpp`, `Constants.h`, and
`Constants.idl`. These methods were associated with Power
Display functionality that is no longer needed.
This change simplifies the codebase by removing unused
constants and methods related to Power Display events.
Updated the `InfoBar` in `LightSwitchPage.xaml` to improve
accessibility and visual consistency, including changes to
`Severity`, `Background`, and `HyperlinkButton` alignment.
Added new resource entries in `Resources.resw` for monitor
settings and updated the `PowerDisplayDisabledWarningBar`
title to clarify its purpose. Introduced additional resource
strings to support the updated messaging.
Simplify theme change notification logic in `LightSwitchService.cpp` by consolidating redundant checks and improving error handling. Remove the `applyMonitorSettings` setting and associated logic from `LightSwitchSettings`.
Introduce `PowerDisplayProfilesHelper` to centralize profile management, ensuring thread safety and simplifying file operations. Update UI in `LightSwitchPage.xaml` to replace `ApplyMonitorSettings` with separate dark and light mode profile settings, adding navigation to PowerDisplay settings.
Enhance `LightSwitchViewModel` with nullable annotations, new profile selection properties, and improved property synchronization. Refactor `PowerDisplayViewModel` to use `PowerDisplayProfilesHelper` for profile management.
Update localization strings for new UI elements. Perform general code cleanup, including null safety annotations, improved logging, and removal of legacy code.
Integrated PowerDisplay with LightSwitch to enable automatic monitor profile switching based on theme changes. Added event signaling to notify PowerDisplay of theme updates.
Enhanced `LightSwitchService` to support this integration and improved logging for better traceability. Updated `LightSwitchSettings` and `LightSwitchConfig` to include new settings for monitor profile management.
Introduced a background thread in `MainViewModel` to listen for theme change events and apply the appropriate PowerDisplay profile. Added UI elements for managing monitor settings and profiles in `LightSwitchPage`.
Implemented methods in `LightSwitchViewModel` to load PowerDisplay profiles, check module status, and manage new settings. Added localized strings for the new UI elements and warnings.
Improved backward compatibility for old profiles and enhanced error handling throughout the codebase.
Enhanced monitor identification by introducing the `InternalName`
property as a unique identifier, with fallback to `HardwareId`
for backward compatibility. Updated `MainViewModel` logic,
logging, and UI bindings to use `InternalName`.
Extended `ProfileMonitorSetting` to include `MonitorInternalName`
for serialization and profile management. Adjusted profile
creation and pre-fill logic to support the new property.
These changes improve robustness, maintain compatibility with
older profiles, and enhance clarity in logging and the UI.
Refactor logic to support optional inclusion of brightness, contrast, volume, and color temperature in monitor profiles. Updated `Brightness` and `ColorTemperature` to nullable types and adjusted related logic in `MainViewModel.cs` and `ProfileMonitorSetting.cs`.
Improved the UI in `PowerDisplayPage.xaml` and `ProfileEditorDialog.xaml`:
- Added toggle switches for selectively including settings in profiles.
- Enhanced layout and styling for better user experience.
- Updated context menu and monitor selection visuals.
Enhanced `MonitorSelectionItem.cs` with new `Include` flags and auto-selection suppression. Updated `ProfileEditorViewModel.cs` to validate profiles and ensure at least one setting is included for selected monitors.
Performed general code cleanup for readability and maintainability.
Simplified profile management by removing the concept of "Custom profiles" and "current profile" tracking. Profiles are now treated as templates for quick application of monitor settings, rather than persistent states.
Key changes include:
- Replaced `ObservableCollection<string>` with `ObservableCollection<PowerDisplayProfile>` to manage profile objects directly.
- Removed redundant properties and methods related to "selected" and "current" profiles.
- Refactored methods for creating, updating, and deleting profiles to operate on `PowerDisplayProfile` objects.
- Updated `PowerDisplayViewModel` and `ProfileManager` to streamline profile loading, saving, and application logic.
- Updated the UI to replace the profile dropdown with buttons for quick application, along with context menu options for managing profiles.
- Improved logging and error handling for profile operations.
- Updated resource strings and removed references to "Custom profiles" and "current profile."
These changes simplify the codebase, improve maintainability, and align the application with the new design philosophy of treating profiles as templates.
Introduced a comprehensive profile management system for PowerDisplay, enabling users to create, edit, delete, and apply predefined monitor settings. Key changes include:
- Added `ProfileManager` for handling profile storage and retrieval.
- Introduced `PowerDisplayProfile`, `PowerDisplayProfiles`, and related data models for profile representation.
- Enhanced `MainViewModel` and `MonitorViewModel` to support profile application and parameter change detection.
- Created `ProfileEditorDialog` for editing and creating profiles via the UI.
- Updated `PowerDisplayViewModel` to manage profiles, including commands for adding, deleting, renaming, and saving profiles.
- Added new events (`ApplyProfileEvent`) and constants for profile application.
- Updated `PowerDisplayPage` UI to include a "Profiles" section for managing profiles.
- Added serialization support for profile-related classes.
- Updated `dllmain.cpp` and `App.xaml.cs` to handle profile-related events.
These changes improve user experience by allowing quick switching between tailored monitor configurations.
Introduced `ColorTemperatureOperation` class to manage pending color temperature changes. Updated `MainViewModel` to process operations for specific monitors, improving efficiency and separation of concerns.
Added `PendingColorTemperatureOperation` property to `PowerDisplayProperties` for tracking operations. Enhanced IPC messaging with `MonitorId` and `ColorTemperature` in `PowerDisplayActionMessage`.
Refactored `PowerDisplayViewModel` and `PowerDisplayPage` to directly apply color temperature to specified monitors. Improved logging for better traceability.
Enhanced exception handling in RelayCommand to improve robustness.
Standardized slider debounce delays using a new constant
`SliderDebounceDelayMs`. Improved resource management in
SimpleDebouncer with proper disposal of CancellationTokenSource
and added support for synchronous actions. Refactored event
handling in App.xaml.cs for clarity and consistency. Removed
redundant logging in MonitorStateManager and MainViewModel to
reduce verbosity. Updated namespaces and dependencies for better
organization. General code cleanup to improve readability and
maintainability.
Enhanced monitor initialization with parallelism in `MonitorManager.cs` for better performance. Added cancellation support to `NativeEventWaiter.cs` with `CancellationToken` and timeout handling. Introduced thread safety in `PhysicalMonitorHandleManager.cs` using locks to prevent race conditions.
Updated `PowerDisplayViewModel.cs` to include proper resource cleanup with `CancellationTokenSource` and improved memory management. Added necessary namespaces for threading and asynchronous operations. General code improvements for readability, maintainability, and reliability.
