dotnet/wpf

This system is the Windows Presentation Foundation (WPF) framework, a comprehensive UI and graphics library for building Windows desktop applications. It provides a complete rendering engine with support for 2D/3D graphics, text shaping, and ink input, alongside a robust data binding and animation subsystem. The codebase also implements the XAML/BAML markup compilation pipeline, accessibility (UI Automation) interfaces, and native interop layers for Windows-specific features like printing and file dialogs.

207 changes.

This period focused on populating the WPF codebase with the core implementation of the XAML parsing, markup compilation, and UI control libraries. The work involved adding extensive internal classes for text shaping, ink handling, and accessibility, alongside establishing the build infrastructure and shared utility components required to compile and run WPF applications.

42 changes.

This period focused on integrating the WPF Media Integration Layer (MIL) and graphics engine into the repository, including build infrastructure for native libraries and COM stability wrappers. It also established internal support for document rights management, OLE compound files, and OS version detection, while significantly expanding unit test coverage for WPF core components.

The \System.Windows.Input.Manipulations\ namespace is introduced, providing classes for handling 2D user input manipulations and inertia simulation. This includes the \ManipulationProcessor2D\ for tracking gestures, \InertiaProcessor2D\ for simulating physical motion after release, and associated behavior classes (\InertiaTranslationBehavior2D\, \InertiaRotationBehavior2D\, \InertiaExpansionBehavior2D\) that allow developers to configure deceleration, displacement, and rotation parameters. The update also adds supporting types such as \Manipulation2DCompletedEventArgs\ for event data and \DoubleUtil\ for floating-point comparisons.

src/Microsoft.DotNet.Wpf/src/System.Windows.Input.Manipulations/System · high confidence

The WpfGfx component now includes new header files implementing the DirectX abstraction layer for both D3DX9 and DirectXMath (XMath). This adds support for 2D, 3D, and 4D vectors, quaternions, and 4x4 matrices, along with shader compilation utilities and math extensions. The changes introduce a factory mechanism that allows the application to select between the legacy D3DX9 API and the modern DirectXMath API at compile time, enabling the rendering subsystem to utilize hardware-accelerated graphics operations through a unified interface.

src/Microsoft.DotNet.Wpf/src/WpfGfx/common/DirectXLayer · high confidence

The WindowsBase library now includes the \Key\ and \ModifierKeys\ enumerations, along with their corresponding \TypeConverter\ and \ValueSerializer\ classes (\KeyConverter\, \ModifierKeysConverter\, \KeyValueSerializer\, \ModifierKeysValueSerializer\). These additions enable string-to-enum conversion and XAML serialization for keyboard input values. Additionally, the \KeyInterop\ class is introduced to map Win32 VirtualKeys to the new \Key\ enum, and the \TraversalRequest\ class with \FocusNavigationDirection\ is added to support programmatic focus traversal.

src/Microsoft.DotNet.Wpf/src/WindowsBase/System/Windows/Input · high confidence

A new shared utility, OSVersionHelper, has been introduced to detect the installed Windows version at runtime. This helper exposes boolean properties (e.g., IsOsWindows10RS5OrGreater) that wrap native P/Invoke calls to PresentationNative, allowing the framework to branch behavior based on the specific Windows version (ranging from Windows XP SP2 to Windows 10 RS5). The change also includes an OperatingSystemVersion enumeration to support this detection logic.

src/Microsoft.DotNet.Wpf/src/Shared/System/Windows/Interop · high confidence

A new internal readonly struct, PixelUnit, has been added to the codebase. This struct provides static methods to parse and convert various pixel-based length units (pixels, inches, centimeters, and points) from string representations. This change introduces a new mechanism for handling unit conversions in the WPF common code.

src/Microsoft.DotNet.Wpf/src/Common/src/MS · medium confidence

A new \SpecialBracketCharacters\ class has been added to the XAML parser to handle bracket characters specified on a Markup Extension property. This class manages start and end bracket characters, validates them against a restricted character set, and provides methods to check for escape sequences and matching brackets.

src/Microsoft.DotNet.Wpf/src/Shared/MS/Internal/Xaml/Parser · medium confidence

The PresentationFramework assembly now includes a new internal helper class, SystemXmlLinqExtension, which provides specialized property descriptors for XElement. This enables WPF's data binding engine to correctly handle XElements, including resolving synthetic properties like Elements, Descendants, Attribute, and Element, and identifying non-idempotent properties that create new objects on each access.

src/Microsoft.DotNet.Wpf/src/Extensions/PresentationFramework-SystemXmlLinq · high confidence

A new internal helper class, SystemDrawingExtension, is introduced to manage conversions between WPF image types and System.Drawing types. This includes methods for retrieving HBITMAP handles, converting BitmapSource to System.Drawing.Bitmap, and handling metafile formats, facilitating the integration of System.Drawing functionality within the WPF framework.

src/Microsoft.DotNet.Wpf/src/Extensions/PresentationFramework-SystemDrawing · high confidence

A new TypeUriConverter class has been added to the System.Xaml replacements to handle conversions between strings and System.Uri objects within the XAML markup processing pipeline. This provides a dedicated converter for URI-based type conversions in the shared codebase.

src/Microsoft.DotNet.Wpf/src/Shared/System/Windows/Markup/Replacements · high confidence

Added new internal classes in the UIAutomationClientSideProviders assembly, including Accessible, ClickablePoint, ThemePart, RemoteMemoryBlock, and XSendMessage. These files implement the core logic for wrapping IAccessible, calculating clickable points, retrieving theme part sizes, managing cross-process memory blocks, and handling cross-process message sending for UI Automation providers.

src/Microsoft.DotNet.Wpf/src/UIAutomation/UIAutomationClientSideProviders/MS/Internal · high confidence

The PresentationCore library now includes the core AutomationPeer classes (AutomationPeer, ContentElementAutomationPeer, GenericRootAutomationPeer, UIElement3DAutomationPeer, and UIElementAutomationPeer) which expose UI elements to accessibility tools. These peers provide the necessary interface for screen readers and other assistive technologies to understand and interact with WPF controls, including support for synchronized input patterns and standard automation properties.

src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/Automation/Peers · high confidence

A new reference assembly (UIAutomationProvider.cs) is introduced for the UI Automation provider layer, exposing the public API surface for UIA providers. This includes the AutomationInteropHelper class with methods for raising automation events and properties, as well as a comprehensive set of provider interfaces (such as IGridProvider, IScrollProvider, ITextProvider, and IWindowProvider) that define the contract for UI automation controls. This change enables developers to build or extend UI automation providers using the standard .NET interfaces.

src/Microsoft.DotNet.Wpf/src/UIAutomation/UIAutomationProvider/ref · high confidence

The WPF threading model is introduced with the \Dispatcher\ class, which manages the queue of operations for a specific thread. This includes support for \DispatcherOperation\ to represent queued work, \DispatcherPriority\ to define execution order, and \DispatcherObject\ to enforce thread-affinity checks. The update also adds \DispatcherHooks\ for monitoring dispatcher activity, \DispatcherFrame\ for message loop integration, and synchronization context support, enabling developers to schedule and manage UI-thread-bound code execution.

src/Microsoft.DotNet.Wpf/src/WindowsBase/System/Windows/Threading · high confidence

The WPF build system now includes the core MSBuild targets and task definitions required to compile XAML markup files. This change introduces the \Microsoft.WinFX.targets\ file, which defines the build pipeline for WPF projects, including targets for compiling XAML into code-behind and managing resources. Additionally, the \SR.cs\ file is added to expose a shared \ResourceManager\ for the build tasks, enabling consistent error and status messaging during the build process. These files provide the foundational build logic for WPF projects.

src/Microsoft.DotNet.Wpf/src/PresentationBuildTasks · high confidence

The WPF controls library gains a substantial set of new UI components and value converters, including AVElementHelper, AccessText, AddingNewItemEventArgs, AdornedElementPlaceholder, AlternationConverter, BooleanToSelectiveScrollingOrientationConverter, BooleanToVisibilityConverter, Border, BorderGapMaskConverter, Button, Calendar, and CalendarBlackoutDatesCollection. These additions expand the available controls for building user interfaces and handling data binding scenarios.

src/Microsoft.DotNet.Wpf/src/PresentationFramework/System/Windows/Controls · high confidence

The WPF framework introduces several new classes to support application lifecycle, design-time support, and annotation storage. The \Application\ class is added to manage application-wide state and events like startup and exit. \DesignerProperties\ provides attached properties to detect if a control is running in a designer. \AccentColorHelper\ is introduced to retrieve the system's accent color. Additionally, the \System.Windows.Annotations.Storage\ namespace is populated with classes (\AnnotationStore\, \XmlStreamStore\, \StoreContentChangedEventArgs\) that enable storing, retrieving, and tracking changes to annotations in XML streams.

src/Microsoft.DotNet.Wpf/src/PresentationFramework/System/Windows · high confidence

Added new classes to the \System.Windows.Interop\ namespace to support hosting native Windows and ActiveX controls within WPF applications. This includes \HwndHost\ for embedding unmanaged windows, \ActiveXHost\ for hosting ActiveX controls, and helper classes like \BrowserInteropHelper\ and \WindowInteropHelper\ to facilitate interop between WPF and legacy Windows APIs.

src/Microsoft.DotNet.Wpf/src/PresentationFramework/System/Windows/Interop · high confidence

The WPF navigation framework is introduced with the addition of core classes including \NavigationService\, \NavigationWindow\, and associated event argument types such as \NavigationEventArgs\, \NavigatingCancelEventArgs\, and \NavigationFailedEventArgs\. This includes the \Journal\ class for managing back/forward history, \JournalEntry\ for representing history items, and converters like \JournalEntryListConverter\ to limit the number of entries shown in the UI. These changes enable developers to implement client-side navigation, manage browser history, and handle navigation states within WPF applications.

src/Microsoft.DotNet.Wpf/src/PresentationFramework/System/Windows/Navigation · high confidence

The PresentationCore library adds several new internal classes to support text formatting and 3D transformations. The \Bidi\ class implements a state machine for bidirectional text resolution, while \CultureMapper\ handles mapping between \CultureInfo\ objects for text formatting. The \DrawingState\ class manages drawing context and baseline guidelines for text lines. Additionally, \GeneralTransform2DTo3DTo2D\ and \GeneralTransform3DTo2DTo3D\ classes provide transform services between 2D and 3D coordinate spaces, and \LineUtil\ and \M3DUtil\ provide utility functions for 3D geometry and matrix operations.

src/Microsoft.DotNet.Wpf/src/PresentationCore/MS/internal/TextFormatting · high confidence

The WindowsBase library now includes a new \WeakReadOnlyCollection\<T\>\ class in the \System.Collections.ObjectModel\ namespace, which stores items as weak references to help avoid memory leaks from event handlers. Additionally, a new \CollectionChangedEventManager\ class has been added to the \System.Collections.Specialized\ namespace to manage weak event listeners for the \INotifyCollectionChanged.CollectionChanged\ event, providing a pattern for handling collection changes without retaining strong references.

src/Microsoft.DotNet.Wpf/src/WindowsBase/System/Collections · high confidence

The WPF runtime now includes a new shared \MS.Win32\ namespace containing core Win32 interop utilities and window management classes. This adds \ExternDll.cs\ for centralized DLL name constants, \HwndSubclass.cs\ for managed window procedure subclassing, \HwndWrapper.cs\ for creating and managing native window handles, \HandleCollector.cs\ for tracking native handle lifetimes, and \NativeMethods\*.cs\ files defining P/Invoke signatures and constants. These components provide the underlying mechanism for WPF to interact with the Windows OS, enabling features like window subclassing, message handling, and native resource management.

src/Microsoft.DotNet.Wpf/src/Shared/MS/Win32 · high confidence

Added new interop files in src/Microsoft.DotNet.Wpf/src/Common/src/Interop to expose Windows API functions and constants. This includes the Libraries registry mapping native DLL names (including System.IO.Compression.Native.dll), user32 window and system parameters, winmm audio and multimedia I/O functions (PlaySoundW, mmioOpenW, etc.), and zlib compression functions (Deflate, Inflate, Crc32).

src/Microsoft.DotNet.Wpf/src/Common/src/Interop · high confidence

A new WindowsFormsHostAutomationPeer class has been added to the WindowsFormsIntegration assembly. This class implements the UI Automation peer for the WindowsFormsHost control, exposing its identity as a 'Pane' control type and providing the necessary infrastructure for accessibility tools to interact with hosted Windows Forms content.

src/Microsoft.DotNet.Wpf/src/WindowsFormsIntegration/System/Windows/Automation · high confidence

The System.Xaml library now includes the core infoset object model and reader/writer implementations. This adds the \XamlNode\ struct and \XamlNodeType\ enum to represent the XAML infoset, alongside settings classes (\XamlReaderSettings\, \XamlObjectWriterSettings\, \XamlTextReaderSettings\, \XamlXmlReaderSettings\) that configure parsing and writing behavior. The diff introduces the \XamlObjectWriter\ and \XamlXmlReader\ classes, which provide the primary mechanisms for writing and reading XAML data, including support for deferred template writing and line information tracking.

src/Microsoft.DotNet.Wpf/src/System.Xaml/System/Xaml/InfosetObjects · high confidence

The System.Xaml library now includes the resource files (ExceptionStringTable.txt, Strings.resx, and win32res.rc) that define the error messages for XAML parsing and object writing exceptions, enabling localized error reporting for developers.

src/Microsoft.DotNet.Wpf/src/System.Xaml/Resources · high confidence

Introduced new internal TypeConverter implementations for the XAML subsystem, including DateTimeConverter2, DateTimeOffsetConverter2, TypeListConverter, and TypeTypeConverter. These classes provide specific conversion logic for date/time types, type arrays, and single types, bridging the gap between string representations and their corresponding .NET types within the XAML parsing and serialization pipeline.

src/Microsoft.DotNet.Wpf/src/System.Xaml/System/Xaml/Replacements · high confidence

The diff introduces two new internal classes, XamlContextStack and XamlFrame, located in the MS.Internal.Xaml.Context namespace. XamlFrame serves as an abstract base class providing depth tracking and previous-frame linking, while XamlContextStack implements a generic stack that manages XAML context frames, supporting push/pop scope operations, frame recycling, and depth management. This change adds new internal infrastructure for managing XAML parsing context, likely to support template context reuse as noted in the Clone method comment.

src/Microsoft.DotNet.Wpf/src/Shared/MS/Internal/Xaml/Context · high confidence

Introduced new files (ZLibNative.Windows.cs, ZLibNative.cs) that define the managed wrappers and P/Invoke declarations for the native CLRCompression.dll (ZLib) library. This adds the underlying native binding infrastructure required for Deflate compression, exposing enums for compression levels, strategies, and methods, as well as handle wrappers for the ZLib stream state.

src/Microsoft.DotNet.Wpf/src/Common/src/System/IO · high confidence

New AssemblyAttrs.cs files were added to the System.Windows.Controls.Ribbon and WindowsFormsIntegration projects. These files define assembly-level attributes, including theme resource locations and XML namespace definitions for the respective namespaces, ensuring proper integration with the WPF and Windows Forms ecosystems.

src/Microsoft.DotNet.Wpf/src/System.Windows.Controls.Ribbon, src/Microsoft.DotNet.Wpf/src/WindowsFormsIntegration · medium confidence

The PresentationUI library introduces a new set of internal classes to support document rights management (DRM) and digital signature workflows. This includes a \CredentialManagerDialog\ for managing user credentials, a \DocumentSignatureManager\ to coordinate signature states and policies, and a \DigitalSignatureProvider\ to interface with XPS packaging. The update also adds a \DialogBaseForm\ and \DocumentApplicationDocumentViewer\ to handle UI rendering and command binding for these features, alongside supporting enums and status resources.

src/Microsoft.DotNet.Wpf/src/PresentationUI/MS/Internal/Documents · high confidence

The WindowsBase library now includes a new internal implementation for handling OLE Compound Files (structured storage). This adds support for reading and writing Microsoft Office-style compound file formats, including stream and storage references, compression transforms, and native interop bindings to OLE32. Users working with legacy compound file formats will now have access to these internal APIs for packaging and unpacking structured storage documents.

src/Microsoft.DotNet.Wpf/src/WindowsBase/MS/Internal/IO/Packaging/CompoundFile · high confidence

Introduced new internal types to manage Windows DPI awareness contexts more robustly. The DpiAwarenessContextValue enumeration maps to the Windows DPI\_AWARENESS\_CONTEXT pseudo-handles, and the DpiAwarenessContextHandle class wraps these handles as a SafeHandle to simplify comparison and conversion. A companion DpiUtil class provides a safe method to compare DPI context handles, falling back to trivial pointer comparison if the AreDpiAwarenessContextsEqual API is unavailable on older Windows versions.

src/Microsoft.DotNet.Wpf/src/Shared/MS/Utility/DpiAwarenessContext · high confidence

The WindowsBase packaging layer introduces several new internal classes to support digital signature handling and stream emulation. A new \CertificatePart\ class manages X.509 certificate parts within a package, utilizing \X509CertificateLoader.LoadCertificate\ for deserialization. Stream handling is enhanced with \CompressEmulationStream\ and \DeflateEmulationStream\ to provide fully functional stream interfaces over restricted compression streams, while \IgnoreFlushAndCloseStream\ optimizes performance by suppressing flush and close calls. Additionally, \CustomSignedXml\ extends the standard \SignedXml\ to support XAdES-specific reference targeting, and \InternalRelationshipCollection\ centralizes relationship serialization. These changes provide the internal foundation for package integrity and compression emulation.

src/Microsoft.DotNet.Wpf/src/WindowsBase/MS/Internal/IO/Packaging · high confidence

The WPF shared codebase now includes several new internal helper classes: AppDomainShutdownMonitor for tracking AppDomain shutdown events, CharacterBuffer for handling character memory buffers, CommandLibraryHelper for creating UI commands, CommonDependencyPropertyAttribute for marking common dependency properties, CopyOnWriteList for thread-safe list operations, CriticalExceptions for identifying critical exceptions, CulturePreservingExecutionContext for managing thread culture during dispatcher operations, DecoderFallbackWithFailureFlag for decoding failures, DoubleUtil and FloatUtil for fuzzy numeric comparisons, FixedPageInfo and GlyphRunInfo for glyph metrics, FreezableOperations for Freezable helpers, and SynchronizingStream for thread-safe stream access.

src/Microsoft.DotNet.Wpf/src/Shared/MS/Internal · high confidence

The System.Xaml component now includes two new internal classes, StringValueSerializer and TypeConverterValueSerializer, which provide mechanisms for serializing and deserializing string values and converting types via TypeConverter instances. These additions support the XAML serialization infrastructure by handling string conversions and delegating to type converters, enabling more flexible value serialization within the framework.

src/Microsoft.DotNet.Wpf/src/System.Xaml/ms · high confidence

Added the System.Printing reference assembly (System.Printing.cs and System.Printing.internals.cs) to the WPF build, exposing public and internal types such as PrintQueue, PrintServer, and related enums to support API compatibility and compilation of projects that depend on printing functionality.

src/Microsoft.DotNet.Wpf/src/System.Printing/ref · high confidence

New reference assemblies have been added to expose the public API surface for 2D input manipulation and UI automation client-side providers. The System.Windows.Input.Manipulations namespace now includes types such as InertiaProcessor2D, ManipulationProcessor2D, and related event args and parameters, enabling developers to handle touch and gesture inputs in WPF applications. Additionally, the UIAutomationClientSideProviders assembly now exposes the ClientSideProviderDescriptionTable, allowing applications to access descriptions of client-side providers for UI Automation. These changes provide the necessary metadata for compilation and IntelliSense support without altering runtime behavior.

src/Microsoft.DotNet.Wpf/src/Shared/ref, src/Microsoft.DotNet.Wpf/src/System.Windows.Input.Manipulations/ref, src/Microsoft.DotNet.Wpf/src/UIAutomation/UIAutomationClientSideProviders/ref · high confidence

A new reference assembly (PresentationCore.cs) has been added to the PresentationCore project. This file contains the public API surface for the core WPF types, including the Clipboard class with methods for handling audio, images, and text data, as well as event definitions for input and focus handling. This enables tooling and consumers to reference the library's public interface without requiring the full implementation.

src/Microsoft.DotNet.Wpf/src/PresentationCore/ref · high confidence

The WPF library now includes new files that define trace messages for debugging and diagnostics, specifically \AvTraceMessages.txt\ and \AvTraceMessages.xml\, which provide the data used to generate wrapper classes for trace sources. Additionally, \GlobalUsings.cs\ adds standard library imports, \HashHelper.cs\ provides a utility to check for reliable hash codes, and \LibraryAssemblyInfo.cs\ and \OtherAssemblyInfo.cs\ configure assembly attributes, including internal visibility for test projects and XML namespace definitions for XAML.

src/Microsoft.DotNet.Wpf/src/PresentationFramework · high confidence

The PresentationCore library now includes a new set of classes in the System.Windows.Media.Media3D namespace, introducing support for 3D graphics. This includes base classes and implementations for 3D geometry (Geometry3D, GeometryModel3D), 3D transforms (GeneralTransform3D, GeneralTransform3DGroup, GeneralTransform2DTo3D, GeneralTransform3DTo2D), 3D lights (AmbientLight, DirectionalLight), 3D materials (DiffuseMaterial, EmissiveMaterial), and 3D cameras. Additionally, a ContainerUIElement3D is provided to manage 3D visual children, and HitTestParameters3D supports 3D hit testing. These additions enable developers to render and interact with 3D content within the WPF framework.

src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/Media3D · high confidence

New XAML theme files (Aero.NormalColor.xaml, Aero2.NormalColor.xaml, and their .sdk variants) have been added to the WPF Ribbon control's Themes folder. These files define the visual styles for the RibbonWindow, including button templates, gradient brushes, and control templates for window caption buttons (minimize, maximize, close) in the Aero and Aero2 visual styles, ensuring consistent native-looking window chrome for Ribbon applications.

src/Microsoft.DotNet.Wpf/src/System.Windows.Controls.Ribbon/Themes · high confidence

The BAML 2006 reader implementation has been added to the Presentation Framework, introducing the core classes required to parse and process BAML (Binary Application Markup Language) files. This includes the \Baml2006Reader\ and its supporting infrastructure such as \Baml2006SchemaContext\, \Baml2006ReaderContext\, and various helper classes like \Baml2006ReaderFrame\ and \Baml2006RecordType\. These changes enable the WPF framework to read and interpret BAML resources, which are a compiled form of XAML used for UI definition. The implementation includes handling of static resources, type conversions, and namespace mappings essential for loading XAML-based user interfaces.

src/Microsoft.DotNet.Wpf/src/PresentationFramework/System/Windows/Markup/Baml2006 · high confidence

The new BaseUriHelper class provides static methods and properties to resolve the base URI for dependency objects within the WPF visual tree. This includes logic to handle relative URIs by resolving them against the application's base URI, ensuring that elements like images or resources can correctly locate their associated files or resources within the application package.

src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/Navigation · high confidence

The WPF Ink subsystem now includes a new \BitStreamReader\ class that handles reading packed bits from byte arrays, supporting various bit-widths (16, 32, 64) and reverse byte order. This is accompanied by a \Native\ helper class that defines bit-width constants (e.g., \BitsPerByte\, \BitsPerInt\) and size constants for primitive types, ensuring consistent bit-packing behavior for the ISF encoder/decoder compatibility.

src/Microsoft.DotNet.Wpf/src/Shared/MS/Internal/Ink · high confidence

Introduced the Csp tool, a C\# project interpreter and code generator located in src/Microsoft.DotNet.Wpf/src/WpfGfx/tools/csp. This tool parses and executes C\# projects, supporting a 'C\# Prime' extension for code generation, which is utilized by the MilCodeGen component. The change includes the core parser, runtime support, and test scripts for both standard C\# and C\# Prime projects.

src/Microsoft.DotNet.Wpf/src/WpfGfx/tools · high confidence

A new C\# reference assembly (WindowsBase.cs) has been added to the WindowsBase project. This file contains the public API surface for the WindowsBase library, including types such as CollectionChangedEventManager, CurrentChangedEventManager, DependencyPropertyDescriptor, and interfaces like ICollectionView and IEditableCollectionView. This change supports the project's shift to using GenAPI for generating reference assemblies, ensuring that consumers of the library have accurate metadata for compilation and tooling.

src/Microsoft.DotNet.Wpf/src/WindowsBase/ref · high confidence

New C++ source files (Utils.cxx and dwriteloader.cpp) were added to the shared WPF C++ codebase. Utils.cxx implements registry reading and path resolution logic to locate the WPF installation directory, supporting both standard and private CLR configurations. dwriteloader.cpp provides a simplified mechanism to load dwrite.dll and retrieve the DWriteCreateFactory function pointer, replacing previous, more complex loading processes.

src/Microsoft.DotNet.Wpf/src/Shared/cpp · medium confidence

The WPF printing subsystem now includes a new set of C++/CLI header files in \src/Microsoft.DotNet.Wpf/src/System.Printing/CPP/inc\ that define the managed/unmanaged interop layer for asynchronous notifications, GDI-based rendering, and print system management. These headers introduce classes such as \AsyncNotify\ for handling print spooler notifications, \PrintDriver\ and \PrintFilter\ for managing printer drivers and filter pipelines, and a suite of GDI exporter headers (\GDIExporter/\) that wrap Win32 GDI32 API calls (like \CreateDC\, \StartDoc\, \DrawGeometry\) to facilitate legacy driver printing. This adds the necessary interface definitions and native method bindings to support the GDI rendering path in WPF.

src/Microsoft.DotNet.Wpf/src/System.Printing/CPP/inc · high confidence

The System.Printing namespace now includes a new C++/CLI implementation in the \CPP/src\ directory, introducing core components for asynchronous notifications (AsyncNotify), driver/job/printer thunking profiles, and data retrieval logic. This change adds the underlying managed/unmanaged bridge that enables WPF printing features to interact with Win32 APIs, supporting operations like enumerating printers, managing print jobs, and handling print system events.

src/Microsoft.DotNet.Wpf/src/System.Printing/CPP/src · high confidence

Added a new set of internal C\# interfaces in the \System.Windows.Xps.Serialization.RCW\ namespace, including \IOpcPartUri\, \IOpcUri\, \IXpsOMCanvas\, \IXpsOMDocument\, and others. These files are auto-generated Runtime Callable Wrappers (RCWs) derived from Windows SDK type libraries (\.idl\), enabling managed code to interact with the underlying COM-based XPS object model.

src/Microsoft.DotNet.Wpf/src/ReachFramework/Serialization/RCW · high confidence

The PresentationBuildTasks component now includes XLIFF localization files (Strings.cs.xlf, Strings.de.xlf, Strings.es.xlf, Strings.fr.xlf, Strings.it.xlf, and Strings.ja.xlf) in the Resources/xlf directory. These files contain translated strings for markup compilation diagnostics and status messages, enabling the WPF build system to display localized error codes (such as MC1002, MC6015, UM1001) and UI text in these languages.

src/Microsoft.DotNet.Wpf/src/PresentationBuildTasks/Resources/xlf · high confidence

A new MSBuild project file (D3DCompiler.vcxproj) was added to the WPF redist directory. This change enables the build system to properly handle the D3DCompiler DLL for ARM64 architectures, ensuring that the correct version of the library is included in the distribution for that platform.

src/Microsoft.DotNet.Wpf/redist/D3DCompiler · high confidence

New extension methods were added to the WPF threading model. The \DispatcherExtensions\ class now provides \BeginInvoke\ and \Invoke\ overloads that allow asynchronous and synchronous execution of delegates on the dispatcher thread, with support for priority and timeout parameters. Additionally, \TaskExtensions\ introduces \IsDispatcherOperationTask\ to identify tasks wrapping dispatcher operations, and \DispatcherOperationWait\ to wait for their completion. These additions enhance the integration between WPF's dispatcher model and modern asynchronous patterns.

src/Microsoft.DotNet.Wpf/src/System.Windows.Presentation · high confidence

A new FileHelper class was added to the System.IO namespace, providing methods to atomically create and open temporary files and to delete them robustly. This addresses a race condition where an 'impolite process' could interfere with temp file creation, and ensures that failures to delete temp files (e.g., due to antivirus scans) do not crash the application.

src/Microsoft.DotNet.Wpf/src/Shared/System/IO · high confidence

Introduced a new set of C++ source files in the GDIExporter directory, including FontInfo, GdiBitmap, GdiBrush, GdiDevice, GdiPath, GdiPen, GdiPrintContext, GdiText, PrintMsg, and Utils. These files implement the native code logic for converting WPF drawing operations into GDI commands, handling tasks such as font management, bitmap and brush conversion, path and pen rendering, and text output, which are essential for the printing subsystem.

src/Microsoft.DotNet.Wpf/src/System.Printing/CPP/src/GDIExporter · high confidence

The diff introduces the \KeyboardNavigation\ sealed class and the \KeyboardNavigationMode\ enum in the \System.Windows.Input\ namespace. This adds new attached properties (\TabIndex\, \IsTabStop\, \TabOnceActiveElement\, \ControlTabOnceActiveElement\) and methods to manage keyboard focus and navigation behavior for UI elements, enabling logical (Tab) and directional (arrow) navigation between focusable controls.

src/Microsoft.DotNet.Wpf/src/PresentationFramework/System/Windows/Input · high confidence

Introduced a new internal class, NativeRecognizer, which acts as a wrapper for the unmanaged recognition APIs in mshwgst.dll. This class manages the creation and disposal of recognition contexts, handles the setting of enabled gestures, and processes stroke collections to return gesture recognition results.

src/Microsoft.DotNet.Wpf/src/PresentationCore/MS/internal/Ink/GestureRecognizer · high confidence

The WPF PresentationCore library now includes new classes to handle 'pack' scheme URIs. PackWebRequest and PackWebResponse implement the WebRequest and WebResponse interfaces to manage requests to packaged resources. PackWebRequestFactory registers the 'pack' scheme handler, while PackageStore provides a thread-safe cache for packages, allowing multiple parts of a package to be accessed without re-opening the file. This enables more efficient access to resources within XPS documents and other packaged formats.

src/Microsoft.DotNet.Wpf/src/PresentationCore/System/IO · high confidence

The PenIMC component now includes new C++ classes—ComApartmentVerifier, ComLockableWrapper, and GitComLockableWrapper—that verify COM apartment states and lock/unlock COM objects to prevent rundown issues. These wrappers ensure that COM objects remain valid during critical operations, improving stability for pen and touch input handling in WPF applications.

src/Microsoft.DotNet.Wpf/src/PenImc · high confidence

A new Visual C++ project file (PresentationNative.vcxproj) was added to the WPF redist directory, establishing a build configuration that includes ARM64 alongside existing Win32 and x64 platforms. This change enables the distribution of the PresentationNative native library for ARM64 architectures, supporting the broader WPF ARM64 support initiative.

src/Microsoft.DotNet.Wpf/redist/PresentationNative · high confidence

Introduced the PrintSystemException class and supporting interop code (InteropWin32ApiThunk.cs) to handle print system errors. The new exception class provides constructors for generic errors, custom messages, inner exceptions, and specific error codes, mapping Win32 error codes to HRESULTs for consistent error reporting in the printing subsystem.

src/Microsoft.DotNet.Wpf/src/ReachFramework/PrintSystemExceptions · medium confidence

The Reach and XPS packaging and serialization APIs now have dedicated exception classes (ReachException, ReachPackagingException, ReachSerializationException, XpsException, XpsPackagingException, and XpsSerializationException) along with a string table containing localized error messages for these operations.

src/Microsoft.DotNet.Wpf/src/ReachFramework/Exceptions · high confidence

The \System.Security.RightsManagement\ namespace in WindowsBase now includes core classes for managing digital rights, including \CryptoProvider\ for encryption and decryption services, \PublishLicense\ and \UnsignedPublishLicense\ for handling license structures, \SecureEnvironment\ for user activation and session management, and supporting types such as \ContentGrant\, \ContentUser\, \ContentRight\, and \RightsManagementException\. This provides the foundational types needed to acquire, bind, and enforce usage rights for protected content.

src/Microsoft.DotNet.Wpf/src/WindowsBase/System/Security · high confidence

A new SystemDataExtension class was added to the PresentationFramework-SystemData assembly. This class provides helper methods for interacting with System.Data types, including checks for DataView, DataRowView, and SqlNull values, as well as specialized handling for DataSet collection properties to prevent memory leaks and ensure proper object lifetimes during data binding.

src/Microsoft.DotNet.Wpf/src/Extensions/PresentationFramework-SystemData · medium confidence

The System.Xaml library now includes a comprehensive set of XAML markup extensions and attributes in the System.Windows.Markup namespace. This adds support for referencing types (TypeExtension), static members (StaticExtension), and null values (NullExtension) within XAML content. The update also introduces key attributes such as ContentProperty, ConstructorArgument, and MarkupExtensionReturnType to guide XAML parsing and serialization, alongside interfaces like IComponentConnector and INameScope to manage component initialization and name scoping during XAML loading.

src/Microsoft.DotNet.Wpf/src/System.Xaml/System/Windows · high confidence

Added new T4 templates (AvTraceMessages.tt, PresentationTraceSources.tt) and corresponding MSBuild targets (GenAvMessages.targets, GenTraceSources.targets, DesignTimeTextTemplating.targets) to the WPF Arcade SDK. These files configure the build system to automatically generate C\# trace source classes and trace source properties from XML metadata during compilation, enabling consistent trace point generation across WindowsBase, PresentationCore, and PresentationFramework.

eng/WpfArcadeSdk/tools/CodeGen · high confidence

Introduced the TextRange class in the System.Windows.Automation.Text namespace, providing a client-side wrapper for text ranges in UI Automation. This new component enables applications to represent and manipulate spans of text within a Text Pattern container, including methods for cloning, comparing ranges, expanding to enclosing units, and finding subranges with specific attributes.

src/Microsoft.DotNet.Wpf/src/UIAutomation/UIAutomationClient/System/Windows/Automation/Text · high confidence

A new TypeConverterHelper class has been added to the System.Windows.Media namespace. This helper provides a GetUriFromUriContext method that resolves relative URIs against a base URI obtained from an IUriContext, handling various scenarios such as absolute URIs, relative URIs with a base context, or fallback to the application's base URI.

src/Microsoft.DotNet.Wpf/src/Shared/System/Windows/Media · high confidence

Added new AutomationPeer classes for WPF controls including Button, Calendar, CheckBox, ComboBox, ContextMenu, DataGrid, and ContentText elements. These peers expose UI Automation patterns (such as Invoke, ExpandCollapse, Grid, Table, and Selection) to assistive technologies, enabling screen readers and other accessibility tools to interact with these controls. The implementation includes specific handling for control states, patterns, and child elements to ensure proper accessibility tree construction.

src/Microsoft.DotNet.Wpf/src/PresentationFramework/System/Windows/Automation · high confidence

The UIAutomationProvider module now includes new internal wrappers for UIA Core API calls, including methods to raise various automation events (property changes, structure changes, notifications, etc.) and host provider lookups. Additionally, a new file provides type-forwarding attributes for key UI Automation interfaces, ensuring compatibility between the real and reference assemblies.

src/Microsoft.DotNet.Wpf/src/UIAutomation/UIAutomationProvider/MS · medium confidence

The UIAutomationProvider library now includes a new \AutomationInteropProvider\ class and a comprehensive set of provider interfaces (such as \IScrollProvider\, \ISelectionProvider\, \ITextProvider\, and others) that enable Win32 and Avalon servers to expose UI Automation patterns. These changes allow applications to interact with UI elements via the UI Automation framework, supporting features like scrolling, selection, text manipulation, and event notification.

src/Microsoft.DotNet.Wpf/src/UIAutomation/UIAutomationProvider/System · high confidence

The PresentationFramework library now includes the core classes for the WPF Annotation framework, including the \Annotation\ object model, \AnnotationService\ for managing annotations on document viewers, and supporting types like \AnnotationResource\ and event args for change notifications. This enables developers to implement annotation features such as highlighting text, adding sticky notes, and persisting user annotations in WPF applications.

src/Microsoft.DotNet.Wpf/src/PresentationFramework/System/Windows/Annotations · high confidence

Introduced a new tracing infrastructure for WPF, including a code generation tool (mcwpf) and associated scripts (EventTraceCodeGen.cmd) to produce managed and unmanaged source files from the wpf-etw.man manifest. This adds a suite of new files in src/Microsoft.DotNet.Wpf/src/Shared/Tracing, including the C\# generators (mcwpf/CommandLineParser.cs, mcwpf/mcwpf.cs), templates (wpf\_template.cs), and the resulting generated code (managed/wpf-etw.cs, managed/wpf-etw-xaml.cs) and native headers (native/wpf-etw.h, native/wpf-etw-valuemaps.h) that enable Event Tracing for Windows (ETW) diagnostics for WPF components.

src/Microsoft.DotNet.Wpf/src/Shared/Tracing · high confidence

The \System.Windows.Ink\ namespace in \PresentationCore\ now includes core types for handling digital ink and touch gestures. This adds the \GestureRecognizer\ class for recognizing strokes as gestures, along with supporting types like \ApplicationGesture\ and \RecognitionConfidence\ enums, \GestureRecognitionResult\ for recognition outcomes, and \DrawingAttributes\ for styling strokes. Additionally, the \Stroke\ and \StrokeCollection\ classes provide the fundamental storage and manipulation of ink data, including hit-testing, transformation, and serialization capabilities.

src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/Ink · high confidence

Added new shared source files for the WPF and XAML markup systems, including ReflectionHelper, RuntimeIdentifierPropertyAttribute, TypeConverterHelper, XmlCompatibilityReader, and XmlWrappingReader. These files provide core functionality for reflection-based type resolution, XAML attribute handling, type conversion, and XML parsing compatibility, supporting both the build-time compiler (PBTCOMPILER) and runtime namespaces (System.Windows.Markup, System.Xaml).

src/Microsoft.DotNet.Wpf/src/Shared/System/Windows/Markup · high confidence

Introduced a new internal font face subsystem in PresentationCore, including classes for parsing composite font XML files, managing font family identifiers, differentiating font styles, and loading physical font files. This adds support for composite font families, font face matching, and device font retrieval, enabling WPF to resolve and render fonts from .CompositeFont files and native font files.

src/Microsoft.DotNet.Wpf/src/PresentationCore/MS/internal/FontFace · high confidence

New header and C\# source files for WPF graphics (WpfGfx) have been added to the build, introducing core type definitions such as AVEvent, AVEventData, MilSegmentType, and various rendering flags. These files provide the underlying data structures and enumerations used by the WPF graphics subsystem.

src/Microsoft.DotNet.Wpf/src/WpfGfx/include/processed · high confidence

Added a new set of internal C\# files in the WPF graphics common layer, including generated command structures, export definitions, error codes, and rendering enums. These files establish the managed interface to the MIL (Media Integration Layer) core, enabling low-level graphics operations such as resource management, media playback, and render target handling.

src/Microsoft.DotNet.Wpf/src/Common/Graphics · high confidence

Added the DbgXHelper library, a set of C++ utilities for debugging and interacting with the Windows Debugging Engine (WinDbg), including helper functions for reading memory, handling debugger events, and formatting output. Additionally, introduced the MilCodeGen tooling and supporting C\# model classes to generate WPF graphics resource types and managed code, enabling the build system to automatically produce necessary headers and source files for the graphics subsystem.

src/Microsoft.DotNet.Wpf/src/WpfGfx/codegen · high confidence

The WPF graphics subsystem now includes new C++ implementations for core rendering tasks. This adds the \CEffectList\ class to manage effect parameters and resources, and introduces a full suite of scan operations in the \scanop\ directory, including bitmap handling, halftone conversion, and pixel format conversion logic. These components enable the underlying rendering engine to process image data and apply visual effects.

src/Microsoft.DotNet.Wpf/src/WpfGfx/common/scanop · high confidence

Added new classes for WPF input handling, including \AccessKeyManager\ for managing access keys, \Cursor\ and \Cursors\ for standard and custom cursors, \FocusManager\ for tracking focus scope and events, and \DefaultTextStore\ for text composition support.

src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/Input · high confidence

Introduced new classes in the \System.Windows.Interop\ namespace within \PresentationCore\, including \CursorInteropHelper\ for bridging Win32 cursor handles to Avalon \Cursor\ objects, \D3DImage\ for displaying Direct3D surfaces, and several input providers (\HwndAppCommandInputProvider\, \HwndKeyboardInputProvider\, \HwndMouseInputProvider\, \HwndPointerInputProvider\) that handle Windows messages for keyboard, mouse, stylus, and application commands. Also added \HwndSource\ and related helper classes to manage Win32 window integration and input routing.

src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/InterOp · high confidence

The following new types were added to the \System.Windows.Controls.Primitives\ namespace, enabling richer UI composition and control behavior: \AutoToolTipPlacement\ enum for Slider tooltips; \BulletDecorator\ for decorating content with glyphs; \ButtonBase\ as the abstract base for button controls; \CalendarButton\ and \CalendarDayButton\ for Calendar control interactions; \CalendarItem\ for the Calendar's internal layout; \CustomPopupPlacement\ and \CustomPopupPlacementCallback\ for custom popup positioning; \DataGridCellsPresenter\ and \DataGridColumnHeader\ for DataGrid header and cell management. These additions provide the foundational building blocks for WPF controls, allowing developers to create custom templates, handle specific UI states, and manage complex layouts like calendars and data grids.

src/Microsoft.DotNet.Wpf/src/PresentationFramework/System/Windows/Controls/Primitives · high confidence

New internal classes have been added to the WPF shared telemetry layer to support Asimov-compatible event sourcing and control usage tracking. The \TelemetryEventSource\ class provides a base for writing telemetry events with specific keywords (Telemetry, Measures, CriticalData) and tags (PII handling, latency, persistence). The \EventSourceActivity\ class manages activity-based tracing with start/stop states and parent-child relationships. Additionally, \TraceLoggingProvider\ handles the lazy, thread-safe initialization of the event source, while specific trace loggers (\ControlsTraceLogger\ and \XpsOMPrintingTraceLogger\) are introduced to log which WPF controls are used in an application and the status of Xps OM printing, respectively.

src/Microsoft.DotNet.Wpf/src/Shared/Telemetry · high confidence

The WPF PresentationUI assembly now includes the full set of XAML theme files (Aero, Aero2, AeroLite, Classic, Generic, Luna variants, and MediaCenter), providing the default visual styles for Windows Presentation Foundation applications. Additionally, C++ header and source files for the System.Printing component have been added to support the native interop layer for printing functionality.

src/Microsoft.DotNet.Wpf/src/PresentationUI/Themes, src/Microsoft.DotNet.Wpf/src/System.Printing/CPP · high confidence

The PresentationUI assembly now includes new XAML and code-behind files for the installation error and progress screens. The \InstallationError\ and \TenFeetInstallationError\ pages display error states, support links, and buttons to view logs or retry. The \TenFeetInstallationProgress\ page tracks download progress, displaying publisher, application name, and byte counts. These pages implement the \IErrorPage\ and \IProgressPage\ interfaces, providing the user interface for WPF-based installation scenarios.

src/Microsoft.DotNet.Wpf/src/PresentationUI · high confidence

The UI Automation client-side providers now include a new set of files in the MS.Win32 namespace that define Win32 constants, safe and unsafe P/Invoke signatures, and DLL name mappings. This adds the underlying Windows API bindings required for UI Automation to interact with native controls and system components.

src/Microsoft.DotNet.Wpf/src/UIAutomation/UIAutomationClientSideProviders/MS/Win32 · high confidence

The Windows Forms integration layer now includes new internal helper classes and constants to interact with native Windows APIs. Specifically, the diff adds DCSafeHandle, ExternDll, NativeMethods, SafeNativeMethods, and UnsafeNativeMethods, which provide managed wrappers for Win32 functions such as GetDeviceCaps, CreateDC, DeleteDC, and various window messages and states. These changes consolidate low-level P/Invoke declarations and constants (e.g., WM\\, UIS\\) into a structured internal API, enabling the Windows Forms integration components to communicate with the underlying OS more reliably.

src/Microsoft.DotNet.Wpf/src/WindowsFormsIntegration/MS · high confidence

Introduced a new set of classes in the \System.Windows.Forms.Integration\ namespace to facilitate the hosting of WPF elements within Windows Forms applications. This includes the \ElementHost\ control, which acts as a container for WPF content, and supporting infrastructure such as \ApplicationInterop\ for managing keyboard and message filtering, \Convert\ for translating between WPF and WinForms types (like cursors and images), \PropertyMap\ for synchronizing host control properties, and various event argument classes (\ChildChangedEventArgs\, \IntegrationExceptionEventArgs\, etc.) to handle state changes and errors.

src/Microsoft.DotNet.Wpf/src/WindowsFormsIntegration/System/Windows/Integration · high confidence

New internal classes have been added to PresentationCore to wrap WinRT APIs for the InputPane (touch keyboard) and UISettings (accent colors). These changes enable WPF applications to programmatically show/hide the touch keyboard and retrieve system accent colors, with fallbacks to default colors if the WinRT APIs are unavailable.

src/Microsoft.DotNet.Wpf/src/PresentationCore/MS/internal/WindowsRuntime · high confidence

The WindowsBase library now includes new internal interop wrappers for Win32 error codes and HRESULTs, along with native structure definitions for COM and file system operations. Additionally, a new tracing system has been introduced, providing \TraceSource\ instances for debugging WPF components like DependencyProperties, Freezables, and data binding, accessible via the \PresentationTraceSources\ class.

src/Microsoft.DotNet.Wpf/src/WindowsBase/MS/Internal/Interop, src/Microsoft.DotNet.Wpf/src/WindowsBase/System/Diagnostics · high confidence

The \System.Windows.Interop\ namespace now includes the \ComponentDispatcher\ and \ComponentDispatcherThread\ classes, which manage the message pump, idle processing, and modal state for the current thread. Additionally, the \IKeyboardInputSink\ and \IKeyboardInputSite\ interfaces are introduced to allow UI components to participate in tabbing, accelerators, and mnemonic processing. The \MSG\ struct is also added to represent Win32 window messages, with write access restricted to prevent security vulnerabilities in partial trust scenarios.

src/Microsoft.DotNet.Wpf/src/WindowsBase/System/Windows/Interop · high confidence

Added new header and source files to the WpfGfx include directory, including build scripts (GraphicsInclude.nativeproj), C++ headers (InternalGUIDs.h, spec\_string.h, std.h, wgx\_core\_types.h, wgx\_effect\_types.h), and C\# source files (exports.cs, wgx\_core\_dllname.cs, wgx\_error.cs). These files define internal GUIDs, memory management locks, P/Invoke wrappers for the MIL core, and error code enumerations, supporting the WPF graphics subsystem.

src/Microsoft.DotNet.Wpf/src/WpfGfx/include · high confidence

Introduced new internal classes in the System.Xaml namespace to support XAML parsing and object writing, including context management (ObjectWriterContext, XamlParserContext), frame stacks (ObjectWriterFrame, XamlCommonFrame), and dependency tracking (NameFixupGraph, NameFixupToken). These changes provide the foundational state management and namespace resolution logic required for processing XAML documents.

src/Microsoft.DotNet.Wpf/src/System.Xaml/System/Xaml/Context · high confidence

The WPF XAML serialization infrastructure has been expanded with new internal classes in the \System.Windows.Markup.Primitives\ namespace. \ElementMarkupObject\ provides the core implementation for serializing \DependencyObject\ and CLR objects, handling property enumeration, constructor arguments, and pseudo-properties for collections and dictionaries. \ExtensionSimplifierMarkupObject\ and its associated wrappers (\MarkupObjectWrapper\, \MarkupPropertyWrapper\) simplify markup extensions during serialization. \FrameworkElementFactoryMarkupObject\ handles the serialization of \FrameworkElementFactory\ instances, including their properties and content. \MarkupWriter\ provides the public API (\GetMarkupObjectFor\, \SaveAsXml\) to serialize object trees to XML, enforcing serialization constraints such as public visibility and non-generic types.

src/Microsoft.DotNet.Wpf/src/PresentationFramework/System/Windows/Markup/Primitives · high confidence

The WPF framework now includes new internal classes, SystemXmlExtension and XmlNodeComparer, to enable sorting of data produced by an XmlDataSource. The SystemXmlExtension class provides helper methods to identify and extract values from XmlNode objects, while the XmlNodeComparer implements IComparer to sort a view of data based on XPath queries and culture-specific string comparisons.

src/Microsoft.DotNet.Wpf/src/Extensions/PresentationFramework-SystemXml · high confidence

The ReachFramework's XPS packaging subsystem has been implemented with a new set of classes in the \src/Microsoft.DotNet.Wpf/src/ReachFramework/Packaging\ directory. This includes the \XpsDocument\ class for reading and writing XPS packages, along with supporting types such as \XpsFixedDocumentReaderWriter\, \XpsFixedPageReaderWriter\, \XpsDigitalSignature\, and \XpsInterleavingPolicy\. These classes provide the core functionality for managing XPS document structures, fixed pages, and digital signatures within the WPF framework.

src/Microsoft.DotNet.Wpf/src/ReachFramework/Packaging · high confidence

The ReachFramework now includes the necessary resources and build tools to handle XPS (XML Paper Specification) schemas. This change adds the \Strings.resx\ file containing localized error messages for the ReachFramework, along with a new \Resources\ directory structure containing XSD schema files (such as \ContentTypes.xsd\, \OPC\_DigSig.xsd\, \SignatureDefinitions.xsd\, and \coreproperties.xsd\) in their master, publish, and validation variants. Additionally, the \SchemaGen\ and \SchemaPP\ C\# source files and a \generate.cmd\ script are introduced to preprocess and compile these schemas into embedded resources, enabling the framework to validate and process XPS documents according to the specified XML schemas.

src/Microsoft.DotNet.Wpf/src/ReachFramework/Resources, src/Microsoft.DotNet.Wpf/src/System.Windows.Input.Manipulations/Resources, src/Microsoft.DotNet.Wpf/src/UIAutomation/UIAutomationProvider/Resources · high confidence

Introduced new classes for XPS serialization within the ReachFramework, including type converters for colors, fonts, and images, alongside supporting infrastructure like a CRC32 calculator, a drawing context flattener, and services for handling font subsets and image resources. These additions enable the serialization of visual tree elements, fonts, and images into XPS packages.

src/Microsoft.DotNet.Wpf/src/ReachFramework/Serialization · medium confidence

Added new files in the ReachFramework serialization layer, including the \IXpsSerializationManager\ and \IXpsSerializationManagerAsync\ interfaces, along with implementations such as \NgcSerializationManager\, \NgcSerializationManagerAsync\, and various serializer classes (e.g., \NgcFixedDocumentSerializer\, \NgcPageContentSerializerAsync\). These changes introduce the core infrastructure for serializing Avalon content into XPS format, supporting both synchronous and asynchronous serialization workflows.

src/Microsoft.DotNet.Wpf/src/ReachFramework/Serialization/manager · high confidence

A new \Redist\ project has been introduced in the WPF distribution to manage the build and packaging of redistributable components. This includes a \Directory.Build.props\ file that marks the project as a redistribution target and a \Redist.sln\ solution file that defines the build configurations for the \VCRuntime\ and \D3DCompiler\ native libraries across Debug/Release and x86/x64 architectures.

src/Microsoft.DotNet.Wpf/redist · high confidence

Introduced new build scripts and project files (ThemeGenerator.Fluent.ps1, ThemeGenerator.pl, ThemeGenerator.proj) that automate the generation of combined XAML resource dictionaries for the Fluent theme. This infrastructure consolidates individual control styles and color resources into unified theme files (Light, Dark, High Contrast, and System), enabling the WPF framework to apply consistent, theme-aware styling to controls such as buttons, text boxes, and data grids.

src/Microsoft.DotNet.Wpf/src/Themes · high confidence

The WindowsBase library now includes a comprehensive set of types for collection view management and component model support. This includes interfaces such as ICollectionView, ICollectionViewLiveShaping, and IEditableCollectionView, along with their corresponding event managers (e.g., CurrentChangedEventManager, ErrorsChangedEventManager, PropertyChangedEventManager) that implement the weak event listener pattern. Additionally, the change introduces the DependencyPropertyDescriptor class for wrapping property descriptors with dependency property features, and provides the ItemPropertyInfo class and IItemProperties interface to expose item property information. These additions enable advanced data binding, sorting, filtering, grouping, and editing capabilities within WPF applications.

src/Microsoft.DotNet.Wpf/src/WindowsBase/System/ComponentModel · high confidence

Introduced a suite of new documentation files to guide developers through the WPF build and contribution processes. The Developer Guide details local machine setup, running DRTs, debugging locally built assemblies, and testing API changes. New files cover the pull request acceptance criteria, code generation via T4 templates, API compatibility checking, and C++/CLI build constraints. Additional guides address issue tracking, cycle breakers, and localization, providing a complete reference for contributors and maintainers.

Documentation · high confidence

The WPF and Windows Base libraries now include the AdornerHitTestResult class, which provides hit test results for adorner layers, and the ICustomTypeProvider interface for custom type resolution. Additionally, shared internal headers and IDL-generated C/C++ files for Windows Media Player controls and multimedia attributes have been added to the shared internal directory.

src/Microsoft.DotNet.Wpf/src/PresentationFramework/System/Windows/Design, src/Microsoft.DotNet.Wpf/src/Shared/internal, src/Microsoft.DotNet.Wpf/src/WindowsBase/System/Reflection · medium confidence

The WPF framework now includes the foundational classes for document flow and visual decoration, including Adorner, AdornerLayer, Block, and related types. This adds support for rendering decorative overlays on UI elements and managing structured text content, enabling features like custom selection highlights, text editing cursors, and embedded UI elements within text flows.

src/Microsoft.DotNet.Wpf/src/PresentationFramework/System/Windows/Documents · high confidence

The \System.Windows.Documents.Serialization\ namespace now includes the core types that enable a plug-in architecture for document serialization. \ISerializerFactory\ and \SerializerDescriptor\ allow external assemblies to register themselves as available serializers, while \SerializerProvider\ manages the discovery and registration of these plug-ins via the Windows Registry. \SerializerWriter\ and \SerializerWriterCollator\ provide the abstract base classes that serializers must implement to handle writing \Visual\ and \DocumentPaginator\ content. This change introduces the foundational classes and interfaces required for the document serialization system to support third-party or custom serialization plugins.

src/Microsoft.DotNet.Wpf/src/PresentationFramework/System/Windows/Documents/Serialization · high confidence

The PresentationFramework-SystemCore extension now includes a new implementation for dynamic property and indexer accessors. The \DynamicAccessorImpl.cs\ file introduces \DynamicPropertyAccessorImpl\ and \DynamicIndexerAccessorImpl\ classes that utilize the \System.Dynamic\ namespace to provide runtime access to properties and indexers on objects implementing \IDynamicMetaObjectProvider\. This allows WPF data binding and other features to dynamically access members on dynamic objects, with the \SystemCoreExtension\ class providing the factory methods to instantiate these accessors.

src/Microsoft.DotNet.Wpf/src/Extensions/PresentationFramework-SystemCore · high confidence

New generated files (AvTraceMessages.cs) were added to the PresentationCore and WindowsBase projects. These files define internal trace message classes for RoutedEvents, Animations, DependencyProperties, Freezables, and NameScopes, enabling detailed diagnostic tracing for these core WPF subsystems.

src/Microsoft.DotNet.Wpf/src/PresentationCore/MS/internal/Generated, src/Microsoft.DotNet.Wpf/src/WindowsBase/MS/Internal/Generated · high confidence

Added a new set of automatically generated files in the WpfGfx/Generated directory, including wgx\_command\_types.cs/h, wgx\_commands.cs/h, wgx\_misc.cs/h, wgx\_render\_types\_generated.h, wgx\_renderdata\_commands.h, and wgx\_resource\_types.cs/h. These files define the C\# and C/C++ enums, structs, and types that bridge the Media Integration Layer (MIL) commands and resources, enabling the managed WPF code to communicate with the native graphics subsystem.

src/Microsoft.DotNet.Wpf/src/WpfGfx/include/Generated · high confidence

The PresentationFramework library now includes generated code for animating Thickness properties. This includes the base class ThicknessAnimationBase and the concrete ThicknessAnimation class, as well as the keyframe-based ThicknessAnimationUsingKeyFrames and its associated collection. The change also introduces the abstract base ThicknessKeyFrame and its concrete implementations (Discrete, Linear, Spline, and Easing variants) to support complex, multi-step thickness animations in WPF.

src/Microsoft.DotNet.Wpf/src/PresentationFramework/System/Windows/Media · high confidence

The WPF runtime now includes new internal classes in the MS.Internal.AppModel namespace to manage HTTP cookies, custom credential policies for web requests, and loading resources from the site of origin. CookieHandler intercepts web requests and responses to manage cookies via WinInet. CustomCredentialPolicy registers a default credential policy that sends credentials for intranet, trusted, and local machine zones, while restricting default credentials for internet and untrusted zones. SiteOfOriginContainer and SiteOfOriginPart provide a mechanism to access application resources from the site of origin, supporting both local file and HTTP web requests.

src/Microsoft.DotNet.Wpf/src/PresentationCore/MS/internal/AppModel · high confidence

The WindowsBase library now includes a new internal implementation for Rights Management (RM) support, introducing a managed wrapper around the unmanaged Promethium RM SDK. This change adds several new files to the \MS.Internal.Security.RightsManagement\ namespace, including \CallbackHandler.cs\ for managing asynchronous callbacks from the SDK, \ClientSession.cs\ for handling client sessions and activation, \Errors.cs\ for mapping SDK error codes to .NET exceptions, and \NativeRightsManagementAPIs\*.cs\ files that define the P/Invoke signatures and constants for the native APIs. This provides the foundational infrastructure for .NET applications to interact with Windows Rights Management services.

src/Microsoft.DotNet.Wpf/src/WindowsBase/MS/Internal/Security/RightsManagement · high confidence

The UI Automation types library now includes internal support for mapping UI Automation identifiers (properties, events, patterns, control types, and text attributes) to their underlying GUIDs and integer values. This change introduces \AutomationIdentifierConstants\ to manage version-specific support for Windows releases (from Windows 7 through Windows 10 RS5), \UiaCoreTypesApi\ to wrap calls to the \UIAutomationCore\ DLL, and \CodeQuality\_Approved.cs\ to suppress specific code analysis warnings for internal namespaces.

src/Microsoft.DotNet.Wpf/src/UIAutomation/UIAutomationTypes/MS · high confidence

The PresentationCore library introduces a new internal \MS.Internal.Automation\ namespace containing a suite of classes that bridge WPF's \AutomationPeer\ infrastructure to the Windows UI Automation (UIA) provider model. This includes \ElementProxy\ and \ElementUtil\ to manage the visual tree and dispatching, \EventMap\ to track registered UIA events, and specific provider wrappers (e.g., \DockProviderWrapper\, \ExpandCollapseProviderWrapper\, \GridProviderWrapper\) that implement UIA interfaces like \IDockProvider\ or \IExpandCollapseProvider\. These changes enable WPF controls to expose their accessibility features to assistive technologies by marshalling calls from the UIA RPC thread onto the correct dispatcher context.

src/Microsoft.DotNet.Wpf/src/PresentationCore/MS/internal/Automation · high confidence

The System.Xaml library introduces several new internal classes in the System.Xaml.MS.Impl namespace to support XAML schema and namespace handling. This includes AssemblyNamespacePair for tracking assembly and CLR namespace associations, a thread-safe ConcurrentDictionary implementation for .NET 3.5 compatibility, KnownStrings for managing XAML directive strings, PositionalParameterDescriptor for handling positional parameters, XamlDirectiveCollection for managing XAML directives, XamlPropertyInfoKey for property metadata, and XmlNsInfo for XML namespace information. These classes provide the foundational infrastructure for XAML parsing and schema resolution.

src/Microsoft.DotNet.Wpf/src/System.Xaml/System/Xaml/MS · high confidence

The WPF framework now includes a new set of internal classes to support document annotation anchoring and animation interpolation. The \AnimatedTypeHelpers\ class provides static methods for interpolating and performing arithmetic on \Thickness\ and \Double\ values, which are used by the animation system. Additionally, a complete set of internal classes has been added to the \MS.Internal.Annotations.Anchoring\ namespace, including \AttachedAnnotation\, \DataIdProcessor\, \FixedPageProcessor\, \FixedTextSelectionProcessor\, \LocatorManager\, \PathNode\, and \SelectionProcessor\. These classes implement the core logic for locating, generating, and resolving content locators for annotations in paginated documents and text selections.

src/Microsoft.DotNet.Wpf/src/PresentationFramework/MS · high confidence

The ReachFramework's internal printing configuration layer now includes new classes to manage printer device modes and resource strings. This includes the \COMPSTUISR\ class for retrieving localized strings from \compstui.dll\, and a suite of \DevMode\*\ classes (e.g., \DevMode\, \DevModePaperSizes\, \DevModeOrientation\) that map Windows GDI \DEVMODE\ structures and capabilities to .NET types. These additions provide the underlying support for printer settings and paper size resolution.

src/Microsoft.DotNet.Wpf/src/ReachFramework/MS · high confidence

The WPF PresentationCore library now includes a suite of internal classes to support advanced ink (stylus) handling. This includes \Bezier\ for curve generation and flattening, \CuspData\ for analyzing stylus points and detecting cusps, \ContourSegment\ for representing edges in hit-testing, \DrawingFlags\ for rendering options, \EllipticalNodeOperations\ for processing elliptical stroke nodes, \ErasingStroke\ for managing erasing contours and hit-testing, \ExtendedProperty\ and \ExtendedPropertyCollection\ for storing and managing custom drawing attributes, \Lasso\ for polygonal selection regions, \Quad\ as a helper structure for connecting stroke nodes, and \Renderer\ for drawing ink. These components enable more accurate stroke fitting, hit-testing, and rendering of ink strokes.

src/Microsoft.DotNet.Wpf/src/PresentationCore/MS/internal/Ink · high confidence

The PresentationCore library introduces several new internal helper classes to support BAML serialization and text rendering options. ParserStreamGeometryContext is added to compress Path data into a compact binary format for startup performance and smaller BAML files. TextOptionsInternal provides attached properties for text hinting modes. XamlSerializationHelper and related structs (ThreeDoublesMarkup, Point, Size) support the conversion of types to custom binary formats. VisualTreeUtils adds internal methods for propagating flags and handling hit tests within the visual tree.

src/Microsoft.DotNet.Wpf/src/PresentationCore/MS/internal/Media · high confidence

Introduced several new internal classes in the \MS.Internal.IO.Packaging\ namespace to support package resource handling. \ByteRangeDownloader\ handles downloading resources via HTTP byte range requests. \DeobfuscatingStream\ provides a read-only stream that de-obfuscates font data according to the XPS specification. \NetStream\ implements a stream supporting progressive download and simultaneous web requests. \PreloadedPackages\ manages a global cache of preloaded packages. \PseudoWebRequest\ handles pack-specific URI requests resolved from the package store. \ResponseStream\ wraps streams to manage the lifetime of web response containers. These changes enhance the internal IO capabilities for packaging and resource management.

src/Microsoft.DotNet.Wpf/src/PresentationCore/MS/internal/IO · high confidence

A new \KnownIds.cs\ file was added to the \System.Windows.Ink\ namespace, defining static \Guid\ constants for various ink-related properties such as \StylusHeight\, \StylusWidth\, \Color\, and spatial orientation attributes like \XTiltOrientation\ and \TwistOrientation\. These identifiers are mapped from an internal \KnownIdCache\ and are used to identify specific ink data attributes within the WPF ink subsystem.

src/Microsoft.DotNet.Wpf/src/Shared/System/Windows/Ink · high confidence

The WPF markup compilation tasks now include a new resource file (Strings.resx) containing English localization strings for build and compilation status messages, such as 'MarkupCompilePass1 successfully generated BAML or source code files' and 'Markup compilation is done.' This change supports internationalization of the build task's output messages.

src/Microsoft.DotNet.Wpf/src/PresentationBuildTasks/Resources · high confidence

Added the English source resource file (Strings.resx) and corresponding XLIFF translation files for Czech, German, Spanish, French, and Italian. These files provide localized error messages for various WindowsBase components, including Freezable, Dispatcher, and array operations, ensuring users see appropriate error text in their preferred language.

src/Microsoft.DotNet.Wpf/src/WindowsBase/Resources · high confidence

The UIAutomationClientSideProviders library now includes comprehensive localization resources. This change adds the English resource files (ExceptionStringTable.txt, StringTable.txt, Strings.resx) and XLIFF translation files for Czech, German, Spanish, French, Italian, and Japanese, enabling the UI Automation client-side providers to display user-facing messages and control names in those languages.

src/Microsoft.DotNet.Wpf/src/UIAutomation/UIAutomationClientSideProviders/Resources · high confidence

Added the English resource file (Strings.resx) and XLIFF translation files for Czech, German, Spanish, French, Italian, Japanese, and Korean. These files provide localized display names for UI Automation control types, such as button, calendar, checkbox, and menu, enabling the UIAutomationTypes library to present these elements in the user's preferred language.

src/Microsoft.DotNet.Wpf/src/UIAutomation/UIAutomationTypes/Resources · high confidence

New C\# files were added to PresentationCore to expose Windows Ink (PenIMC), pointer, and tablet recognition native APIs. These changes introduce P/Invoke declarations and safe handle wrappers for the Win32 tablet and pointer stacks, enabling WPF to interact with the underlying OS input services.

src/Microsoft.DotNet.Wpf/src/PresentationCore/MS/Win32 · high confidence

The \cycle-breakers\ directory now contains a set of empty or minimal stub classes and structs for WPF and printing namespaces, including \OpenFolderDialog\, \PrintCapabilities\, \PrintTicket\, and various serialization delegates. These stubs are intended to satisfy the build system's dependency graph, allowing the actual implementations to be compiled in a separate pass without circular reference errors. This change also introduces an \.editorconfig\ file to suppress specific code analysis warnings for these stub files.

src/Microsoft.DotNet.Wpf/cycle-breakers · high confidence

The WPF \PresentationCore\ library now includes a complete C\# implementation for handling Ink Serialized Format (ISF) data, replacing previous native code dependencies. This adds new files for compression algorithms (Gorilla, Huffman), packet and property data serialization, and drawing attribute handling, enabling the .NET runtime to process and generate ink data without relying on the legacy \Penimc\ native library.

src/Microsoft.DotNet.Wpf/src/PresentationCore/MS/internal/Ink/InkSerializedFormat · high confidence

The System.Xaml parser now includes new internal classes to support parsing generic type names and markup extensions. Specifically, GenericTypeNameParser and GenericTypeNameScanner handle the parsing of generic type syntax (e.g., \Namespace.Type\<T\>\), while MePullParser and MeScanner provide the logic for parsing Markup Extensions (e.g., \{Binding ...}\). These components enable the XAML parser to correctly interpret complex type references and extension syntax within XAML content.

src/Microsoft.DotNet.Wpf/src/System.Xaml/System/Xaml/Parser · high confidence

The \src/Microsoft.DotNet.Wpf/src/WindowsBase/System/IO/Packaging/CompoundFile\ directory now includes several new internal classes that support the CompoundFile format. These include \DataSpaceManager\ for manipulating data spaces within a container, \FormatVersion\ for managing feature versioning, \StorageInfo\ and \StorageRoot\ for handling storages, \StreamInfo\ for handling streams, and \VersionPair\ for version tracking. These classes provide the underlying infrastructure for managing compound file structures, including data space management, storage hierarchy, and version control.

src/Microsoft.DotNet.Wpf/src/WindowsBase/System/IO/Packaging/CompoundFile · high confidence

The \src/Microsoft.DotNet.Wpf/src/ReachFramework/PrintConfig\ directory now contains a comprehensive set of internal classes for handling print job configurations and capabilities. This includes \PrintTicketConverter\ for converting between DEVMODE and PrintTicket formats, \PrintTicketManager\ for validating print tickets and resolving conflicts, and \PTProvider\ for interacting with unmanaged printer driver components. Additionally, new files define specific print features such as NUp, Collation, Duplex, Input Bins, Page Order, and Stapling, each with their respective option and capability classes that parse and expose printer settings.

src/Microsoft.DotNet.Wpf/src/ReachFramework/PrintConfig · high confidence

New reference assemblies have been added for the PresentationUI and WindowsFormsIntegration libraries. This includes the \PresentationUIStyleResources\ class in the \System.Windows.Documents\ namespace and the \ElementHost\ control along with related automation peers and event argument classes in the \System.Windows.Forms.Integration\ namespace, enabling better tooling support and compile-time checking for these WPF components.

src/Microsoft.DotNet.Wpf/src/PresentationUI/ref, src/Microsoft.DotNet.Wpf/src/WindowsFormsIntegration/ref · high confidence

New reference assemblies have been added for the ReachFramework and System.Xaml libraries, providing the public API surface for WPF printing and XAML parsing. These files define the enums, classes, and interfaces (such as PageMediaSizeName, INameScope, and various XAML attributes) that developers use to build and compile against these frameworks.

src/Microsoft.DotNet.Wpf/src/ReachFramework/ref, src/Microsoft.DotNet.Wpf/src/System.Xaml/ref · high confidence

The PresentationCore library now includes the sRGB.icm color profile as an embedded resource, allowing applications to access standard color definitions. A corresponding license file has been added to clarify that the sRGB.icm binary is licensed to Microsoft by Hewlett Packard and re-licensed under the MIT license.

src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/Media/Resources · high confidence

New shared C++ header files have been added to the WPF shared include directory, providing build information macros, safe coding and error-handling macros, OS version detection helpers, and utility functions for reading the registry and loading DWrite libraries. These headers support the underlying C++ components of WPF by centralizing common definitions and helper classes.

src/Microsoft.DotNet.Wpf/src/Shared/inc · high confidence

Introduced a new set of shared C++ headers and source files in the WPF graphics subsystem to support ARM64 and improve code safety. This includes arithmetic helpers with overflow-protected addition and multiplication, a thread-safety assertion class to detect single-threaded entry violations, a delegating IUnknown base class for COM interface management, and utility classes for DPI scaling and dynamic API loading. These additions provide foundational building blocks for the WPF graphics layer.

src/Microsoft.DotNet.Wpf/src/WpfGfx/common/shared · high confidence

The PresentationFramework assembly now includes a new \Standard\ namespace containing utility classes such as \ComGuids\, \Debug\, \DoubleUtilities\, \DpiHelper\, \ErrorCodes\, \MessageWindow\, \NativeMethods\, \ShellProvider\, and \Utilities\. These classes provide internal support for COM interop, DPI scaling, Windows shell integration, and native method calls, enabling core WPF functionality like taskbar progress, file dialogs, and window management.

src/Microsoft.DotNet.Wpf/src/PresentationFramework/System/Windows/Standard · high confidence

A new InternalEncoding class has been added to register the CodePagesEncodingProvider, enabling access to additional character encodings (such as Windows-1252, GB2312, etc.) that are not included by default in .NET Core. This ensures that WPF applications can correctly handle text in various international code pages without requiring external dependencies or manual registration of encoding providers.

src/Microsoft.DotNet.Wpf/src/Shared/MS/Internal/Text · high confidence

The \System.IO.Packaging\ namespace now includes new types to support encrypted packages and digital signatures. \EncryptedPackageEnvelope\ enables creating and managing OLE compound files that hold encrypted packages with embedded publish and use licenses via \RightsManagementInformation\. Additionally, \PackageDigitalSignature\ and \PackageDigitalSignatureManager\ provide APIs to add, remove, and verify digital signatures on packages, including support for certificate embedding options and signature validation events.

src/Microsoft.DotNet.Wpf/src/WindowsBase/System/IO/Packaging · high confidence

A new internal \WindowBackdropManager\ class has been introduced to manage window backdrops, enabling visual effects like the tabbed window and main window backdrop types on Windows 11. This implementation relies on the \DwmSetWindowAttributeSystemBackdropType\ API and respects the \DisableFluentThemeWindowBackdrop\ framework switch, allowing applications to render system-defined window backgrounds.

src/Microsoft.DotNet.Wpf/src/PresentationFramework/System/Windows/Appearance · high confidence

The text formatting subsystem in PresentationCore now includes a comprehensive set of new types to support text layout and rendering. This includes the \CharacterBufferReference\ struct for managing character buffers, \CharacterHit\ for hit-testing, \CharacterBufferRange\ for string ranges, and \CultureSpecificCharacterBufferRange\ for culture-aware text. Additionally, \IndexedGlyphRun\ maps text indices to glyph runs, \MinMaxParagraphWidth\ calculates paragraph width constraints, and \NumberSubstitution\ handles locale-specific number formatting. The update also introduces \TextBounds\ and \TextRunBounds\ for bounding rectangle calculations, \TextBreakpoint\ for line-breaking states, \TextCharacters\ for symbol shaping, \TextCollapsingProperties\ for text collapsing features, \TextEmbeddedObject\ for inline objects, and \TextEndOfLine\ for line break control.

src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/Media/textformatting · high confidence

The codebase now includes new internal classes to manage the Windows touch keyboard and handle COM interop. The \TipTsfHelper\ class provides logic to show and hide the touch keyboard, ensuring it appears when appropriate text input fields are focused. Additionally, \IUnknown\ and \NativePointerCriticalHandle\ introduce managed wrappers for COM interfaces and native pointers, facilitating safer interaction with unmanaged code.

src/Microsoft.DotNet.Wpf/src/PresentationCore/MS/internal/Interop · high confidence

A new trace logger, SpellerCOMActionTraceLogger, has been added to the WPF Documents tracing subsystem. It tracks the latency of COM calls related to spell-checking (creation, dictionary registration/unregistration, and comprehensive checks). This allows the platform to measure and monitor performance issues arising from stale COM registrations, particularly on Windows 8.1+.

src/Microsoft.DotNet.Wpf/src/PresentationFramework/System/Windows/Documents/Tracing · high confidence

New files CommandConverter.cs and CommandValueSerializer.cs were added to the PresentationFramework, enabling the conversion of RoutedCommand instances to and from string representations. This allows commands to be serialized in XAML and deserialized back into command objects, supporting both known commands and custom commands defined as static properties or fields.

src/Microsoft.DotNet.Wpf/src/PresentationFramework/System/Windows/Input/Command · high confidence

The PresentationCore library now includes a new set of generated ValueSerializer classes for converting between string representations and .NET types used in XAML markup. This change adds generated serializers for 2D and 3D media types, including Brush, CacheMode, Geometry, Transform, and various collection types (DoubleCollection, Int32Collection, PathFigureCollection, PointCollection, VectorCollection) in the System.Windows.Media.Converters namespace, as well as Matrix3D, Point3D, Point4D, Quaternion, Rect3D, Size3D, and Vector3D in the System.Windows.Media.Media3D.Converters namespace. These classes implement the ValueSerializer contract to enable the XAML parser to serialize and deserialize these types during markup parsing and writing.

src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/Media/Converters, src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/Media3D/Converters · high confidence

The \FrameworkContentElement\ and \FrameworkElement\ classes in the \System.Windows\ namespace are now generated by the MilCodeGen tool, providing the underlying implementation for core WPF UI elements. This change introduces the generated source files for these types, which handle name scoping, logical tree management, and resource lookup, replacing or augmenting the previous manual implementation.

src/Microsoft.DotNet.Wpf/src/PresentationFramework/System/Windows/Generated · high confidence

The MilCodeGen tool was run to generate new validation methods for various WPF enumeration types, including AlignmentX, BitmapScalingMode, BrushMappingMode, FillRule, GeometryCombineMode, PenLineCap, and TextRenderingMode. These generated files provide internal helper methods to validate enumeration values, which are used by the framework's property system to ensure type safety and correctness.

src/Microsoft.DotNet.Wpf/src/Shared/MS/Internal/Generated · high confidence

The \src/Microsoft.DotNet.Wpf/src/WindowsBase/System/Windows/Generated\ directory now contains the generated C\# source files for several WindowsBase value types and their associated type converters: \Int32Rect\ and \Int32RectConverter\, \Point\ and \PointConverter\, \Rect\ and \RectConverter\, \Size\ and \SizeConverter\, and \Vector\ and \VectorConverter\. These files, produced by the MilCodeGen tool, provide the structural definitions, equality checks, parsing, and string conversion capabilities for these geometric types, enabling their use in XAML and data-binding scenarios.

src/Microsoft.DotNet.Wpf/src/WindowsBase/System/Windows/Generated, src/Microsoft.DotNet.Wpf/src/WindowsBase/System/Windows/Media/Generated · high confidence

Added generated ValueSerializer classes for Int32Rect, Point, Rect, Size, Vector, and Matrix. These new files in the WindowsBase converters enable string-to-type and type-to-string conversions for these specific geometric and structural types, supporting XAML markup parsing and serialization.

src/Microsoft.DotNet.Wpf/src/WindowsBase/System/Windows/Converters, src/Microsoft.DotNet.Wpf/src/WindowsBase/System/Windows/Media/Converters · high confidence

The WPF Ribbon control now exposes a complete set of AutomationPeers (e.g., for Ribbon, RibbonButton, RibbonComboBox, and InRibbonGallery), enabling screen readers and other assistive technologies to properly identify control types, retrieve labels, and interact with UI elements like scroll buttons and context menus.

src/Microsoft.DotNet.Wpf/src/System.Windows.Controls.Ribbon/Microsoft · high confidence

The shared utility classes in src/Microsoft.DotNet.Wpf/src/Shared/MS/Utility are introduced, including BindUriHelper, FrugalList, FrugalMap, ItemList, ItemMap, DTypeMap, PerfService, and Trace/TraceProvider. These provide optimized, low-allocation collections and diagnostic tracing capabilities for the WPF and XAML frameworks.

src/Microsoft.DotNet.Wpf/src/Shared/MS/Utility · high confidence

The PresentationCore assembly now includes a suite of internal helper classes and types in the MS.Internal namespace, including AnimatedTypeHelpers for interpolation and addition of various data types, CheckedPointers for safe pointer handling, Classification for Unicode script and character classification, CoreAppContextSwitches for runtime configuration, CustomCategoryAttribute for localized categories, DeferredElementTreeState for managing element tree changes, DpiScale2 for DPI scale operations, IListConverters for serializing lists, IVisual3DContainer for 3D container operations, KnownBoxes for caching common values, LoadedOrUnloadedOperation for deferred UI operations, MediaTrace for debug tracing, and PartialArray for array ranges. These additions support internal WPF rendering, layout, and accessibility features.

src/Microsoft.DotNet.Wpf/src/PresentationCore/MS/internal · high confidence

Added core classes for the WPF animation engine, including \Animatable\, \AnimationClock\, \AnimationClockResource\, \AnimationLayer\, \AnimationStorage\, \AnimationTimeline\, \AnimationType\, and various easing functions (\BackEase\, \BounceEase\, \CircleEase\). These files implement the runtime state management, property animation, and timing control for WPF UI elements.

src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/Media/Animation · high confidence

Added new runtime classes in the System.Xaml namespace to handle XAML object instantiation, factory method invocation, and value conversion. The \ClrObjectRuntime\ class provides a standard reflection-based implementation for creating instances and converting values. The \DynamicMethodRuntime\ class offers a performance-optimized alternative using dynamic method generation to access non-public members. Additionally, \PartialTrustTolerantRuntime\ implements a fallback strategy that attempts transparent execution first and switches to the elevated dynamic method runtime if access is denied, ensuring compatibility across different trust levels.

src/Microsoft.DotNet.Wpf/src/System.Xaml/System/Xaml/Runtime · high confidence

The XAML schema namespace now includes a comprehensive set of classes for reflecting CLR types and managing value conversions. This includes \ClrProperty\, \ClrEvent\, and \ClrAttachableProperty\ to represent metadata about types, properties, and events. A new \BuiltInValueConverter\ class provides optimized, lazy-initialized converters for common types like \Int32\, \String\, and \DateTime\. Additionally, \CollectionReflector\ and \MemberReflector\ handle the detection of collection and dictionary types via reflection, while \ReferenceEqualityComparer\ ensures correct identity-based equality for schema objects.

src/Microsoft.DotNet.Wpf/src/System.Xaml/System/Xaml/Schema · high confidence

Added a new internal text shaping and layout engine in PresentationCore, including classes for composite font families, typeface metrics, glyph information lists, and OpenType layout processing. This introduces new internal APIs for contextual lookups, glyph caching, and font table handling, enabling more robust text rendering and layout capabilities within the WPF text formatting pipeline.

src/Microsoft.DotNet.Wpf/src/PresentationCore/MS/internal/Shaping · high confidence

Added new types to the \System.Windows.Media.Imaging\ namespace, including the \BitmapCacheOption\ and \BitmapCreateOptions\ enumerations, the \BitmapCodecInfo\ class for codec metadata, and the core \BitmapDecoder\, \BitmapEncoder\, \BitmapFrame\, and \BitmapImage\ classes. These changes provide the foundational classes and options for loading, caching, and encoding images in WPF applications.

src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/Media/Imaging · high confidence

The PresentationCore library adds several new types to support clipboard operations and UI behavior configuration. This includes the \AutoResizedEvent\ delegate and \AutoResizedEventArgs\ for handling window resize events, and a suite of \DataObject\*\ classes (\DataObjectCopyingEventArgs\, \DataObjectEventArgs\, \DataObjectPastingEventArgs\) that expose the \Copying\ and \Pasting\ events, allowing applications to inspect or modify clipboard data before it is used. Additionally, \CoreCompatibilityPreferences\ is introduced to allow runtime configuration of WPF behaviors such as ink bounding box calculations and multi-monitor clipping via application settings. The \DataFormat\ and \DataFormats\ classes provide a structured way to manage standard and custom clipboard data formats.

src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows · high confidence

Added several new internal classes to the WPF PresentationCore stylus subsystem to handle raw input and system gestures. This includes \DynamicRenderer\ and \DynamicRendererThreadManager\ to manage off-application dispatcher inking and thread management, \MultiTouchSystemGestureLogic\ to detect two-finger tap and rollover gestures, and a suite of classes (\RawStylusInput\, \RawStylusInputReport\, \RawStylusSystemGestureInputReport\, \RawStylusActions\) to encapsulate and validate raw stylus data and actions. These changes provide the underlying infrastructure for processing stylus and touch input events.

src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/Input/Stylus/Common · high confidence

Added a new set of internal classes within the ReachFramework's AlphaFlattener namespace, including BrushProxy, DrawingContext, Flattener, ImageProxy, Interfaces, MetroDevice, Optimizer, Primitive, PrimitiveList, and PrimitiveRenderer. These components implement a tree-flattening and alpha-flattening pipeline that rasterizes complex visual trees into a DisplayList for more efficient rendering of opacity, gradients, and image blending in the print and print-preview subsystems.

src/Microsoft.DotNet.Wpf/src/ReachFramework/AlphaFlattener · high confidence

The WindowsBase library now exposes a new set of AppContext-based compatibility switches, including \BaseCompatibilityPreferences\ and \AccessibilitySwitches\, which allow applications to opt into legacy behaviors for dispatcher synchronization context handling and accessibility features. Additionally, new attributes (\AttachedPropertyBrowsableForTypeAttribute\, \AttachedPropertyBrowsableWhenAttributePresentAttribute\) have been added to control the visibility of attached properties in design-time and type-descriptor scenarios, giving developers finer control over which types or attributes make properties browsable.

src/Microsoft.DotNet.Wpf/src/WindowsBase/System/Windows · high confidence

Added new internal classes for the WISP stylus input stack, including PenContext, PenThread, PenThreadPool, WispLogic, and WispStylusDevice. These files implement the core logic for handling stylus and touch input events, managing tablet device contexts, and coordinating with the underlying PenIMC COM interfaces.

src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/Input/Stylus/Wisp · high confidence

Added a new set of internal classes to the PresentationCore font cache, including BufferCache for thread-safe array pooling, CachedFontFace and CachedFontFamily for efficient font face and family representation, and CanonicalFontFamilyReference for normalized font family resolution. These changes establish a new internal architecture for managing font resources, replacing previous implementations with a more structured caching and lookup mechanism.

src/Microsoft.DotNet.Wpf/src/PresentationCore/MS/internal/FontCache · high confidence

Adds a new shared C++ library (OSVersionHelper) that provides native C++ functions to detect Windows versions (XP through 10/Server) and retrieve OS version details. This enables WPF to perform runtime OS checks in native code, supporting features like ARM64 builds and improved compatibility with various Windows releases.

src/Microsoft.DotNet.Wpf/src/Shared/OSVersionHelper · high confidence

Adds a suite of internal classes to the PresentationUI framework to support document management, dependency chaining, and rights management enforcement. This includes the \Document\ base class and its concrete implementations (\PackageDocument\, \RightsDocument\, \FileDocument\) which manage file streams and dependencies. The update introduces \ChainOfDependencies\ and \ChainOfResponsibility\ patterns to handle ordered execution of document controllers. It also adds \CommandEnforcer\ to manage RMPolicy bindings and disable PrintScreen when required, \CriticalFileToken\ for secure file access, and \DocumentProperties\ to wrap the properties dialog. Additionally, utility classes for mailto URIs and application state are added to support these features.

src/Microsoft.DotNet.Wpf/src/PresentationUI/MS/Internal/Documents/Application · high confidence

Adds new internal classes to manage application context switches for WPF components. AppContextDefaultValues handles parsing the Target Framework Name to populate default switch values, while LocalAppContext provides a thread-safe, cached mechanism to query and define these local switch defaults. This infrastructure allows WPF libraries to configure their own compatibility switches independently of the central AppContext, improving performance by avoiding reflection and enabling per-library switch configuration.

src/Microsoft.DotNet.Wpf/src/Common/src/System · high confidence

The DirectWriteForwarder project has been added to the WPF build, introducing a new C++/CLI native library that forwards DirectWrite calls. This change includes the solution file, the C++/CLI project configuration, and the C++ source files that handle module initialization and dependency loading, enabling WPF to utilize DirectWrite for text rendering.

src/Microsoft.DotNet.Wpf/src/DirectWriteForwarder · high confidence

The DirectWrite wrapper in the WPF text rendering stack has been migrated from native C++ to managed C++/CLI. This change introduces a new set of header and source files (including DWriteTypeConverter, Factory, Font, and various DWrite interface wrappers) that bridge the .NET types with the native DirectWrite COM interfaces. The migration includes type converters for font weights, stretches, and simulations, as well as a managed font file loader and factory implementation that caches file timestamps to improve performance. This allows the WPF text subsystem to leverage DirectWrite for improved typography and font handling on Windows.

src/Microsoft.DotNet.Wpf/src/DirectWriteForwarder/CPP/DWriteWrapper · high confidence

Added new types in the System.Windows.Shell namespace to support Windows 7+ shell features. This includes JumpList, JumpItem, JumpPath, and JumpTask for managing the application's Jump List (recent and frequent items). Additionally, TaskbarItemInfo and ThumbButtonInfo provide dependency properties to control the taskbar progress bar, overlay, description, and thumbnail button states, while WindowChrome and WindowChromeWorker enable custom window chrome and hit-testing behavior.

src/Microsoft.DotNet.Wpf/src/PresentationFramework/System/Windows/Shell · high confidence

The PresentationFramework library introduces a new set of classes in the System.Windows.Markup.Localizer namespace to support BAML localization. This includes the BamlLocalizer class for extracting and updating localizable resources, the BamlLocalizationDictionary to manage resource collections, and supporting types like BamlLocalizableResource, BamlLocalizableResourceKey, and BamlLocalizabilityResolver. The API also provides error handling via the BamlLocalizerError enumeration and BamlLocalizerErrorNotifyEventArgs for error notification.

src/Microsoft.DotNet.Wpf/src/PresentationFramework/System/Windows/Markup/Localizer · high confidence

The WPF markup subsystem received a comprehensive overhaul of its BAML (Binary Application Markup Language) handling. New internal classes have been introduced to manage the reading and writing of BAML records, including \BamlRecordReader\ and \BamlRecordWriter\ for stream processing, and \BamlBinaryReader\/\BamlBinaryWriter\ for low-level binary I/O. The update also adds \AttributeData\ and \DefAttributeData\ to cache attribute information for compact syntax properties, and introduces \BamlCollectionHolder\ to manage property collections. Additionally, \BamlMapTable\ and \BamlVersionHeader\ are added to track type and assembly mappings and handle BAML format versioning. These changes provide the foundation for the new BAML parsing and serialization capabilities.

src/Microsoft.DotNet.Wpf/src/PresentationFramework/System/Windows/Markup · high confidence

Added the abstract DataSourceProvider class in the System.Windows.Data namespace, providing a common base for data source providers that execute queries to produce data for Avalon data bindings. This introduces the core abstraction for data providers, including methods for initial loading and refreshing data, along with properties for tracking data changes and errors.

src/Microsoft.DotNet.Wpf/src/WindowsBase/System/Windows/Data · high confidence

The UI Automation API in \System.Windows.Automation\ has been expanded with new types to support additional accessibility features. This includes \ActiveTextPositionChangedEventArgs\ and \HeadingLevel\/\IsDialog\ properties on \AutomationElementIdentifiers\ to expose heading levels and dialog states. New event args (\AsyncContentLoadedEventArgs\, \AutomationPropertyChangedEventArgs\) and event identifiers (\AsyncContentLoadedEvent\, \ActiveTextPositionChangedEvent\) are added to track asynchronous content loading and text position changes. Additionally, \AutomationNotificationKind\ and \AutomationNotificationProcessing\ enums are introduced to control how live region updates and other notifications are presented to the user.

src/Microsoft.DotNet.Wpf/src/UIAutomation/UIAutomationTypes/System · high confidence

The PresentationCore library now includes new types to support XAML parsing and serialization: the IAddChild and IProvidePropertyFallback interfaces for handling child elements and property fallbacks, the XamlCoreSerializerUtil helper class for serialization logic, and the XmlLanguage class with its associated converter to manage RFC 3066 language tags in markup.

src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/Markup · high confidence

Added new types to the Windows Automation API to support enhanced accessibility features. This includes the \AutomationHeadingLevel\ and \AutomationLiveSetting\ enumerations, which allow developers to specify heading levels and live region notification behaviors for assistive technologies. Additionally, the \AutomationProperties\ class now exposes attached properties and helper methods for \HeadingLevel\ and \IsDialog\, enabling UI elements to expose these specific accessibility attributes to UI Automation clients.

src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/Automation · high confidence

Added new classes in the System.Windows.Diagnostics namespace to expose diagnostic information about the WPF runtime. BindingDiagnostics provides a BindingFailed event and a NotifyBindingFailed method to track binding failures, while ResourceDictionaryDiagnostics exposes events for when themed and generic ResourceDictionaries are loaded or unloaded, along with methods to enumerate them. Supporting types include BindingFailedEventArgs, ResourceDictionaryLoadedEventArgs, ResourceDictionaryUnloadedEventArgs, ResourceDictionaryInfo, and StaticResourceResolvedEventArgs to carry the relevant data for these diagnostic events.

src/Microsoft.DotNet.Wpf/src/PresentationFramework/System/Windows/Diagnostics · high confidence

Added new classes to the \Microsoft.Win32\ namespace to support modern Windows file and folder selection. The \OpenFileDialog\ and \SaveFileDialog\ classes provide wrappers around the Windows \IFileOpenDialog\ and \IFileSaveDialog\ interfaces, exposing properties like \Multiselect\, \ForcePreviewPane\, \CreatePrompt\, and \OverwritePrompt\. Additionally, \OpenFolderDialog\ allows users to select directories, and \FileDialogCustomPlaces\ provides static access to common system folders (e.g., Documents, Pictures) for the dialog's favorites pane. These classes inherit from new base classes \CommonDialog\, \CommonItemDialog\, and \FileDialog\ to share common dialog behavior.

src/Microsoft.DotNet.Wpf/src/PresentationFramework/Microsoft · high confidence

The reference assembly for PresentationFramework now exposes the OpenFolderDialog class and the ThemeMode property on Application, enabling developers to build folder-selection dialogs and detect or control the application's theme mode. Additionally, the CommonDialog base class and related file-dialog types (FileDialog, OpenFileDialog, SaveFileDialog) are defined in the reference assembly, providing the public API surface for these UI components.

src/Microsoft.DotNet.Wpf/src/PresentationFramework/ref · high confidence

The WindowsBase library introduces several new internal classes to support XAML markup processing and type conversion. A new \DateTimeConverter2\ class wraps \DateTimeValueSerializer\ to enable string-to-DateTime conversions within the markup context. The \TypeTypeConverter\ is added to handle \System.Type\ conversions via the XAML type resolver. Additionally, \ServiceProviders\ is introduced to manage service lookups and registrations, while \InternalTypeHelper\ provides an abstract base for internal type and property access. The deprecated \IReceiveMarkupExtension\ interface is also included, marked with an obsolete attribute.

src/Microsoft.DotNet.Wpf/src/WindowsBase/System/Windows/Markup · high confidence

A new internal implementation of the stylus and touch input handling has been added to PresentationCore, introducing a modern WM\_POINTER-based stack. This includes new classes such as PointerLogic, PointerStylusDevice, and PointerInteractionEngine, which manage pointer data, interaction contexts, and flick detection. This change provides a new pathway for processing raw stylus and touch input events, enabling more accurate gesture recognition and input handling in WPF applications.

src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/Input/Stylus/Pointer · high confidence

Added new types to support resource handling in WPF applications. This includes the \Span\ and \SpanVector\ structs in \MS.Internal.Generic\ for managing value ranges, the \AssemblyAssociatedContentFileAttribute\ in \System.Windows.Resources\ to associate loose content files at compile time, and the \StreamResourceInfo\ class in \System.Windows.Resources\ to encapsulate stream-based resources with their content types.

src/Microsoft.DotNet.Wpf/src/PresentationCore/MS/internal/Generic, src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/Resources, src/Microsoft.DotNet.Wpf/src/PresentationFramework/System/Windows/Resources · high confidence

The WPF media library now includes a new \DisableDpiAwarenessAttribute\ to allow applications to opt out of DPI awareness for WPF UI elements, and introduces the \TextFormattingMode\ enum with \Ideal\ and \Display\ options to control text rendering metrics. Additionally, the \Matrix\ struct in \System.Windows.Media\ is added, providing methods for matrix multiplication, rotation, and transformation operations.

src/Microsoft.DotNet.Wpf/src/WindowsBase/System/Windows/Media · high confidence

Developers can now subscribe to the new VisualTreeChanged event to receive notifications about visual tree modifications, and use the GetXamlSourceInfo method to retrieve source location details (URI, line number, and position) for objects loaded from XAML or BAML. This enables diagnostic tools to track UI structure changes and identify the origin of UI elements.

src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/Diagnostics · high confidence

The WPF build tasks in PresentationBuildTasks are now open-sourced. This includes the MSBuild tasks responsible for compiling XAML markup (MarkupCompilePass1, MarkupCompilePass2), generating temporary target assemblies, classifying and embedding resources, managing unique identifiers in XAML, and updating application manifests for browser-hosted applications.

src/Microsoft.DotNet.Wpf/src/PresentationBuildTasks/Microsoft · high confidence

The source code for the UI Automation client library (UIAutomationClient) has been added to the project, introducing the core classes for UI Automation, including condition evaluation (AndCondition, Condition), element management (AutomationElement, AutomationElementCollection), event handling (AutomationFocusChangedEventArgs), caching (CacheRequest), and pattern implementations (DockPattern, BasePattern). This provides the foundational API for accessing UI automation elements and properties.

src/Microsoft.DotNet.Wpf/src/UIAutomation/UIAutomationClient/System/Windows/Automation · high confidence

The WPF Media namespace source files, including classes such as AncestorChangedEventArgs, ArcSegment, BezierSegment, BitmapCache, and Brush, have been added to the PresentationCore assembly. This change introduces the core implementation of the System.Windows.Media namespace, providing the foundational types for WPF's 2D and 3D rendering, geometry, and brush systems.

src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/Media · high confidence

The System.Printing component now supports building for the ARM64 architecture and targets .NET 6. This enables WPF applications using printing functionality to run natively on ARM64 devices and benefit from the features and improvements in .NET 6.

src/Microsoft.DotNet.Wpf/src/System.Printing · high confidence

The WPF XAML markup compiler now includes new internal classes to support localization file generation and improved error handling. A new \LocalizationParserHooks\ class intercepts XAML parsing to collect localization comments and attributes, writing them to a \.loc\ file. An \LocalizationDirectivesToLocFile\ enum controls the level of localization data extracted. Additionally, an \AssemblyVersionParseException\ is introduced to properly surface assembly version parsing errors during compilation, and supporting types like \SourceFileInfo\ and \CompilationUnit\ are added to manage file paths and compilation state.

src/Microsoft.DotNet.Wpf/src/PresentationBuildTasks/MS/Internal/MarkupCompiler · high confidence

The WPF build system introduces several new MSBuild targets and configuration files in the WpfArcadeSdk/tools directory to support modern .NET build practices. API compatibility checks against .NET Framework 4.8 and reference assemblies are now handled via ApiCompat.props/targets. Test payload creation and DRT (Debug Runtime Tests) inclusion are managed by new targets like CreateTestPayload.targets and AddDrtsToPayload.targets. Code analysis is configured via CodeAnalysis.props/targets, pulling in StyleCop, Microsoft.CodeAnalysis.NetAnalyzers, and other analyzers. Additionally, scripts for generating trace sources, trace strings, and XML string tables are added to automate code generation tasks.

eng/WpfArcadeSdk/tools · high confidence

The WPF markup compiler tasks now cache build state and local reference information to enable incremental builds. This means that when XAML files are modified, only the affected files are recompiled, significantly reducing build times for large WPF projects. The system tracks changes to source code, content files, and build settings to determine which XAML files need recompilation.

src/Microsoft.DotNet.Wpf/src/PresentationBuildTasks/MS/Internal/Tasks · high confidence

The commanding subsystem for WPF has been introduced into the PresentationCore assembly. This includes the core command classes (ApplicationCommands, ComponentCommands, NavigationCommands, MediaCommands), the CommandManager for routing and event handling, and supporting types like CommandBinding, InputBinding, and related event arguments. This provides the foundational API for handling input gestures and executing commands in WPF applications.

src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/Input/Command · high confidence

The WPF data binding subsystem is introduced with new core classes including Binding, BindingBase, BindingExpression, and BindingExpressionBase, enabling two-way, one-way, and one-time data flows between UI elements and data sources. The BindingGroup class is added to manage collections of bindings and provide cross-binding validation. Additionally, the CollectionView infrastructure is expanded with the introduction of BindingListCollectionView to support ADO DataViews, and helper operations for managing bindings are exposed via the BindingOperations class.

src/Microsoft.DotNet.Wpf/src/PresentationFramework/System/Windows/Data · high confidence

The WPF graphics engine (MIL) source code, including the core API, brush, factory, and light data implementations, has been added to the repository. This includes the project configuration files and C++/C header and source files that define the rendering and graphics primitives used by WPF.

src/Microsoft.DotNet.Wpf/src/WpfGfx/core · high confidence

Added a README.md file to the Shared folder with a note about coordinating changes with the WPF team, and introduced RefAssemblyAttrs.cs which defines build version constants and public key tokens for WPF assemblies such as WindowsBase, PresentationCore, and PresentationFramework.

src/Microsoft.DotNet.Wpf/src/Shared · high confidence

The WindowsBase library now includes its solution file, global using directives, resource string helpers, trace message definitions, and assembly attributes. These changes establish the foundational build structure and metadata for the WindowsBase assembly, including InternalsVisibleTo declarations for related WPF assemblies and type forwarding for XAML and packaging types.

src/Microsoft.DotNet.Wpf/src/WindowsBase · high confidence

The XAML subsystem now includes localized error and status messages for Czech, German, Spanish, and French. This update ensures that runtime exceptions and validation errors in the System.Xaml library are displayed in the user's preferred language, improving the debugging experience for developers working with XAML-based applications in these locales.

src/Microsoft.DotNet.Wpf/src/System.Xaml/Resources/xlf · high confidence

The UIAutomationTypes reference assembly now exposes new automation properties and events, including HeadingLevel, IsDialog, ActiveTextPositionChanged, and AsyncContentLoaded, enabling developers to access these accessibility features in their applications.

src/Microsoft.DotNet.Wpf/src/UIAutomation/UIAutomationTypes/ref · high confidence

A new Visual Studio C++ project file (VCRuntime.vcxproj) has been added to the WPF redist directory. This project configures the build for Debug and Release modes across Win32, x64, and arm64 platforms, and sets up the copying of privatized copies of the Visual C++ runtime (vcruntime and msvcp DLLs) into the output directory for both Debug and Release builds.

src/Microsoft.DotNet.Wpf/redist/VCRuntime · medium confidence

The System.Windows.Primitives library now includes an AssemblyInfo.cs file that configures CLS compliance and grants internal visibility to key WPF and related assemblies (such as PresentationFramework, WindowsBase, and UIAutomationClient). Additionally, NativeMethods.json and NativeMethods.txt have been added to configure CsWin32 for P/Invoke declarations, listing specific Windows API functions and constants (e.g., CoInitialize, DwmIsCompositionEnabled) to support native interop within the primitives layer.

src/Microsoft.DotNet.Wpf/src/System.Windows.Primitives · high confidence

The WPF framework now includes comprehensive localized error messages for the PresentationCore library. This change introduces the English exception string table and resource files (Strings.resx) along with their translations for Czech, German, and Spanish (Strings.cs.xlf, Strings.de.xlf, Strings.es.xlf). These resources provide user-friendly, localized descriptions for various runtime exceptions, such as invalid animation timelines, layout recursion limits, and input handling errors, ensuring that error messages displayed to users are correctly translated into their preferred language.

src/Microsoft.DotNet.Wpf/src/PresentationCore/Resources · high confidence

Added new resource files to the WPF PresentationUI, Ribbon, and WindowsFormsIntegration projects. This includes the English string table and ResX files containing UI strings for the digital signature workflow (e.g., 'Digital Signature', 'Sign XPS Document', and various error messages) as well as localized XLIFF translation files for Czech, German, and Spanish. These resources support the user-facing dialogs and messages related to signing XPS documents and managing rights-based permissions.

src/Microsoft.DotNet.Wpf/src/PresentationUI/Resources, src/Microsoft.DotNet.Wpf/src/System.Windows.Controls.Ribbon/Resources, src/Microsoft.DotNet.Wpf/src/WindowsFormsIntegration/Resources · high confidence

The reference assembly for System.Windows.Controls.Ribbon now includes the full set of AutomationPeer classes for Ribbon components, such as RibbonApplicationMenu, RibbonButton, RibbonCheckBox, RibbonComboBox, RibbonContextMenu, RibbonContextualTabGroup, RibbonControl, RibbonControlGroup, RibbonGallery, RibbonGroup, and RibbonMenuButton. This ensures that assistive technologies and screen readers can properly interpret the structure and state of Ribbon UI elements, improving accessibility for users relying on these tools.

src/Microsoft.DotNet.Wpf/src/System.Windows.Controls.Ribbon/ref · high confidence

Introduced new internal utilities for handling OPC package structures and stream operations. Added ContainerFlags to define options for Avalon application containers, and implemented PackagePartExtensions to ensure streams returned from PackagePart are seekable, addressing behavioral differences in .NET Core 3.0 where non-seekable streams could cause crashes. Included PackagingUtilities for encoding verification and stream read/write argument validation.

src/Microsoft.DotNet.Wpf/src/Shared/MS/Internal/IO/Packaging · high confidence

WPF now uses the shared System.Formats.Nrbf library for handling Nrbf serialization, replacing the previous implementation. This change introduces new extension methods for deserializing common types like PointF, RectangleF, and primitive lists, and delegates core serialization logic to the shared serializer, ensuring consistent behavior across .NET.

src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/Nrbf · medium confidence

The PresentationCore library now explicitly defines default values for a range of AppContext switches, including hardware acceleration for RDP, stylus/touch support, and special character ligatures. These defaults are initialized to false, meaning these features are disabled by default unless explicitly enabled via AppContext configuration.

src/Microsoft.DotNet.Wpf/src/PresentationCore/System · medium confidence

The PresentationFramework library now explicitly defines default values for various WPF AppContext switches, such as enabling the adorner for textbox selection rendering and disabling dynamic resource optimization by default. This ensures consistent behavior across different .NET target versions without requiring manual configuration.

src/Microsoft.DotNet.Wpf/src/PresentationFramework/System · medium confidence

A new build validation step has been added to the WPF packaging process to ensure assembly versions are handled correctly during release and servicing builds. The system now distinguishes between assemblies that must remain at a fixed version (those in lib and ref directories) and those that must be incremented with every release (those in sdk/analyzers). This prevents breaking changes in servicing releases by verifying that specific assemblies do not have their versions revved unexpectedly.

packaging/Microsoft.DotNet.Wpf.GitHub · medium confidence

The UIAutomationClient reference assembly now includes the HeadingLevel and IsDialog automation properties on the AutomationElement class, enabling developers to programmatically access these accessibility attributes for UI elements.

src/Microsoft.DotNet.Wpf/src/UIAutomation/UIAutomationClient/ref · high confidence

The generated C\# files in the PresentationCore media effects namespace have been regenerated, introducing new implementations for classes such as BevelBitmapEffect, BlurEffect, and DropShadowEffect. This update includes updated property accessors and internal methods for these effects, ensuring the generated code aligns with the current code generation templates.

src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/Media/Effects/Generated · high confidence

The PresentationCore library now includes new internal helper classes to manage DPI awareness contexts and scaling more robustly. The \DpiAwarenessContextHelper\ and \DpiAwarenessScope\ classes provide mechanisms to query and temporarily modify the DPI awareness context of the current thread, supporting mixed-hosting scenarios. Additionally, \HwndDpiInfo\ and \WindowDpiScaleHelper\ improve the accuracy of window-specific DPI scale factors by falling back to the nearest monitor's DPI when direct window queries fail. These changes ensure that WPF applications handle high-DPI displays and multi-monitor setups with greater reliability and precision.

src/Microsoft.DotNet.Wpf/src/PresentationCore/MS/internal/DpiUtil · high confidence

The TrueType font subsetting logic in WPF has been updated to improve stability and correctness. The \ComputeSubset\ method now checks for a \Switch.MS.Internal.TtfDelta.DisableDirectWriteForwarderBoundsCheckProtection\ AppContext switch to optionally disable bounds checking, and it explicitly handles the \ERR\_WOULD\_GROW\ error by returning the original font data instead of throwing a \FileFormatException\. Additionally, new header files (\fsassert.h\, \sfntoff.h\) and utility functions (\util2.cpp\) have been added to support the subsetting implementation and registry access.

src/Microsoft.DotNet.Wpf/src/DirectWriteForwarder/CPP/TrueTypeSubsetter · medium confidence

WPF now loads uncommon assemblies (such as System.Drawing, System.Xml, and System.Data) only when they are actually used, which improves startup time and reduces memory pressure. The internal \AssemblyHelper\ class now tracks loaded assemblies and loads extension assemblies on demand. Additionally, the \AvTrace\ logging system has been refactored to use \ReadOnlySpan\<T\>\ and other span-based APIs, which eliminates unnecessary string and array allocations during tracing. These changes optimize the runtime behavior of the WindowsBase library.

src/Microsoft.DotNet.Wpf/src/WindowsBase/MS/Internal · high confidence

Added BuildTasksAppContextSwitches.cs and AppContextDefaultValues.cs to the PresentationBuildTasks project. The new BuildTasksAppContextSwitches class defines the 'Switch.System.Windows.Markup.DoNotUseSha256ForMarkupCompilerChecksumAlgorithm' AppContext switch. The AppContextDefaultValues class configures the default value for this switch based on the target framework: it is set to true for .NET Framework versions up to 4.7.1, and false for .NET Core. This allows the markup compiler to control whether SHA256 is used for checksums, with the default behavior changing depending on the target platform.

src/Microsoft.DotNet.Wpf/src/PresentationBuildTasks/MS/Internal, src/Microsoft.DotNet.Wpf/src/PresentationBuildTasks/System · high confidence

Added localized resource files for the System.Printing and UIAutomationClient components, including the English source strings and translations for Czech, German, Spanish, and French.

src/Microsoft.DotNet.Wpf/src/System.Printing/Resources, src/Microsoft.DotNet.Wpf/src/UIAutomation/UIAutomationClient/Resources · high confidence

The DirectWrite font file and collection loaders have been migrated from C++/CLI to managed C\# classes (DWriteLoader, FontCollectionLoader, etc.). This change replaces the previous native/CLI bridge with a fully managed implementation for loading fonts, which improves maintainability and aligns with the broader effort to reduce native code dependencies in the text subsystem.

src/Microsoft.DotNet.Wpf/src/PresentationCore/MS/internal/Text · high confidence

The DWrite interop layer in PresentationCore has been migrated to managed C\# structs, replacing the previous implementation. This change introduces new internal interop definitions for DirectWrite, including the IDWriteFactory, IDWriteFontCollection, IDWriteFontCollectionLoader, IDWriteFontFace, IDWriteFontFile, IDWriteFontFileLoader, and IDWriteTextAnalyzer interfaces, along with supporting enums like DWRITE\_FONT\_FACE\_TYPE and DWRITE\_FONT\_SIMULATIONS. These structs define the vtable layouts and method signatures for calling into the native DirectWrite library, enabling the .NET WPF stack to interact with system fonts and text rendering services.

src/Microsoft.DotNet.Wpf/src/PresentationCore/MS/internal/Interop/DWrite · high confidence

The cross-compilation infrastructure for Android and Tizen has been significantly updated. For Android, the default NDK version was upgraded from r14 to r21, and the minimum supported API level for arm64 was raised from 21 to 28 to ensure compatibility with modern system libraries like glob. The Android rootfs builder now supports configurable NDK versions and downloads dependencies from Termux repositories. For Tizen, the build scripts and patches were reorganized and updated to support additional architectures including RISC-V, and the toolchain patches were updated to use relative library paths instead of absolute ones. Additionally, legacy Ubuntu and Debian source lists for cross-compilation were removed.

eng/common/cross · high confidence

The UIAutomationClient module has been refactored to improve code quality and maintainability. Internal helper classes such as Accessible, AutomationAttributeInfo, AutomationPatternInfo, and AutomationPropertyInfo have been introduced or updated to manage automation metadata and state. The ClientEventManager and related queueing classes (CalloutQueueItem, ClientSideQueueItem) have been restructured to handle accessibility events and cache responses more robustly. Additionally, the BoundingRectTracker and CacheHelper classes have been added or modified to track window location changes and manage cache responses for UI Automation elements. These changes streamline the client-side processing of UI Automation events and properties.

src/Microsoft.DotNet.Wpf/src/UIAutomation/UIAutomationClient/MS · high confidence

The generated source files in PresentationCore (including ContentElement, UIElement, UIElement3D, TextDecoration, and related types) have been regenerated using MilCodeGen. This update modernizes the codebase by replacing manual null-checks with ArgumentNullException.ThrowIfNull, ensuring consistent argument validation across the generated API surface.

src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/Generated · high confidence

The generated source files in PresentationCore's Media and Media3D Generated directories have been regenerated using the MilCodeGen tool. This update introduces or refreshes the implementation of various media-related types, including enums (AlignmentX, AlignmentY, BitmapScalingMode, BrushMappingMode, CachingHint, ClearTypeHint), classes (ArcSegment, BezierSegment, BitmapCache, BitmapCacheBrush, Brush, CacheMode), and type converters (BrushConverter, CacheModeConverter). These changes update the underlying implementation of WPF's rendering and composition engine, ensuring consistency with the latest code generation templates.

src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/Media/Generated, src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/Media3D/Generated · high confidence

The generated source files in PresentationCore's animation namespace (such as Animatable, BooleanAnimationBase, and ByteAnimation) have been regenerated using the MilCodeGen tool. This update replaces manual null-argument checks with the modern ArgumentNullException.ThrowIfNull helper, standardizing how the framework validates parameters for animation methods like BeginAnimation and ApplyAnimationClock.

src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/Media/Animation/Generated · high confidence

The generated source files for WPF imaging classes (including BitmapImage, ColorConvertedBitmap, CroppedBitmap, FormatConvertedBitmap, and TransformedBitmap) have been regenerated using the MilCodeGen tool. This update applies style cleanups, corrects whitespace in the generated code, and ensures the files contain the proper license headers and accessibility modifiers, reflecting the latest state of the code generator.

src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/Media/Imaging/Generated · medium confidence

The CI build and unit test scripts (CIBuild.cmd and CIUnitTest.cmd) have been moved to the eng/scripts directory. These Windows batch files invoke the common Build.ps1 script to handle the build, test, and CI execution steps.

eng/scripts · medium confidence

The System.Xaml project now includes a Directory.Build.Props file that sets the IsWPF property to true, enabling WPF-specific build behaviors. Global suppressions for code analysis rules (such as naming, performance, and reliability warnings) have been added to GlobalSuppressions.cs, allowing the codebase to maintain compatibility with existing public API contracts and internal implementation details. Additionally, the solution file has been renamed from HelloWorld.sln to System.Xaml.sln, and the project configuration has been updated to support x64 and x86 build platforms, alongside a change in the project GUID to reflect the new name.

src/Microsoft.DotNet.Wpf/src/System.Xaml · high confidence

The C\# and Visual Basic WPF project templates have been updated to support target frameworks from .NET 6.0 through .NET 11.0. The templates now include configuration files (dotnetcli.host.json) and localized string resources for multiple languages, and they conditionally apply modern C\# features like implicit usings and file-scoped namespaces for .NET 6.0 and newer versions.

packaging/Microsoft.Dotnet.Wpf.ProjectTemplates · high confidence

The System.Xaml library has been updated to use modern C\# features, including nullable reference type annotations, ArgumentNullException.ThrowIfNull, and interpolated strings. The codebase also includes various style cleanups, such as using compound assignments, removing delegate allocations, and optimizing parsing and serialization of generic type names to decrease allocations. These changes improve code safety, performance, and maintainability within the XAML parsing and object graph handling components.

src/Microsoft.DotNet.Wpf/src/System.Xaml/System/Xaml · medium confidence

The PresentationFramework library received updated localized string resources. The English source file (ExceptionStringTable.txt and Strings.resx) was refreshed with new and corrected error messages for various WPF components, including DocumentViewer, FlowDocumentScrollReader, and ScrollBar context menus. These changes are propagated to the corresponding XLIFF localization files for Czech, German, Spanish, and other languages, ensuring that user-facing error messages and UI text are up to date across all supported locales.

src/Microsoft.DotNet.Wpf/src/PresentationFramework/Resources · high confidence

The font fallback system in PresentationCore has been updated with new composite font definitions (GlobalMonospace, GlobalSansSerif, GlobalSerif, and GlobalUserInterface) that map a broader range of Unicode character sets to specific fonts. This change, which includes the addition of the 'simsun-extg' font to support additional characters, ensures that text in various languages and scripts renders correctly by selecting the appropriate fallback fonts. Users will see improved text display for diverse scripts, including those previously unsupported or poorly supported.

src/Microsoft.DotNet.Wpf/src/PresentationCore/Fonts · high confidence

The files in the eng/common directory have been updated to match the latest contents from the dotnet/arcade repository. This includes new or updated scripts for .NET SDK installation (dotnet-install, dotnet), NuGet source configuration (SetupNugetSources), internal feed operations, and pipeline logging functions. These changes ensure the repository's build system stays synchronized with the shared .NET build infrastructure.

eng/common · high confidence

PresentationCore now initializes the process DPI awareness and loads the DirectWrite forwarder earlier via a module constructor, ensuring DPI settings are applied before any sensitive operations. The library also includes new build configuration, global using directives for shared clipboard and data format code, and linker trim directives for dependencies like System.Diagnostics.Debug and mscorlib. Additionally, trace message definitions for RoutedEvent and Animation events have been added to support diagnostic tracing.

src/Microsoft.DotNet.Wpf/src/PresentationCore · medium confidence

The TrueType font subsetter in WPF now includes extensive bounds checking and overflow protection for native C++ code. New header files (intsafe\_private\_copy.h) provide safe arithmetic and memory allocation wrappers to prevent integer overflows and memory errors during font processing. The subsetter functions (automap, makeglst, modcmap, modglyf, modsbit, modtable) now use these safe wrappers and explicit checks to ensure that glyph indices, offsets, and array sizes are validated before use, preventing potential crashes or memory corruption when processing malformed or large font files.

src/Microsoft.DotNet.Wpf/src/DirectWriteForwarder/CPP/TrueTypeSubsetter/TtfDelta · high confidence

Add unit tests for System.Xaml and Windows.Markup components; Added DRT test infrastructure and utilities; Added test infrastructure for PresentationCore; Added test infrastructure for WindowsBase unit tests; Added test utilities for binary serialization; Added unit tests for BrushConverter; Added unit tests for Fluent theme resource dictionaries; Added unit tests for PrintStringProperty; Added unit tests for WPF clipboard, data object, and converter classes; Added unit tests for WPF components; Added unit tests for WPF geometry types; Added unit tests for WPF imaging classes; Added unit tests for WPF input converters; Added unit tests for WindowsBase event managers and component model classes.

The WPF project has updated its dependencies from the dotnet/arcade repository. This includes updates to the build infrastructure and tooling, ensuring the project remains compatible with the latest .NET build system components.

(repo-wide) · high confidence

The project's build system dependencies have been updated to the latest builds from the dotnet/winforms, dotnet/arcade, and dotnet/dotnet repositories. This includes syncing with the latest versions of the .NET build infrastructure, ensuring the project uses the most recent tooling and SDK components for compilation and testing.

eng · high confidence

The WPF project templates have been updated to support modern .NET versions (net5.0, net6.0, and netcoreapp3.1), with C\# templates now including implicit usings and nullable reference types by default. The build infrastructure has been reorganized into new packaging projects (e.g., Microsoft.DotNet.Arcade.Wpf.Sdk.ArchNeutral) and cycle-breaker projects to resolve assembly reference cycles. Additionally, the internal tools project (Tools.csproj) was added to manage build-time dependencies like Microsoft.ManifestTool.CrossPlatform and MicroBuild plugins.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 69.

• Architecture 93
• Maturity 69
• Readiness 62
• Security 77

• 300 commits — 276 feature/other, 24 fixes

• (root) — 100 commits
• src/Microsoft.DotNet.Wpf — 67 commits
• eng/Version.Details.props — 50 commits
• eng/common — 50 commits
• eng/Version.Details.xml — 9 commits
• (repo) — 7 commits
• eng/Versions.props — 5 commits
• packaging/Microsoft.Dotnet.Wpf.ProjectTemplates — 3 commits
• .github/CODEOWNERS — 2 commits
• eng/WpfArcadeSdk — 2 commits
• .azuredevops/dependabot.yml — 1 commit
• .github/policies — 1 commit
• Documentation/developer-guide.md — 1 commit
• eng/helixpublish.proj — 1 commit
• eng/pipeline.yml — 1 commit

• fix: Fix .Net 10 SDK build issue when using internal members (#11289)
• fix: Fix ComboBox popup content to allow grouping in Fluent (#10878)
• fix: Fix Fluent in Windows 10 (#11341)
• fix: Fix an InvalidOperationException when WeakEventTable.Purge is called … (#11521)
• fix: Fix crashes in TextBox(es) in Fluent theme (#10841)
• fix: Fix potential issues in WPF Native Code (#11797)
• fix: Fix potential overflow issues in WPF native code (#11642)
• fix: Fix(Fluent): TextBox invalidation style (#10887)
• fix: Fix: Plausible Exception while closing an Application (#10631)
• fix: Fixed AutomationProperties.Name for DatePicker Button (#10949)
• fix: Fixed ComboBox style and template (#10818)
• fix: Fixed DataGrid Column Header issues (#10912)
• fix: Fixed DataGrid column header text color in HC mode (#10956)
• fix: Fixed TabItem MinWidth issue (#10865)
• fix: Fixed ToolTip Fluent Style and Resources (#10863)
• fix: Fixes arrow direction for expander when FlowDirection is set to RightToLeft (#10804)
• fix: Fixes layout issues in RichTextBox style for Fluent theme (#10793)
• fix: Fixes the layout and resource usage for PasswordBox (#10768)
• fix: Replace ArrayList in InputProcessorProfiles with fixed-size array, reduce allocations (#9946)
• fix: Revert "Fix unit tests native dependencies (#10338)" (#10919)
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

dotnet/wpf was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.