In WPF-UI version 4.0.3, it is no longer possible to override global control styles (e.g., TextBlock.FontSize) from App.xaml using implicit styles

[rwnsgud]

Describe the bug

First of all, thank you for your continued work on WPF-UI — it's a fantastic library that has greatly improved the developer experience in our WPF projects.

In WPF-UI version 4.0.3, setting a global implicit style for ui:TextBlock in App.xaml does not override the default FontSize applied by the library. Even after explicitly defining a style like this:

<Style TargetType="ui:TextBlock">
    <Setter Property="FontSize" Value="40" />
</Style>

the actual FontSize of ui:TextBlock elements remains 14, as confirmed in the Properties window at runtime.
This behavior differs from WPF-UI 3.x and even 4.0.0, where such global styles were correctly applied.

To Reproduce

For example, in App.xaml:
Add an implicit style for ui:TextBlock with FontSize = 40 in App.xaml.

    <Application.Resources>
        <ResourceDictionary>
            <ResourceDictionary.MergedDictionaries>
                <!--<ResourceDictionary
                    Source="pack://application:,,,/Wpf.Ui;component/Resources/Wpf.Ui.xaml" />-->

                <ResourceDictionary
                    Source="pack://application:,,,/Wpf.Ui;component/Controls/TextBlock/TextBlock.xaml" />
                <ResourceDictionary
                    Source="pack://application:,,,/Wpf.Ui;component/Controls/TextBox/TextBox.xaml" />

                <ui:ControlsDictionary />
            </ResourceDictionary.MergedDictionaries>

            <Style
                TargetType="ui:TextBlock">
                <Setter Property="FontSize" Value="40" />
            </Style>

            <Style
                TargetType="TextBlock">
                <Setter Property="FontSize" Value="40" />
            </Style>
        </ResourceDictionary>
    </Application.Resources>

in MainWindow.xaml:

    <StackPanel
        HorizontalAlignment="Center"
        VerticalAlignment="Center"
        Orientation="Horizontal">

        <StackPanel
            Margin="8">
            <ui:TextBlock
                Text="ui:TextBlock A" />
            <ui:TextBlock
                FontSize="30"
                Text="ui:TextBlock B" />
        </StackPanel>

        <StackPanel
            Margin="8">
            <TextBlock
                Text="TextBlock A" />
            <TextBlock
                FontSize="30"
                Text="TextBlock B" />
        </StackPanel>
    </StackPanel>

Expected behavior

The FontSize of ui:TextBlock should reflect the value defined in App.xaml — in this case, 40 — and should be visible as such in the property panel at runtime.

Screenshots

OS version

Windows 11

.NET version

net9.0

WPF-UI NuGet version

4.0.3

Additional context

No response

[EllisWong]

Same issue after updated to v4.0.3 from v4.0.0-rc2. The custom global style can not be applied to ui:textblock.

[giiyms]

The 4.0.2 update causes the issues. There is a change to the TextBlock to do with the FontTypography. Could this be the cause?

6 changes: 6 additions & 0 deletions6  
[src/Wpf.Ui/Controls/TextBlock/TextBlock.cs](https://github.com/lepoco/wpfui/compare/4.0.0...4.0.2#diff-e8bf22faea2f4a0662979532cc871ecd66222aace2d8ecf61b371ddffa520be5)
Copied!
Original file line number	Diff line number	Diff line change
@@ -39,6 +39,12 @@ public class TextBlock : System.Windows.Controls.TextBlock
        )
    );

    public TextBlock()
    {
        var defaultFontTypography = (FontTypography)FontTypographyProperty.DefaultMetadata.DefaultValue;
        SetResourceReference(StyleProperty, defaultFontTypography.ToResourceValue());
    }

    /// <summary>
    /// Gets or sets the <see cref="FontTypography"/> of the text.
    /// </summary>

And its not just the font it affects, it seems to have broken the margin and padding somehow for me.

[giiyms]

Gemini analysis:

The bug is caused by a code change in the TextBlock's constructor that programmatically sets a style. This local style takes precedence over the implicit style you defined in App.xaml, preventing your global FontSize from being applied.

---

Why the Bug Happens 🐛

The user giiyms correctly identified the problematic code introduced in version 4.0.2:

// src/Wpf.Ui/Controls/TextBlock/TextBlock.cs

public TextBlock()
{
    var defaultFontTypography = (FontTypography)FontTypographyProperty.DefaultMetadata.DefaultValue;
    SetResourceReference(StyleProperty, defaultFontTypography.ToResourceValue());
}

This code runs every time a ui:TextBlock control is created. The line SetResourceReference(StyleProperty, ...) directly sets the Style property on the control instance.

In the WPF dependency property system, property values are resolved based on a strict order of precedence. A value set directly on an object (a local value) has higher precedence than an implicit style defined in a resource dictionary.

1. Before v4.0.2: The constructor was empty. When a ui:TextBlock was created, WPF would look for a style. It would find your implicit style in App.xaml and apply it.
2. After v4.0.2: The constructor now sets the Style property locally. Because this local value has higher precedence, WPF applies this style (the library's default Body typography style, which has FontSize="14") and stops looking for any other styles, completely ignoring your global style in App.xaml.

This is also why other properties like Margin and Padding were affected for user giiyms—the entire default library style was being forced onto the control, overwriting any global setters.

---

How to Fix It ✅

The correct way to assign a default style to a custom control is not by setting it in the constructor, but by overriding the control's default style key. This tells WPF what style to use by default, but allows developers to easily override it with implicit or explicit styles.

The fix involves removing the code from the instance constructor and adding a static constructor to override the DefaultStyleKeyProperty.

1. Remove the code from the TextBlock() instance constructor:

   // REMOVE these lines from the instance constructor
   public TextBlock()
   {
       // var defaultFontTypography = (FontTypography)FontTypographyProperty.DefaultMetadata.DefaultValue;
       // SetResourceReference(StyleProperty, defaultFontTypography.ToResourceValue());
   }

2. Add a static constructor to override the default style key:

   // ADD this static constructor to the TextBlock class
   static TextBlock()
   {
       DefaultStyleKeyProperty.OverrideMetadata(
           typeof(TextBlock),
           new FrameworkPropertyMetadata(typeof(TextBlock))
       );
   }

This change restores the expected WPF behavior. The DefaultStyleKeyProperty tells the framework to apply the library's base style, but this default has a lower precedence than your implicit App.xaml style. The framework will now correctly find and apply your global style first.

@rwnsgud if you have a good test case setup, do you have time to do this modification and see if it fixes the bug?

[rwnsgud]

Thank you @giiyms for your suggestion!

I cloned the latest Wpf.Ui GitHub repository and modified the TextBlock control as you suggested by moving the DefaultStyleKeyProperty.OverrideMetadata call to a static constructor. However, a runtime error occurred stating that "PropertyMetadata is already registered for type 'TextBlock'."

ChatGPT analysis:

The reason for this error is that the OverrideMetadata method can only be called once for a specific dependency property and target type. In this case, the base TextBlock type has already registered metadata for the DefaultStyleKeyProperty. Attempting to override it again, even in a static constructor, results in an InvalidOperationException. To avoid this, a new custom class that inherits from TextBlock should be created, and metadata should be overridden on that new type instead of the base TextBlock type.