<Application x:Class="SizeVisualizer.App"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:sizeVisualizer="clr-namespace:SizeVisualizer"
             xmlns:system="clr-namespace:System;assembly=mscorlib"
             StartupUri="DemoWindow.xaml">
    <Application.Resources>
        <Style TargetType="{x:Type Button}">
            <Setter Property="Width" Value="150"/>
            <Setter Property="Height" Value="32"/>
            <Setter Property="Margin" Value="5" />
        </Style>
        <system:String x:Key="DialogText">
            Здравствуйте!
Помогите пожалуйста разобраться с концепцией. Имею следующую разметку с Frame-ом:
В данный Frame я выгружаю различные представления.
Для себя поставил задачу реализовать всплывающее окно, с затемнением основного окна. И когда начал думать как это сделать, я несколько запутался в каком направлении идти.
        </system:String>
        <sizeVisualizer:MainModel x:Key="MainModel"/>
    </Application.Resources>
</Application>

<Window x:Class="SizeVisualizer.DemoWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:commonControls="clr-namespace:CommonControls;assembly=CommonControls"
        Title="DemoWindow" Height="300" Width="500"
        DataContext="{StaticResource MainModel}">
    <Window.Resources>
        <DataTemplate x:Key="DialogWindowTemplate">
            <Grid>
                <Grid.RowDefinitions>
                    <RowDefinition Height="*"/>
                    <RowDefinition Height="Auto"/>
                </Grid.RowDefinitions>
                <TextBlock Grid.Row="0" 
                           HorizontalAlignment="Center" VerticalAlignment="Center" 
                           TextWrapping="Wrap"
                           Text="{StaticResource DialogText}"/>
                <StackPanel Grid.Row="1"
                            Orientation="Horizontal" >
                    <Button Content="Ok" IsDefault="True"/>
                    <Button Content="Cancel" IsCancel="True"/>
                </StackPanel>
                
            </Grid>
        </DataTemplate>
    </Window.Resources>
    <Grid>
        <commonControls:DialogWindow x:Name="Dialog" Header="Dialog Window"
                                     Content="{Binding Dialog}"
                                     ContentTemplate="{StaticResource DialogWindowTemplate}" Margin="0,-10,0,10">
            <commonControls:DialogWindow.WindowStyle>
                <Style TargetType="{x:Type Window}">
                    <Setter Property="MaxWidth" Value="500"/>
                </Style>
            </commonControls:DialogWindow.WindowStyle>
        </commonControls:DialogWindow>

        <Button VerticalAlignment="Top" HorizontalAlignment="Left"
                Content="Open Dialog"
                Command="{x:Static commonControls:DialogWindow.OpenDialog}"
                CommandTarget="{Binding ElementName=Dialog}"/>
        <TextBox Width="300" VerticalAlignment="Center" HorizontalAlignment="Center"/>
    </Grid>
</Window>

namespace SizeVisualizer
{
    public class MainModel
    {
        public string Value { set; get; }

        public MainModel()
        {
            Value = "Example";
        }

        public DialogModel Dialog { set; get; }
    }

    public class DialogModel
    {
        public string Value { set; get; }
    }
}

using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;

namespace CommonControls
{
    public class DialogWindow : ContentControl
    {

        public static ICommand OpenDialog = new RoutedCommand("OpenDialog", typeof (DialogWindow));

        private Popup a;
        private AdornerContainer _adornerContainer;
        private Visual _rootElement;
        private IAnimatable _border;

        public Style WindowStyle
        {
            get { return (Style)GetValue(WindowStyleProperty); }
            set { SetValue(WindowStyleProperty, value); }
        }
        
        public static readonly DependencyProperty WindowStyleProperty =
            DependencyProperty.Register("WindowStyle", typeof(Style), typeof(DialogWindow), new PropertyMetadata(null));
        
        public bool IsOpen
        {
            get { return (bool)GetValue(IsOpenProperty); }
            set { SetValue(IsOpenProperty, value); }
        }

        // Using a DependencyProperty as the backing store for IsOpen.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty IsOpenProperty =
            DependencyProperty.Register("IsOpen", typeof(bool), typeof(DialogWindow), new FrameworkPropertyMetadata(false, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault , IsOpenChanged));


        private Window _openWindow = null;

        private static void IsOpenChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            var dw = (DialogWindow)d;
            var isOpen = (bool) e.NewValue;
            var oldIsOpen = (bool) e.OldValue;
            if (isOpen && !oldIsOpen)
            {
                var window = Window.GetWindow(dw);
                if (window != null)
                {
                    var dialogWindow = new DlgWindow
                    {
                        Header = dw.Header,
                        MinWidth = 50,
                        MinHeight = 50,
                        Owner = window,
                        AllowsTransparency = true,
                        WindowStyle = System.Windows.WindowStyle.None,
                        ResizeMode = ResizeMode.NoResize,
                        WindowStartupLocation = WindowStartupLocation.CenterOwner,
                        DataContext = dw.DataContext,
                        Style = (Style)dw.GetValue(WindowStyleProperty),
                        Content = dw.Content,
                        ContentTemplate = dw.ContentTemplate,
                        ContentTemplateSelector = dw.ContentTemplateSelector
                    };

                    dialogWindow.AddHandler(CommandManager.CanExecuteEvent, new RoutedEventHandler(dw.OnRoutedEvent));
                    dialogWindow.AddHandler(CommandManager.ExecutedEvent, new RoutedEventHandler(dw.OnRoutedEvent));

                    dw.Blur();
                    dw._openWindow = dialogWindow;
                    dialogWindow.ShowDialog();

                    dialogWindow.RemoveHandler(CommandManager.CanExecuteEvent, new RoutedEventHandler(dw.OnRoutedEvent));
                    dialogWindow.RemoveHandler(CommandManager.ExecutedEvent, new RoutedEventHandler(dw.OnRoutedEvent));

                    dialogWindow.DataContext = null;

                    dw.Dispatcher.BeginInvoke(new Action(() => dw.IsOpen = false),
                        System.Windows.Threading.DispatcherPriority.ApplicationIdle);
                    dw.Clear();
                }
            }
            if (!isOpen && oldIsOpen && dw._openWindow != null)
            {
                dw._openWindow.Close();
            }
        }

        #region Animation
        private void Blur()
        {
            //Находим корневой визуальный объект
            var root = VisualTree.FindVisualRoot(this) as Visual;
            //Если это окно, то оно не может иметь Adorner так как у окна он уже есть, по этому находим ContentPresenter этого окна
            if (root is Window) root = VisualTree.FindChild<ContentPresenter>(root);
            if (root == null) return;
            _rootElement = root;
            //Получаем Adorner
            var adornerLayer = AdornerLayer.GetAdornerLayer(root);
            //Если адорнер всё равно не найден, просто не затемняем
            if (adornerLayer == null) return;
            //Создаем контейнер
            if (_adornerContainer == null)
            {
                _border = new Border
                {
                    Background = new SolidColorBrush(Colors.Black),
                    Opacity = 0.0
                };
                _adornerContainer = new AdornerContainer((UIElement)root) { Child = (UIElement)_border };
            }
            adornerLayer.Add(_adornerContainer);

            var animation = new DoubleAnimation
            {
                To = 0.5,
                Duration = TimeSpan.FromSeconds(0.3)
            };
            _border.BeginAnimation(OpacityProperty, animation);
        }


        private void Clear()
        {
            var animation = new DoubleAnimation
            {
                To = 0.0,
                Duration = TimeSpan.FromSeconds(0.3)
            };
            //По завершению анимации удаляем Adorner и удаляем все 
            animation.Completed += animation_Completed;
            _border.BeginAnimation(OpacityProperty, animation);
        }

        void animation_Completed(object sender, EventArgs e)
        {
            if (_rootElement != null)
            {
                var adornerLayer = AdornerLayer.GetAdornerLayer(_rootElement);
                if (_adornerContainer != null)
                {
                    adornerLayer.Remove(_adornerContainer);
                    _adornerContainer = null;
                    _border = null;
                }
                _rootElement = null;
            }
        }
        #endregion

        public object Header
        {
            get { return (object)GetValue(HeaderProperty); }
            set { SetValue(HeaderProperty, value); }
        }

        public static readonly DependencyProperty HeaderProperty =
            DependencyProperty.Register("Header", typeof(object), typeof(DialogWindow), new PropertyMetadata(null));

        static DialogWindow()
        {
            DefaultStyleKeyProperty.OverrideMetadata(typeof(DialogWindow), new FrameworkPropertyMetadata(typeof(DialogWindow)));
            FocusableProperty.OverrideMetadata(typeof(DialogWindow), new FrameworkPropertyMetadata(false));
        }

        public DialogWindow()
        {
            CommandBindings.Add(new CommandBinding(OpenDialog, OnOpenDialog));
        }

        private void OnOpenDialog(object sender, ExecutedRoutedEventArgs e)
        {
            IsOpen = true;
        }

        private void OnRoutedEvent(object sender, RoutedEventArgs e)
        {
            if (!e.Handled) RaiseEvent(e);
        }

    }
}

using System.Collections.Generic;
using System.Windows;
using System.Windows.Input;

namespace CommonControls
{
    public class DlgWindow : Window
    {


        public object Header
        {
            get { return (object)GetValue(HeaderProperty); }
            set { SetValue(HeaderProperty, value); }
        }
        public static readonly DependencyProperty HeaderProperty =
            DependencyProperty.Register("Header", typeof(object), typeof(DlgWindow), new PropertyMetadata(null));


        protected override void OnMouseLeftButtonDown(MouseButtonEventArgs e)
        {
            base.OnMouseLeftButtonDown(e);
            DragMove();
        }

        static DlgWindow()
        {
            DefaultStyleKeyProperty.OverrideMetadata(typeof(DlgWindow), new FrameworkPropertyMetadata(typeof(DlgWindow)));
        }
        
        public IEnumerable<ICommand> Commands
        {
            get { return (IEnumerable<ICommand>)GetValue(CommandsProperty); }
            set { SetValue(CommandsProperty, value); }
        }

        public static readonly DependencyProperty CommandsProperty =
            DependencyProperty.Register("Commands", typeof(IEnumerable<ICommand>), typeof(DlgWindow), new PropertyMetadata(null));

        
    }
}