property value inheritance for owned windows

[trebahl]

I would have expected inheritable properties set on a window to be inherited by its owned windows, but it seems that isn't the case.
I guess I could define explicitly a binding for every property I'm interested in (mostly FontSize TBH), but I was wondering if there was a more direct solution.

[DisillusionedDeveloper]

Hi trebahl,

unfortunately the most straight forward solution by adding an implicit Style with TargetType Window to the Resources Tag in App.xaml like this

<Application.Resources>
    <Style TargetType="Window" BasedOn="{StaticResource {x:Type Window}}">
        <Setter Property="FontSize" Value="32" />
        <Setter Property="WhichEverPropertyShouldBeSetOnAllWindows" Value="Something" />
    </Style>
</Application.Resources>

does not get applied at runtime (no idea if this was done on purpose by the WPF team), though it interestingly seems to get recognized by Visual Studio's Designer.
Here are two workarounds that are hopefully of use.

- The explicit one

1. Add a keyed Style to the App.xaml Resource Tag like this

<Application.Resources>
    <Style x:Key="MyBaseWindowStyle" TargetType="Window" BasedOn="{StaticResource {x:Type Window}}">
        <Setter Property="FontSize" Value="32" />
        <Setter Property="WhichEverPropertyShouldBeSetOnAllWindows" Value="Something" />
    </Style>
</Application.Resources>

2. Add this Style explicitly to every Window you use e.g. like this (see the last line):

<Window x:Class="MyAwesomeWpfApp.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"       
        mc:Ignorable="d"               
        Title="MainWindow" Height="450" Width="800"
        Style="{StaticResource MyBaseWindowStyle}">

All your property setters meant for all Windows are in 1 place (App.xaml) and it just needs 1 line per Window to apply them.

- The more implicit one

1. Create a custom control named whatever you like (I named it 'BaseWindow' here) that is derived from the standard WPF Window class. Its BaseWindow.cs file content looks like this:

using System.Windows;

namespace MyAwesomeWpfApp;

public class BaseWindow : Window
{
    static BaseWindow()
    {
        // This line is important for the style lookup logic
        DefaultStyleKeyProperty.OverrideMetadata(typeof(BaseWindow), new FrameworkPropertyMetadata(typeof(BaseWindow)));
    }
}

2. Create a folder named 'Themes' on the topmost folder level of your project and within it a file named 'Generic.xaml' (well if doing step 1 hasn't already done this automatically). Its content looking like this:

<ResourceDictionary
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="clr-namespace:MyAwesomeWpfApp">
    <Style TargetType="{x:Type local:BaseWindow}" BasedOn="{StaticResource {x:Type Window}}">
        <Setter Property="FontSize" Value="32" />
        <Setter Property="WhichEverPropertyShouldBeSetOnAllWindows" Value="Something" />
    </Style>
</ResourceDictionary>

In this solution you don't need a keyed style. An implicit one with TargetType being your custom BaseWindow is enough.

3. Now derive all your Window classes from the BaseWindow class created in step 1 instead of the default WPF own Window class. Let's say you have a Window class called 'MainWindow', then its xaml (well the top part) would look like something like this:

<local:BaseWindow x:Class="MyAwesomeWpfApp.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:MyAwesomeWpfApp"
        mc:Ignorable="d"       
        Title="MainWindow" Height="450" Width="800">

Its code behind class looking something like this:

namespace MyAwesomeWpfApp;

public partial class MainWindow : BaseWindow
{
    public MainWindow()
    {
        InitializeComponent();
    }   
}

WPF will look up the style for your custom Window class BaseWindow in the Generic.xaml file and automatically apply it to all instances of BaseWindow without the need to set the Style explicitly like in the first workaround. Another advantage of this solution is that it gives you even more flexibility by enabling you to customize your BaseWindow even more since it is a full blown custom control.

I hope some parts are applicable to your project and code structure.

Best wishes from Germany

[trebahl]

Thanks, but I want to avoid static variables as much as I can, so using the Application class is a no go for me. Also I would like to change the values dynamically; I guess it might be possible to search for the styles in the global resource dicitionaries and modify them, but it would be very convoluted compared to just setting a new value on the parent window.

I guess I'll just explictly bind properties from parent windows to child window.

There has to be another way though: in avalon dock, the autohide panels are placed in separate windows, that do receive the fontsize of the main window. But I failed to understand how they do it.

[DisillusionedDeveloper]

Hi trebahl,

if you want to inherit specific dependencyproperties explicitly from the Owner Window without

• using App.xaml
• using a custom Window class
• searching through resource dictionaries

maybe this solution might be of use. Here's a simple boolean attached dependencyproperty where you can easily add the dependency properties you want to inherit once within this class and then simply set the attached dependencyproperty to true on the child windows which are supposed to inherit from their owner. This is done by adding real bindings in code behind so the child windows would actually listen dynamically to changes done to the owner's properties at runtime.

Here is the attached dependencyproperty class:

public static class WindowExtensions
{
    public static readonly DependencyProperty InheritFromOwnerWindowProperty =
        DependencyProperty.RegisterAttached(
            "InheritFromOwnerWindow",
            typeof(bool),
            typeof(WindowExtensions),
            new FrameworkPropertyMetadata(false, OnInheritFromOwnerWindowChanged));

    public static bool GetInheritFromOwnerWindow(DependencyObject obj)
        => (bool)obj.GetValue(InheritFromOwnerWindowProperty);

    public static void SetInheritFromOwnerWindow(DependencyObject obj, bool value)
        => obj.SetValue(InheritFromOwnerWindowProperty, value);

    // Add here all the DependencyProperties you want to inherit from the owner window
    // I added FontSize and FontFamily for a start
    private static List<(DependencyProperty Dp, string Path)> s_InheritedProperties =
        [
            (Window.FontSizeProperty,   nameof(Window.FontSize)),
            (Window.FontFamilyProperty, nameof(Window.FontFamily))
        ];

    private static void OnInheritFromOwnerWindowChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        if (d is Window window && e.NewValue is bool inherit && inherit)
        {
            // Wait for loaded event to make sure the owner window is set and available
            window.Loaded += OnWindowLoaded;
            window.Unloaded += OnWindowUnloaded;
        }
    }

    private static void OnWindowLoaded(object sender, RoutedEventArgs e)
    {
        if (sender is Window window && window.Owner != null)
        {
            s_InheritedProperties.ForEach(x =>
            {
                if (BindingOperations.GetBinding(window, x.Dp) == null)
                    window.SetBinding(x.Dp, new Binding(x.Path) { Source = window.Owner, Mode = BindingMode.OneWay });
            });

            window.Loaded -= OnWindowLoaded; // Remove the event handler after applying the bindings
        }
    }

    private static void OnWindowUnloaded(object sender, RoutedEventArgs e)
    {
        if (sender is Window window)
        {
            s_InheritedProperties.ForEach(x => BindingOperations.ClearBinding(window, x.Dp));
            window.Unloaded -= OnWindowUnloaded; // Remove the event handler after clearing the bindings
        }
    }
}

Here is the xaml of a child window. All it needs is the oneliner setting the attached dependencyproperty to true:

<Window x:Class="MyAwesomeWpfApp.ChildWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:MyAwesomeWpfApp"
        mc:Ignorable="d"
        Title="Lorem Ipsum" Height="450" Width="800"
        local:WindowExtensions.InheritFromOwnerWindow="True">
    <Grid>
        <TextBlock HorizontalAlignment="Center" VerticalAlignment="Center">I am a Child Window. Watch my FontSize and FontFamily being bound to my Owner window's values</TextBlock>
    </Grid>
</Window>

This is the most "WPF-ish" way I could come up with.

Best wishes from Germany where we were just eliminated from the soccer world cup way too early so I decided to fumble around with some code to get a little distraction from this disaster ;)