XAML scrub (#6446)

* xaml

* More

* Update link to Common theme resources Xaml file

---------

Co-authored-by: Jim Walker <[email protected]>

Author: niels9001

hub/apps/develop/platform/xaml/attached-properties-overview.md

@@ -117,7 +117,7 @@ The dot in an attached property name is a key part of the identification pattern
 - To specify an attached property as part of a target path for an animation, enclose the attached property name in parentheses `()`—for example, `(Canvas.Left)`. For more info, see [Property-path syntax](property-path-syntax.md).
 
 > [!WARNING]
-> An existing limitation of the Windows Runtime XAML implementation is that you cannot animate a custom attached property.
+> An existing limitation of the WinUI implementation is that you cannot animate a custom attached property.
 
 - To specify an attached property as the target property for a resource reference from a resource file to **x:Uid**, use a special syntax that injects a code-style, fully qualified **using:** declaration inside square brackets ("\[\]"), to create a deliberate scope break. For example, assuming there exists an element `<TextBlock x:Uid="Title" />`, the resource key in the resource file that targets the **Canvas.Top** value on that instance is `Title.\[using:Microsoft.UI.Xaml.Controls\]Canvas.Top`. For more info on resource files and XAML, see [Localize strings in your UI](../../../windows-app-sdk/mrtcore/localize-strings.md).
 

hub/apps/develop/platform/xaml/custom-attached-properties.md

@@ -20,14 +20,14 @@ An _attached property_ is a XAML concept. Attached properties are typically defi
 
 ## Prerequisites
 
-We assume that you understand dependency properties from the perspective of a consumer of existing dependency properties, and that you have read the [Dependency properties overview](dependency-properties-overview.md). You should also have read [Attached properties overview](attached-properties-overview.md). To follow the examples in this topic, you should also understand XAML and know how to write a basic Windows Runtime app using C++, C#, or Visual Basic.
+We assume that you understand dependency properties from the perspective of a consumer of existing dependency properties, and that you have read the [Dependency properties overview](dependency-properties-overview.md). You should also have read [Attached properties overview](attached-properties-overview.md). To follow the examples in this topic, you should also understand XAML and know how to write a basic WinUI app using C++ or C#.
 
 ## Scenarios for attached properties
 
 You might create an attached property when there is a reason to have a property-setting mechanism available for classes other than the defining class. The most common scenarios for this are layout and services support. Examples of existing layout properties are [**Canvas.ZIndex**](/windows/windows-app-sdk/api/winrt/microsoft.ui.xaml.controls.canvas.zindex) and [**Canvas.Top**](/windows/windows-app-sdk/api/winrt/microsoft.ui.xaml.controls.canvas.top). In a layout scenario, elements that exist as child elements to layout-controlling elements can express layout requirements to their parent elements individually, each setting a property value that the parent defines as an attached property. An example of the services-support scenario in the Windows Runtime API is set of the attached properties of [**ScrollViewer**](/windows/windows-app-sdk/api/winrt/microsoft.ui.xaml.Controls.ScrollViewer), such as [**ScrollViewer.IsZoomChainingEnabled**](/windows/windows-app-sdk/api/winrt/microsoft.ui.xaml.controls.scrollviewer.iszoomchainingenabled).
 
 > [!WARNING]
-> An existing limitation of the Windows Runtime XAML implementation is that you cannot animate your custom attached property.
+> An existing limitation of the WinUI app implementation is that you cannot animate your custom attached property.
 
 ## Registering a custom attached property
 

hub/apps/develop/platform/xaml/custom-dependency-properties.md

@@ -1,10 +1,10 @@
 ---
-description: Explains how to define and implement custom dependency properties for a Windows Runtime app using C++, C#, or Visual Basic.
+description: Explains how to define and implement custom dependency properties for a WinUI app using C++, C#, or Visual Basic.
 title: Custom dependency properties
 ms.assetid: 5ADF7935-F2CF-4BB6-B1A5-F535C2ED8EF8
 ms.date: 09/08/2025
 ms.topic: article
-keywords: windows 10, uwp
+keywords: windows 10, winui
 ms.localizationpriority: medium
 dev_langs:
   - csharp
@@ -14,11 +14,11 @@ dev_langs:
 ---
 # Custom dependency properties
 
-Here we explain how to define and implement your own dependency properties for a Windows Runtime app using C++, C#, or Visual Basic. We list reasons why app developers and component authors might want to create custom dependency properties. We describe the implementation steps for a custom dependency property, as well as some best practices that can improve performance, usability, or versatility of the dependency property.
+Here we explain how to define and implement your own dependency properties for a WinUI app using C++, C#, or Visual Basic. We list reasons why app developers and component authors might want to create custom dependency properties. We describe the implementation steps for a custom dependency property, as well as some best practices that can improve performance, usability, or versatility of the dependency property.
 
 ## Prerequisites
 
-We assume that you have read the [Dependency properties overview](dependency-properties-overview.md) and that you understand dependency properties from the perspective of a consumer of existing dependency properties. To follow the examples in this topic, you should also understand XAML and know how to write a basic Windows Runtime app using C++, C#, or Visual Basic.
+We assume that you have read the [Dependency properties overview](dependency-properties-overview.md) and that you understand dependency properties from the perspective of a consumer of existing dependency properties. To follow the examples in this topic, you should also understand XAML and know how to write a basic WinUI app using C++ or C#.
 
 ## What is a dependency property?
 
@@ -38,7 +38,7 @@ If you implement a custom dependency property yourself and want it to be public
 
 Whenever you implement a public read/write property on a class, as long as your class derives from [**DependencyObject**](/windows/windows-app-sdk/api/winrt/microsoft.ui.xaml.DependencyObject), you have the option to make your property work as a dependency property. Sometimes the typical technique of backing your property with a private field is adequate. Defining your custom property as a dependency property is not always necessary or appropriate. The choice will depend on the scenarios that you intend your property to support.
 
-You might consider implementing your property as a dependency property when you want it to support one or more of these features of the Windows Runtime or of Windows Runtime apps:
+You might consider implementing your property as a dependency property when you want it to support one or more of these features of the Windows Runtime or of WinUI apps:
 
 - Setting the property through a [**Style**](/windows/windows-app-sdk/api/winrt/microsoft.ui.xaml.Style)
 - Acting as valid target property for data binding with [**{Binding}**](binding-markup-extension.md)
@@ -431,7 +431,7 @@ Keep the following considerations in mind as best practices when as you define y
 
 ### DependencyObject and threading
 
-All [**DependencyObject**](/windows/windows-app-sdk/api/winrt/microsoft.ui.xaml.DependencyObject) instances must be created on the UI thread which is associated with the current [**Window**](/windows/windows-app-sdk/api/winrt/microsoft.ui.xaml.Window) that is shown by a Windows Runtime app. Although each **DependencyObject** must be created on the main UI thread, the objects can be accessed using a dispatcher reference from other threads, by calling [**Dispatcher**](/windows/windows-app-sdk/api/winrt/microsoft.ui.xaml.dependencyobject.dispatcher).
+All [**DependencyObject**](/windows/windows-app-sdk/api/winrt/microsoft.ui.xaml.DependencyObject) instances must be created on the UI thread which is associated with the current [**Window**](/windows/windows-app-sdk/api/winrt/microsoft.ui.xaml.Window) that is shown by a WinUI app. Although each **DependencyObject** must be created on the main UI thread, the objects can be accessed using a dispatcher reference from other threads, by calling [**Dispatcher**](/windows/windows-app-sdk/api/winrt/microsoft.ui.xaml.dependencyobject.dispatcher).
 
 The threading aspects of [**DependencyObject**](/windows/windows-app-sdk/api/winrt/microsoft.ui.xaml.DependencyObject) are relevant because it generally means that only code that runs on the UI thread can change or even read the value of a dependency property. Threading issues can usually be avoided in typical UI code that makes correct use of **async** patterns and background worker threads. You typically only run into **DependencyObject**-related threading issues if you are defining your own **DependencyObject** types and you attempt to use them for data sources or other scenarios where a **DependencyObject** isn't necessarily appropriate.
 

hub/apps/develop/platform/xaml/dependency-properties-overview.md

@@ -1,5 +1,5 @@
 ---
-description: This topic explains the dependency property system that is available when you write a Windows Runtime app using C++, C#, or Visual Basic along with XAML definitions for UI.
+description: This topic explains the dependency property system that is available when you write a WinUI app using C++, C#, or Visual Basic along with XAML definitions for UI.
 title: Dependency properties overview
 ms.assetid: AD649E66-F71C-4DAA-9994-617C886FDA7E
 ms.date: 02/08/2017
@@ -9,13 +9,13 @@ ms.localizationpriority: medium
 ---
 # Dependency properties overview
 
-This topic explains the dependency property system that is available when you write a Windows Runtime app with XAML definitions for UI.
+This topic explains the dependency property system that is available when you write a WinUI app with XAML definitions for UI.
 
 ## What is a dependency property?
 
-A dependency property is a specialized type of property. Specifically it's a property where the property's value is tracked and influenced by a dedicated property system that is part of the Windows Runtime.
+A dependency property is a specialized type of property. Specifically it's a property where the property's value is tracked and influenced by a dedicated property system that is part of the WinUI.
 
-In order to support a dependency property, the object that defines the property must be a [**DependencyObject**](/windows/windows-app-sdk/api/winrt/microsoft.ui.xaml.dependencyobject) (in other words a class that has the **DependencyObject** base class somewhere in its inheritance). Many of the types you use for your UI definitions for a UWP app with XAML will be a **DependencyObject** subclass, and will support dependency properties. However, any type that comes from a Windows Runtime namespace that doesn't have "XAML" in its name won't support dependency properties; properties of such types are ordinary properties that won't have the property system's dependency behavior.
+In order to support a dependency property, the object that defines the property must be a [**DependencyObject**](/windows/windows-app-sdk/api/winrt/microsoft.ui.xaml.dependencyobject) (in other words a class that has the **DependencyObject** base class somewhere in its inheritance). Many of the types you use for your UI definitions for a WinUI app with XAML will be a **DependencyObject** subclass, and will support dependency properties. However, any type that comes from a Windows Runtime namespace that doesn't have "XAML" in its name won't support dependency properties; properties of such types are ordinary properties that won't have the property system's dependency behavior.
 
 The purpose of dependency properties is to provide a systemic way to compute the value of a property based on other inputs (other properties, events and states that occur within your app while it runs). These other inputs might include:
 
@@ -24,7 +24,7 @@ The purpose of dependency properties is to provide a systemic way to compute the
 - Multiple-use templating patterns such as resources and styles
 - Values known through parent-child relationships with other elements in the object tree
 
-A dependency property represents or supports a specific feature of the programming model for defining a Windows Runtime app with XAML for UI. These features include:
+A dependency property represents or supports a specific feature of the programming model for defining a WinUI app with XAML for UI. These features include:
 
 - Data binding
 - Styles
@@ -88,7 +88,7 @@ The following is the definitive order that the property system uses when assigni
 
 ### Templated properties
 
-Templated properties as a precedence item do not apply to any property of an element that you declare directly in XAML page markup. The templated property concept exists only for objects that are created when the Windows Runtime applies a XAML template to a UI element and thus defines its visuals.
+Templated properties as a precedence item do not apply to any property of an element that you declare directly in XAML page markup. The templated property concept exists only for objects that are created when the WinUI applies a XAML template to a UI element and thus defines its visuals.
 
 All the properties that are set from a control template have values of some kind. These values are almost like an extended set of default values for the control and are often associated with values you can reset later by setting the property values directly. Thus the template-set values must be distinguishable from a true local value, so that any new local value can overwrite it.
 
@@ -188,7 +188,7 @@ You can deliberately set a property to the default value even after you have alr
 
 ## **DependencyObject** and threading
 
-All [**DependencyObject**](/windows/windows-app-sdk/api/winrt/microsoft.ui.xaml.dependencyobject) instances must be created on the UI thread which is associated with the current [**Window**](/windows/windows-app-sdk/api/winrt/microsoft.ui.xaml.Window) that is shown by a Windows Runtime app. Although each **DependencyObject** must be created on the main UI thread, the objects can be accessed using a dispatcher reference from other threads, by accessing the [**DispatcherQueue**](/windows/windows-app-sdk/api/winrt/microsoft.ui.xaml.dependencyobject.dispatcherqueue) property. Then you can call methods such as [**TryEnqueue**](/windows/windows-app-sdk/api/winrt/microsoft.ui.dispatching.dispatcherqueue.tryenqueue) and execute your code within the rules of thread restrictions on the UI thread.
+All [**DependencyObject**](/windows/windows-app-sdk/api/winrt/microsoft.ui.xaml.dependencyobject) instances must be created on the UI thread which is associated with the current [**Window**](/windows/windows-app-sdk/api/winrt/microsoft.ui.xaml.Window) that is shown by a WinUI app. Although each **DependencyObject** must be created on the main UI thread, the objects can be accessed using a dispatcher reference from other threads, by accessing the [**DispatcherQueue**](/windows/windows-app-sdk/api/winrt/microsoft.ui.xaml.dependencyobject.dispatcherqueue) property. Then you can call methods such as [**TryEnqueue**](/windows/windows-app-sdk/api/winrt/microsoft.ui.dispatching.dispatcherqueue.tryenqueue) and execute your code within the rules of thread restrictions on the UI thread.
 
 > [!NOTE]
 > For UWP apps, access the [**Dispatcher**](/uwp/api/windows.ui.xaml.dependencyobject.dispatcher) property. Then you can call methods such as [**RunAsync**](/uwp/api/windows.ui.core.coredispatcher.runasync) on the [**CoreDispatcher**](/uwp/api/Windows.UI.Core.CoreDispatcher) object, and execute your code within the rules of thread restrictions on the UI thread. For more info about differences between UWP and WinUI 3 for the Windows App SDK, see [Threading functionality migration](../../../windows-app-sdk/migrate-to-windows-app-sdk/guides/threading.md).