Why doesn't the Visual Studio 2022 designer show changes?

Question

Why doesn't the Visual Studio 2022 designer show changes?

Oscallo 0

I created a Custom Control from Window. Added a dependency property to it.

public static readonly DependencyProperty IsHideableProperty = DependencyProperty.Register(nameof(IsHideable), typeof(bool), typeof(ExtendedWindow),
new FrameworkPropertyMetadata(BooleanBoxes.TrueBox,new PropertyChangedCallback(OnIsHideableChanged)));

public bool IsHideable 
{
get{return (bool)GetValue(IsHideableProperty);}
set{SetValue(IsHideableProperty, BooleanBoxes.Box(value));}
}

The purpose of this dependency property is to hide and show the "PART_Hide_Button" using ControlTemplate.Triggers.

<ControlTemplate x:Key="DefaultExtendedWindowTemplate" TargetType="{x:Type ui:ExtendedWindow}">
        <ControlTemplate.Resources>
            <coverter:ToWhiteBackgroundBorderConventer x:Key="ToWhiteBackgroundBorderConventer"/>
        </ControlTemplate.Resources>
        <Grid>
            <Grid x:Name="PART_ExternalGrid" Background="{TemplateBinding Background}">
                <Grid.RowDefinitions>
                    <RowDefinition Height="{Binding Source={StaticResource Window.HeaderBar.HeaderHeight}}"/>
                    <RowDefinition Height="*"/>
                </Grid.RowDefinitions>
                <Grid x:Name="PART_HeaderBar" Grid.Row="0" Panel.ZIndex="{Binding Source={StaticResource Window.HeaderBar.HeaderZIndex}}">
                    <StackPanel Orientation="Horizontal" VerticalAlignment="Stretch" HorizontalAlignment="Left" Margin="20,20,0,0">
                        <Image Source="{TemplateBinding Icon}" Height="{Binding Source={StaticResource Window.HeaderBar.HeaderIconHeight}}" Width="{Binding Source={StaticResource Window.HeaderBar.HeaderIconWidth}}"/>
                    </StackPanel>
                    <StackPanel Orientation="Horizontal" VerticalAlignment="Stretch" HorizontalAlignment="Right" Margin="0,0,15,0">
                        <ui:RoundedButton x:Name="PART_Hide_Button" Style="{DynamicResource DefaultWindowRightButtonStyle}" Command="{x:Static com:ExtendedSystemCommands.HideInTreyWindowCommand}" ToolTip="Hide" Content="{x:Static fil:WindowButtonFilling.HideButtonFilling}"/>
                        <ui:RoundedButton x:Name="PART_Minimize_Button" Style="{DynamicResource DefaultWindowRightButtonStyle}" Command="{x:Static com:ExtendedSystemCommands.MinimizeWindowCommand}" ToolTip="Minimize" Content="{x:Static fil:WindowButtonFilling.MinimizeButtonFilling}"/>
                        <ui:RoundedButton x:Name="PART_MaximizeAndRestore_Button" Style="{DynamicResource DefaultWindowRightButtonStyle}"/>
                        <ui:RoundedButton x:Name="PART_Close_Button" Style="{DynamicResource DefaultWindowRightButtonStyle}" Command="{x:Static com:ExtendedSystemCommands.CloseWindowCommand}" ToolTip="Close" Content="{x:Static fil:WindowButtonFilling.CloseButtonFilling}"/>
                    </StackPanel>
                </Grid>
                <Grid Grid.RowSpan="2">
                    <AdornerDecorator>
                        <ContentPresenter
                                Content="{TemplateBinding Content}" 
                                ContentTemplate="{TemplateBinding ContentTemplate}" 
                                SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}"/>
                    </AdornerDecorator>
                    <ResizeGrip x:Name="WindowResizeGrip" HorizontalAlignment="Right" VerticalAlignment="Bottom" Visibility="Collapsed" IsTabStop="False" />
                </Grid>
            </Grid>
        </Grid>
        <ControlTemplate.Triggers>
            <Trigger Property="ui:ExtendedWindow.IsHideable" Value="False">
                <Setter TargetName="PART_Hide_Button" Property="Visibility" Value="Collapsed"/>
            </Trigger>
            
            <Trigger Property="ResizeMode" Value="CanResizeWithGrip">
                <Setter TargetName="WindowResizeGrip" Property="Visibility" Value="Visible" />
            </Trigger>

            <Trigger Property="WindowStyle" Value="ToolWindow">
                <Setter TargetName="PART_Minimize_Button" Property="Visibility" Value="Collapsed"/>
                <Setter TargetName="PART_MaximizeAndRestore_Button" Property="Visibility" Value="Collapsed"/>
            </Trigger>

            <Trigger Property="WindowState" Value="Normal">
                <Setter TargetName="PART_MaximizeAndRestore_Button" Property="Command" Value="{x:Static com:ExtendedSystemCommands.MaximizeWindowCommand}"/>
                <Setter TargetName="PART_MaximizeAndRestore_Button" Property="Content" Value="{x:Static fil:WindowButtonFilling.MaximizeButtonFilling}"/>
                <Setter TargetName="PART_MaximizeAndRestore_Button" Property="ToolTip" Value="Maximize"/>

                <Setter TargetName="PART_ExternalGrid" Property="Margin" Value="0"/>
            </Trigger>

            <Trigger Property="WindowState" Value="Maximized">
                <Setter TargetName="PART_MaximizeAndRestore_Button" Property="Command" Value="{x:Static com:ExtendedSystemCommands.RestoreWindowCommand}"/>
                <Setter TargetName="PART_MaximizeAndRestore_Button" Property="Content" Value="{x:Static fil:WindowButtonFilling.RestoreButtonFilling}"/>
                <Setter TargetName="PART_MaximizeAndRestore_Button" Property="ToolTip" Value="Restore"/>

                <Setter TargetName="PART_ExternalGrid" Property="Margin" Value="7"/>
            </Trigger>
        </ControlTemplate.Triggers>
    </ControlTemplate>

    <Style TargetType="{x:Type ui:ExtendedWindow}">
        <Setter Property="RenderOptions.BitmapScalingMode" Value="HighQuality"/>
        <Setter Property="Background" Value="{DynamicResource Window.Static.Background}"/>
        <Setter Property="Foreground" Value="{DynamicResource Window.Static.Foreground}"/>
        <Setter Property="SnapsToDevicePixels" Value="True" />
        <Setter Property="MinHeight" Value="90"/>
        <Setter Property="MinWidth" Value="260"/>
        <Setter Property="IsHideable" Value="True" />
        <Setter Property="Template" Value="{DynamicResource DefaultExtendedWindowTemplate}"/>
        <Setter Property="WindowChrome.WindowChrome">
            <Setter.Value>
                <WindowChrome CaptionHeight="{DynamicResource Window.HeaderBar.HeaderHeight}"
                              CornerRadius="0"
                              GlassFrameThickness="0"
                              NonClientFrameEdges="None"
                              ResizeBorderThickness="5"
                              UseAeroCaptionButtons="False" />
            </Setter.Value>
        </Setter>
    </Style>

The problem is that if I use this piece of code instead of the one above.

<Trigger Property="IsHideable" Value="False">
	<Setter TargetName="PART_Hide_Button" Property="Visibility" Value="Collapsed"/>
</Trigger>

Then I get the error "Property cannot have an undefined (null) value". Otherwise, there is no update in the designer. GIF attached.

Code.gif

As you can see, the left button does not disappear. Tell me where I'm wrong or what I'm not doing.

Hui Liu-MSFT 48,681 Reputation points Microsoft External Staff

2023-06-19T02:33:44.9133333+00:00
Hi,@Oscallo. Welcome Microsoft Q&A. What is your complete code for DefaultWindowRightButtonStyle, ExtendedSystemCommands.HideInTreyWindowCommand, RoundedButton, BooleanBoxes and OnIsHideableChanged? Or is it possible to show me the minimal sample code that can reproduce the problem to reproduce the problem and analysis?

<ui:RoundedButton x:Name="PART_Hide_Button" Style="{DynamicResource DefaultWindowRightButtonStyle}" Command="{x:Static com:ExtendedSystemCommands.HideInTreyWindowCommand}" ToolTip="Hide" Content="{x:Static fil:WindowButtonFilling.HideButtonFilling}"/>

Oscallo 0

Hi, @Hui Liu-MSFT . Attaching code snippets.

using System;

namespace CoreLand.UI.Modules.Boxes
{
    public static class BooleanBoxes
    {
        public static object TrueBox = true;
        public static object FalseBox = false;

        public static bool Exist(object obj) 
        {
            try
            {
                bool val = Convert.ToBoolean(obj);

                return true;
            }
            catch { return false; }
        }

        public static object Box(bool value)
        {
            if (value == true)
            {
                return TrueBox;
            }
            else
            {
                return FalseBox;
            }
        }
    }
}

private static void OnIsHideableChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
//
}

For now, OnIsHideableChanged is a stub. Below, for simplicity, I will lay out two files that make up ExtendedWindow.

RoundedButton consists of two files RoundedButtonDependency.cs and RoundedButtonExemplar.cs.

RoundedButtonDependency.cs

using CoreLand.UI.Extensions;
using System.Windows;

namespace CoreLand.UI.CustomControls
{
    public partial class RoundedButton : SquaredButtonBase
    {
        public static readonly DependencyProperty CornerRadiusProperty
            = DependencyProperty.Register("CornerRadius", typeof(CornerRadius), typeof(RoundedButton),
                                          new FrameworkPropertyMetadata(new CornerRadius(), FrameworkPropertyMetadataOptions.AffectsMeasure | FrameworkPropertyMetadataOptions.AffectsRender),
                                          new ValidateValueCallback(IsCornerRadiusValid));

        private static bool IsCornerRadiusValid(object value)
        {
            CornerRadius cr = (CornerRadius)value;
            return (cr.IsValid(false, false, false, false));
        }

        static RoundedButton()
        {
            DefaultStyleKeyProperty.OverrideMetadata(typeof(RoundedButton), new FrameworkPropertyMetadata(typeof(RoundedButton)));
        }
    }
}

RoundedButtonExemplar.cs

using System.Windows;

namespace CoreLand.UI.CustomControls
{
    public partial class RoundedButton : SquaredButtonBase
    {
        public CornerRadius CornerRadius
        {
            get { return (CornerRadius)GetValue(CornerRadiusProperty); }
            set { SetValue(CornerRadiusProperty, value); }
        }
    }
}

The IsValid method is in the extension file.

using System;
using System.Windows;

namespace CoreLand.UI.Extensions
{
    public static class CornerRadiusExtension
    {
        public static bool IsValid(this CornerRadius cornerRadius, bool allowNegative, bool allowNaN, bool allowPositiveInfinity, bool allowNegativeInfinity)
        {
            double _topLeft = cornerRadius.TopLeft;
            double _topRight = cornerRadius.TopRight;
            double _bottomLeft = cornerRadius.BottomLeft;
            double _bottomRight = cornerRadius.BottomRight;

            if (allowNegative == false)
            {
                if (_topLeft < 0d || _topRight < 0d || _bottomLeft < 0d || _bottomRight < 0d)
                {
                    return (false);
                }
            }

            if (allowNaN == false)
            {
                if (Double.IsNaN(_topLeft) || Double.IsNaN(_topRight) || Double.IsNaN(_bottomLeft) || Double.IsNaN(_bottomRight))
                {
                    return (false);
                }
            }

            if (allowPositiveInfinity == false)
            {
                if (Double.IsPositiveInfinity(_topLeft) || Double.IsPositiveInfinity(_topRight) || Double.IsPositiveInfinity(_bottomLeft) || Double.IsPositiveInfinity(_bottomRight))
                {
                    return (false);
                }
            }

            if (allowNegativeInfinity == false)
            {
                if (Double.IsNegativeInfinity(_topLeft) || Double.IsNegativeInfinity(_topRight) || Double.IsNegativeInfinity(_bottomLeft) || Double.IsNegativeInfinity(_bottomRight))
                {
                    return (false);
                }
            }

            return (true);
        }
    }
}

SquaredButtonBase also consists of two files SquaredButtonBaseDependency.cs and SquaredButtonBaseExemplar.cs.

SquaredButtonBaseDependency.cs

using System;
using System.Windows;
using System.Windows.Controls;

namespace CoreLand.UI.CustomControls
{
    public partial class SquaredButtonBase : Button
    {
        public static readonly DependencyProperty EdgeProperty = DependencyProperty.Register(
                                                                 "Edge", typeof(double), typeof(SquaredButtonBase),
                                                                 new FrameworkPropertyMetadata(Double.NaN, FrameworkPropertyMetadataOptions.AffectsMeasure, new PropertyChangedCallback(OnTransformDirty)),
                                                                 new ValidateValueCallback(IsEdgeValid));


        private static void OnTransformDirty(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            SquaredButtonBase squaredButtonBase = ((SquaredButtonBase)d);

            squaredButtonBase.Width = (double)e.NewValue;
            squaredButtonBase.Height = (double)e.NewValue;
        }

        private static bool IsEdgeValid(object value)
        {
            double doubleValue = (double)value;
            return (Double.IsNaN(doubleValue)) || (doubleValue >= 0.0d && !Double.IsPositiveInfinity(doubleValue));
        }

        static SquaredButtonBase()
        {
            DefaultStyleKeyProperty.OverrideMetadata(typeof(SquaredButtonBase), new FrameworkPropertyMetadata(typeof(SquaredButtonBase)));
        }
    }
}

SquaredButtonBaseExemplar.cs

using System.ComponentModel;
using System.Windows;
using System.Windows.Controls;

namespace CoreLand.UI.CustomControls
{
    public partial class SquaredButtonBase : Button
    {
        [TypeConverter(typeof(LengthConverter))]
        [Localizability(LocalizationCategory.None, Readability = Readability.Unreadable)]
        public new double Height
        {
            get { return (double)GetValue(HeightProperty); }
            private set { SetValue(HeightProperty, value); }
        }

        [TypeConverter(typeof(LengthConverter))]
        [Localizability(LocalizationCategory.None, Readability = Readability.Unreadable)]
        public new double Width
        {
            get { return (double)GetValue(WidthProperty); }
            private set { SetValue(WidthProperty, value); }
        }

        [TypeConverter(typeof(LengthConverter))]
        [Localizability(LocalizationCategory.None, Readability = Readability.Unreadable)]
        public double Edge
        {
            get { return (double)GetValue(EdgeProperty); }
            set { SetValue(EdgeProperty, value); }
        }

        public SquaredButtonBase() : base()
        {

        }

    }
}

Style DefaultWindowRightButtonStyle.

<Style x:Key="DefaultWindowRightButtonStyle" TargetType="{x:Type ui:RoundedButton}">
        <Setter Property="WindowChrome.IsHitTestVisibleInChrome" Value="True"/>
        <Setter Property="Foreground" Value="White"/>
        <Setter Property="Background" Value="#26FFFFFF"/>
        <Setter Property="BorderBrush" Value="Transparent"/>
        <Setter Property="Focusable" Value="False" />
        <Setter Property="Edge" Value="26"/>
        <Setter Property="CornerRadius" Value="20"/>
        <Setter Property="Margin" Value="0,0,10,0"/>
        <Setter Property="IsTabStop" Value="False"/>
        <Style.Triggers>
            <Trigger Property="IsMouseOver" Value="True">
                <Setter Property="Background" Value="#4CFFFFFF"/>
                <Setter Property="BorderBrush" Value="Transparent"/>
            </Trigger>
            <Trigger Property="IsPressed" Value="True">
                <Setter Property="Background" Value="#4C616161"/>
                <Setter Property="BorderBrush" Value="Transparent"/>
            </Trigger>
            <Trigger Property="IsEnabled" Value="False">
                <Setter Property="Background" Value="#7F252525"/>
                <Setter Property="BorderBrush" Value="Transparent"/>
            </Trigger>
        </Style.Triggers>
    </Style>

RoundedButton has a standard style.

<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                    xmlns:local="clr-namespace:CoreLand.UI.CustomControls">
    
    <ResourceDictionary.MergedDictionaries>
        <ResourceDictionary Source="pack://application:,,,/CoreLand.UI;component/Modules/ThemeManager/DefaultColorScheme.xaml"/>
    </ResourceDictionary.MergedDictionaries>
    
    <SolidColorBrush x:Key="RoundedButton.Static.Background" Color="{DynamicResource RoundedButton.Static.BackgroundColor}"/>
    <SolidColorBrush x:Key="RoundedButton.Static.Border" Color="{DynamicResource RoundedButton.Static.BorderColor}"/>
    <SolidColorBrush x:Key="RoundedButton.Static.Foreground" Color="{DynamicResource RoundedButton.Static.ForegroundColor}"/>

    <SolidColorBrush x:Key="RoundedButton.MouseOver.Background" Color="{DynamicResource RoundedButton.MouseOver.BackgroundColor}"/>
    <SolidColorBrush x:Key="RoundedButton.MouseOver.Border" Color="{DynamicResource RoundedButton.MouseOver.BorderColor}"/>
    <SolidColorBrush x:Key="RoundedButton.MouseOver.Foreground" Color="{DynamicResource RoundedButton.MouseOver.ForegroundColor}"/>

    <SolidColorBrush x:Key="RoundedButton.Pressed.Background" Color="{DynamicResource RoundedButton.Pressed.BackgroundColor}"/>
    <SolidColorBrush x:Key="RoundedButton.Pressed.Border" Color="{DynamicResource RoundedButton.Pressed.BorderColor}"/>
    <SolidColorBrush x:Key="RoundedButton.Pressed.Foreground" Color="{DynamicResource RoundedButton.Pressed.ForegroundColor}"/>

    <SolidColorBrush x:Key="RoundedButton.Disabled.Background" Color="{DynamicResource RoundedButton.Disabled.BackgroundColor}"/>
    <SolidColorBrush x:Key="RoundedButton.Disabled.Border" Color="{DynamicResource RoundedButton.Disabled.BorderColor}"/>
    <SolidColorBrush x:Key="RoundedButton.Disabled.Foreground" Color="{DynamicResource RoundedButton.Disabled.ForegroundColor}"/>
    
    <ControlTemplate TargetType="{x:Type local:RoundedButton}" x:Key="DefaultRoundedButtonTemplate">
        <Border x:Name="PART_border" Background="{TemplateBinding Background}" CornerRadius="{TemplateBinding CornerRadius}" BorderBrush="{TemplateBinding BorderBrush}" BorderThickness="{TemplateBinding BorderThickness}" SnapsToDevicePixels="true">
            <ContentPresenter x:Name="PART_ContentPresenter" Focusable="False" HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}" Margin="{TemplateBinding Padding}" 
                              RecognizesAccessKey="True" SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}" VerticalAlignment="{TemplateBinding VerticalContentAlignment}"/>
        </Border>
        <ControlTemplate.Triggers>
            <Trigger Property="IsDefaulted" Value="True">
                <Setter Property="BorderBrush" Value="{DynamicResource {x:Static SystemColors.HighlightBrushKey}}"/>
            </Trigger>
            <Trigger Property="IsMouseOver" Value="True">
                <Setter Property="Background" Value="{StaticResource RoundedButton.MouseOver.Background}"/>
                <Setter Property="BorderBrush" Value="{StaticResource RoundedButton.MouseOver.Border}"/>
                <Setter Property="TextElement.Foreground" TargetName="PART_ContentPresenter" Value="{StaticResource RoundedButton.MouseOver.Foreground}"/>
            </Trigger>
            <Trigger Property="IsPressed" Value="True">
                <Setter Property="Background" Value="{StaticResource RoundedButton.Pressed.Background}"/>
                <Setter Property="BorderBrush" Value="{StaticResource RoundedButton.Pressed.Border}"/>
                <Setter Property="TextElement.Foreground" TargetName="PART_ContentPresenter" Value="{StaticResource RoundedButton.Pressed.Foreground}"/>
            </Trigger>
            <Trigger Property="IsEnabled" Value="False">
                <Setter Property="Background" Value="{StaticResource RoundedButton.Disabled.Background}"/>
                <Setter Property="BorderBrush" Value="{StaticResource RoundedButton.Disabled.Border}"/>
                <Setter Property="TextElement.Foreground" TargetName="PART_ContentPresenter" Value="{StaticResource RoundedButton.Disabled.Foreground}"/>
            </Trigger>
        </ControlTemplate.Triggers>
    </ControlTemplate>
    
    <Style TargetType="{x:Type local:RoundedButton}" BasedOn="{StaticResource {x:Type Button}}">
        <Setter Property="SnapsToDevicePixels" Value="true" />
        <Setter Property="MinWidth" Value="20"/>
        <Setter Property="MinHeight" Value="20"/>
        <Setter Property="Edge" Value="20"/>
        <Setter Property="Background" Value="{StaticResource RoundedButton.Static.Background}"/>
        <Setter Property="BorderBrush" Value="{StaticResource RoundedButton.Static.Border}"/>
        <Setter Property="Foreground" Value="{StaticResource RoundedButton.Static.Foreground}"/>
        <Setter Property="Template" Value="{StaticResource DefaultRoundedButtonTemplate}"/>
    </Style>
    
</ResourceDictionary>

Attaching the DefaultColorScheme.xaml below.

<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
    
    <Color x:Key="PrimaryColor">#23272C</Color>
    <Color x:Key="SubPrimaryColor">#13141f</Color>
    
    <Color x:Key="SubSecondaryColor">#3F1DBAC5</Color>
    <Color x:Key="SecondaryColor">#1DBAC5</Color>
    
    <Color x:Key="TertiaryColor">#D14D14</Color>
    <Color x:Key="SubTertiaryColor">#C51D31</Color>
    
    <Color x:Key="Window.Static.BackgroundColor">#23272C</Color>
    <Color x:Key="Window.Static.ForegroundColor">#1DBAC5</Color>

    <Color x:Key="ToolTip.BackgroundColor">#23272C</Color>
    <Color x:Key="ToolTip.ForegroundColor">#1DBAC5</Color>

    <Color x:Key="Separator.BackgroundColor">#4C4E4E4E</Color>

    <Color x:Key="RoundedButton.Static.BackgroundColor">#FFDDDDDD</Color>
    <Color x:Key="RoundedButton.Static.BorderColor">#FF707070</Color>
    <Color x:Key="RoundedButton.Static.ForegroundColor">Black</Color>

    <Color x:Key="RoundedButton.MouseOver.BackgroundColor">#FFBEE6FD</Color>
    <Color x:Key="RoundedButton.MouseOver.BorderColor">#FF3C7FB1</Color>
    <Color x:Key="RoundedButton.MouseOver.ForegroundColor">White</Color>

    <Color x:Key="RoundedButton.Pressed.BackgroundColor">#FFC4E5F6</Color>
    <Color x:Key="RoundedButton.Pressed.BorderColor">#FF2C628B</Color>
    <Color x:Key="RoundedButton.Pressed.ForegroundColor">White</Color>

    <Color x:Key="RoundedButton.Disabled.BackgroundColor">#FFF4F4F4</Color>
    <Color x:Key="RoundedButton.Disabled.BorderColor">#FFADB2B5</Color>
    <Color x:Key="RoundedButton.Disabled.ForegroundColor">#FF838383</Color>

    <Color x:Key="SquaredButton.Static.BackgroundColor">#FFDDDDDD</Color>
    <Color x:Key="SquaredButton.Static.BorderColor">#FF707070</Color>
    <Color x:Key="SquaredButton.Static.ForegroundColor">Black</Color>

    <Color x:Key="SquaredButton.MouseOver.BackgroundColor">#FFBEE6FD</Color>
    <Color x:Key="SquaredButton.MouseOver.BorderColor">#FF3C7FB1</Color>
    <Color x:Key="SquaredButton.MouseOver.ForegroundColor">White</Color>

    <Color x:Key="SquaredButton.Pressed.BackgroundColor">#FFC4E5F6</Color>
    <Color x:Key="SquaredButton.Pressed.BorderColor">#FF2C628B</Color>
    <Color x:Key="SquaredButton.Pressed.ForegroundColor">White</Color>

    <Color x:Key="SquaredButton.Disabled.BackgroundColor">#FFF4F4F4</Color>
    <Color x:Key="SquaredButton.Disabled.BorderColor">#FFADB2B5</Color>
    <Color x:Key="SquaredButton.Disabled.ForegroundColor">#FF838383</Color>

</ResourceDictionary>

ExtendedSystemCommands is an extension of the standard SystemCommands.

public static class ExtendedSystemCommands
{
        private static string _HIDEINTREYWINDOWCOMMANDNAME = "HideInTreyWindow";

        public static RoutedCommand CloseWindowCommand => SystemCommands.CloseWindowCommand;
        public static RoutedCommand MaximizeWindowCommand => SystemCommands.MaximizeWindowCommand;
        public static RoutedCommand MinimizeWindowCommand => SystemCommands.MinimizeWindowCommand;
        public static RoutedCommand RestoreWindowCommand => SystemCommands.RestoreWindowCommand;
        public static RoutedCommand ShowSystemMenuCommand => SystemCommands.ShowSystemMenuCommand;
        public static RoutedCommand HideInTreyWindowCommand { get; private set; }

        public static void CloseWindow(Window window) => SystemCommands.CloseWindow(window);
        public static void MaximizeWindow(Window window) => SystemCommands.MaximizeWindow(window);
        public static void MinimizeWindow(Window window) => SystemCommands.MinimizeWindow(window);
        public static void RestoreWindow(Window window) => SystemCommands.RestoreWindow(window);
        public static void ShowSystemMenu(Window window, Point screenLocation) => SystemCommands.ShowSystemMenu(window, screenLocation);
        
        static ExtendedSystemCommands() 
        {
            HideInTreyWindowCommand = new RoutedCommand(_HIDEINTREYWINDOWCOMMANDNAME, typeof(ExtendedSystemCommands));
        }

        public static void HideInTreyWindow(Window window) 
        {
            if (window == null) 
            {
                throw new ArgumentNullException(nameof(window));    
            }
            #pragma warning disable CS8602 
            TreyController.Instance.HideWindow(window);
            #pragma warning restore CS8602 
        }
}

TreyController.cs in first iteration...

using System;
using System.Windows;
using System.Drawing;
using System.Windows.Forms;
using CoreLand.UI.Modules.Information;

using ApplicationWPF = System.Windows.Application;

namespace CoreLand.UI.Modules.Trey
{
    public class TreyController : IDisposable
    {
        #region static Instance

        public static TreyController? Instance { get; private set; }

        static TreyController()
        {
            Instance = new TreyController();
        }

        public static void DisposeInstance()
        {
            if (Instance != null)
            {
                Instance.Dispose();
                Instance = null;
            }
        }

        #endregion

        private NotifyIcon _NotifyIcon = new NotifyIcon();

        private Window? _HidedWindow;

        public TreyController(string text, Icon icon)
        {
            _InitializeEvents();
            _SetIcon(icon);
            _SetText(text);
        }

        public TreyController() : this(InformationReporter.ApplicationName + Environment.NewLine + "v." + InformationReporter.ApplicationVersion, InformationReporter.ApplicationIcon)
        {

        }

        private void _InitializeEvents()
        {
            _NotifyIcon.MouseClick += _NotifyIcon_MouseClick;
            ApplicationWPF.Current.Exit += App_Exit;
        }

        private void _NotifyIcon_MouseClick(object? sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Left)
            {
                _MouseLeftButtonClick();
            }
            else if (e.Button == MouseButtons.Right) 
            {
                _MouseRightButtonClick();
            }
        }

        private void _MouseLeftButtonClick()
        {
            ShowWindow();
        }

        private void _MouseRightButtonClick()
        {
            
        }

        private void _UninitializeEvents()
        {
            _NotifyIcon.MouseClick -= _NotifyIcon_MouseClick;
            ApplicationWPF.Current.Exit -= App_Exit;
        }

        private void App_Exit(object sender, ExitEventArgs e)
        {
            DisposeInstance();
        }

        public void HideWindow(Window window)
        {
            _SetWindow(window);
            HideWindow();
        }

        public void HideWindow()
        {
            if (_HidedWindow == null) { throw new NullReferenceException(); }
            _NotifyIcon.Visible = true;
            _HidedWindow.Hide();
        }

        public void ShowWindow()
        {
            if (_HidedWindow != null)
            {
                _HidedWindow.Show();
                _HideIcon();
            }
        }

        private void _SetWindow(Window window) 
        {
            if (_HidedWindow != null)
            {
                ShowWindow();
            }
            _HidedWindow = window;
        }

        private void _SetIcon(Icon icon)
        {
            _NotifyIcon.Icon = icon;
        }

        private void _SetText(string text)
        {
            _NotifyIcon.Text = text;
        }

        private void _HideIcon()
        {
            _NotifyIcon.Visible = false;
        }

        public void Dispose()
        {
            _HideIcon();
            _UninitializeEvents();
        }

    }
}

An information file that will contain all the necessary information about the application.

using System.Drawing;
using System.Reflection;

namespace CoreLand.UI.Modules.Information
{
    public static class InformationReporter
    {
        #pragma warning disable CS8603 
        #pragma warning disable CS8602 


        public static string ApplicationVersion => Assembly.GetEntryAssembly().GetName().Version.ToString();


        public static string ApplicationName => Assembly.GetEntryAssembly().GetName().Name;

        public static Icon ApplicationIcon => Icon.ExtractAssociatedIcon(Assembly.GetEntryAssembly().Location);

        #pragma warning restore CS8602 
        #pragma warning restore CS8603 
    }
}

ExtendedWindowExemplar.cs

using CoreLand.UI.Modules.Boxes;
using CoreLand.UI.Modules.Commands;
using CoreLand.UI.Modules.Information;
using System;
using System.ComponentModel;
using System.Windows;
using System.Windows.Input;
using static System.Windows.Forms.VisualStyles.VisualStyleElement;

namespace CoreLand.UI.CustomControls
{
    public partial class ExtendedWindow : System.Windows.Window
    {
        public ExtendedWindow() : base()
        {
            this.CommandBindings.Add(new CommandBinding(ExtendedSystemCommands.CloseWindowCommand, OnCloseWindow));
            this.CommandBindings.Add(new CommandBinding(ExtendedSystemCommands.MaximizeWindowCommand, OnMaximizeWindow, OnCanResizeWindow));
            this.CommandBindings.Add(new CommandBinding(ExtendedSystemCommands.MinimizeWindowCommand, OnMinimizeWindow, OnCanMinimizeWindow));
            this.CommandBindings.Add(new CommandBinding(ExtendedSystemCommands.RestoreWindowCommand, OnRestoreWindow, OnCanResizeWindow));
            this.CommandBindings.Add(new CommandBinding(ExtendedSystemCommands.HideInTreyWindowCommand, OnHideInTreyWindow, OnCanHideInTreyWindow));
        }

        private void OnCanHideInTreyWindow(object sender, CanExecuteRoutedEventArgs e)
        {
            e.CanExecute = InformationReporter.ApplicationIcon != null;
        }

        private void OnHideInTreyWindow(object sender, ExecutedRoutedEventArgs e)
        {
            ExtendedSystemCommands.HideInTreyWindow(this);
        }

        private void OnCanMinimizeWindow(object sender, CanExecuteRoutedEventArgs e)
        {
            e.CanExecute = this.ResizeMode != ResizeMode.NoResize;
        }

        private void OnCanResizeWindow(object sender, CanExecuteRoutedEventArgs e)
        {
            e.CanExecute = this.ResizeMode == ResizeMode.CanResize || this.ResizeMode == ResizeMode.CanResizeWithGrip;
        }

        private void OnCloseWindow(object sender, ExecutedRoutedEventArgs e)
        {
            ExtendedSystemCommands.CloseWindow(this);
        }

        private void OnMaximizeWindow(object sender, ExecutedRoutedEventArgs e)
        {
            ExtendedSystemCommands.MaximizeWindow(this);
        }

        private void OnMinimizeWindow(object sender, ExecutedRoutedEventArgs e)
        {
            ExtendedSystemCommands.MinimizeWindow(this);
        }

        private void OnRestoreWindow(object sender, ExecutedRoutedEventArgs e)
        {
            ExtendedSystemCommands.RestoreWindow(this);
        }

        public bool IsInDesignMode
        {
            get
            {
                return DesignerProperties.GetIsInDesignMode(this);
            }
        }

        public bool IsHideable
        {
            get 
            {
                return (bool)GetValue(IsHideableProperty); 
            }
            set 
            {
                SetValue(IsHideableProperty, BooleanBoxes.Box(value)); 
            }
        }
    }
}

ExtendedWindowDependency.cs

using CoreLand.UI.Modules.Boxes;
using System;
using System.Windows;

namespace CoreLand.UI.CustomControls
{
    public partial class ExtendedWindow : System.Windows.Window
    {
        public static readonly DependencyProperty IsHideableProperty = DependencyProperty.Register(nameof(IsHideable), typeof(bool), typeof(ExtendedWindow),
                               new FrameworkPropertyMetadata(BooleanBoxes.TrueBox,new PropertyChangedCallback(OnIsHideableChanged)));

        private static void OnIsHideableChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            
        }

        static ExtendedWindow()
        {
            DefaultStyleKeyProperty.OverrideMetadata(typeof(ExtendedWindow), new FrameworkPropertyMetadata(typeof(ExtendedWindow)));
        }
    }
}

Looks like I didn't forget anything. If necessary, I can add more. Since everything is located in files, with all the comments and punctuation. Thank you in advance.

Hui Liu-MSFT 48,681 Reputation points Microsoft External Staff

2023-06-20T03:15:30.65+00:00

Hi,@Oscallo. I try to show the ExtendedWindow but it is all black. Could you show your code for using ExtendedWindow?

Oscallo 0

Hi, @Hui Liu-MSFT .

Yes, sure. Do not be too surprised, but I have everything spaced into two projects. One is responsible for the GUI. And the second project is an application. Below is the XAML of the created window and its source code.

<ui:ExtendedWindow x:Class="Temphouse.Windows.DashboardWindow"
        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:ui="clr-namespace:CoreLand.UI.CustomControls;assembly=CoreLand.UI"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:Temphouse.Windows"
        d:Template="{DynamicResource DefaultExtendedWindowTemplate}" 
        mc:Ignorable="d" IsHideable="False"
        Title="DashboardWindow" Height="450" Width="800" Icon="/Icon.ico">
    <Grid>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="80"/>
            <ColumnDefinition Width="5"/>
            <ColumnDefinition Width="179*"/>
        </Grid.ColumnDefinitions>

        <Separator Grid.Column="1" Style="{DynamicResource VerticalSeparatorStyle}"/>
        
    </Grid>
</ui:ExtendedWindow>

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Shapes;
using CoreLand.UI.CustomControls;

namespace Temphouse.Windows
{
    public partial class DashboardWindow : ExtendedWindow
    {
        public DashboardWindow()
        {
            InitializeComponent();
        }
    }
}

Tell me, do you have a black screen only in the designer or when you start the application? Or perhaps I misunderstood you. And you wanted other code snippets from me?

Hui Liu-MSFT 48,681 Reputation points Microsoft External Staff

2023-06-21T02:21:02.1833333+00:00

Hi,@Oscallo. It seems that I can't display the ExtendedWindow and RoundedButton's ui correctly. Could you upload a project example that can reproduce the problem to github and share the link for me to analyze?
Oscallo 0 Reputation points

2023-06-21T14:44:13.6866667+00:00

Hello, . Yes, sure. Here is a link to the repository. https://github.com/Oscallo/Temphouse
Forgot to specify. The fact is that in older versions of VisualStudio, incorrect display is possible. I am using VisualStudio 2022 17.6.2. I apologize in advance, I'm not very familiar with GitHub yet.
Hui Liu-MSFT 48,681 Reputation points Microsoft External Staff

2023-06-22T02:12:00.53+00:00

Hi,@Oscallo.Thanks for the feedback, when you upload your project to GitHub, I can download your project for testing according to the link guide. The GitHub link is wrong, you could repost it.
Oscallo 0 Reputation points

2023-06-22T18:13:45.6133333+00:00

Hi, @Hui Liu-MSFT .I'm sorry, I didn't check the link. Link: GitHub

1 answer

Your answer

Hui Liu-MSFT 48,681 Reputation points Microsoft External Staff

2023-06-19T02:33:44.9133333+00:00

Hi,@Oscallo. Welcome Microsoft Q&A. What is your complete code for DefaultWindowRightButtonStyle, ExtendedSystemCommands.HideInTreyWindowCommand, RoundedButton, BooleanBoxes and OnIsHideableChanged? Or is it possible to show me the minimal sample code that can reproduce the problem to reproduce the problem and analysis?

<ui:RoundedButton x:Name="PART_Hide_Button" Style="{DynamicResource DefaultWindowRightButtonStyle}" Command="{x:Static com:ExtendedSystemCommands.HideInTreyWindowCommand}" ToolTip="Hide" Content="{x:Static fil:WindowButtonFilling.HideButtonFilling}"/>
Hui Liu-MSFT 48,681 Reputation points Microsoft External Staff

2023-06-20T03:15:30.65+00:00

Hi,@Oscallo. I try to show the ExtendedWindow but it is all black. Could you show your code for using ExtendedWindow?
Oscallo 0 Reputation points

2023-06-20T17:15:39.1366667+00:00

Hi, @Hui Liu-MSFT .

Yes, sure. Do not be too surprised, but I have everything spaced into two projects. One is responsible for the GUI. And the second project is an application. Below is the XAML of the created window and its source code.

<ui:ExtendedWindow x:Class="Temphouse.Windows.DashboardWindow" 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:ui="clr-namespace:CoreLand.UI.CustomControls;assembly=CoreLand.UI" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:local="clr-namespace:Temphouse.Windows" d:Template="{DynamicResource DefaultExtendedWindowTemplate}" mc:Ignorable="d" IsHideable="False" Title="DashboardWindow" Height="450" Width="800" Icon="/Icon.ico"> <Grid> <Grid.ColumnDefinitions> <ColumnDefinition Width="80"/> <ColumnDefinition Width="5"/> <ColumnDefinition Width="179*"/> </Grid.ColumnDefinitions> <Separator Grid.Column="1" Style="{DynamicResource VerticalSeparatorStyle}"/> </Grid> </ui:ExtendedWindow>

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using System.Windows; using System.Windows.Controls; using System.Windows.Data; using System.Windows.Documents; using System.Windows.Input; using System.Windows.Media; using System.Windows.Media.Imaging; using System.Windows.Shapes; using CoreLand.UI.CustomControls; namespace Temphouse.Windows { public partial class DashboardWindow : ExtendedWindow { public DashboardWindow() { InitializeComponent(); } } }

Tell me, do you have a black screen only in the designer or when you start the application? Or perhaps I misunderstood you. And you wanted other code snippets from me?
Hui Liu-MSFT 48,681 Reputation points Microsoft External Staff

2023-06-21T02:21:02.1833333+00:00

Hi,@Oscallo. It seems that I can't display the ExtendedWindow and RoundedButton's ui correctly. Could you upload a project example that can reproduce the problem to github and share the link for me to analyze?
Oscallo 0 Reputation points

2023-06-21T14:44:13.6866667+00:00

Hello, . Yes, sure. Here is a link to the repository. https://github.com/Oscallo/Temphouse
Forgot to specify. The fact is that in older versions of VisualStudio, incorrect display is possible. I am using VisualStudio 2022 17.6.2. I apologize in advance, I'm not very familiar with GitHub yet.
Hui Liu-MSFT 48,681 Reputation points Microsoft External Staff

2023-06-22T02:12:00.53+00:00

Hi,@Oscallo.Thanks for the feedback, when you upload your project to GitHub, I can download your project for testing according to the link guide. The GitHub link is wrong, you could repost it.
Oscallo 0 Reputation points

2023-06-22T18:13:45.6133333+00:00

Hi, @Hui Liu-MSFT .I'm sorry, I didn't check the link. Link: GitHub

Answer 1

Hi,@Oscallo.You could set DataTrigger in the style of PART_Hide_Button to trigger whether PART_Hide_Button is displayed, and delete the code that triggers the display part in ControlTemplate.Triggers

You can update your code as follows.

ExtendedWindow :

 public partial class ExtendedWindow : System.Windows.Window
    {
        /// <summary>
        ///     DependencyProperty свойства IsHideable.
        /// </summary>
        public static readonly DependencyProperty IsHideableProperty = DependencyProperty.Register(nameof(IsHideable), typeof(bool), typeof(ExtendedWindow),
                               
            new FrameworkPropertyMetadata(BooleanBoxes.TrueBox, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault)
            );
     
      
        static ExtendedWindow()
        {
            DefaultStyleKeyProperty.OverrideMetadata(typeof(ExtendedWindow), new FrameworkPropertyMetadata(typeof(ExtendedWindow)));
        }
    }

DefaultExtendedWindowTemplate:

 <ControlTemplate x:Key="DefaultExtendedWindowTemplate" TargetType="{x:Type ui:ExtendedWindow}">
        <Grid>
            <Grid x:Name="PART_ExternalGrid" Background="{TemplateBinding Background}">
                <Grid.RowDefinitions>
                    <RowDefinition Height="{Binding Source={StaticResource Window.HeaderBar.HeaderHeight}}"/>
                    <RowDefinition Height="*"/>
                </Grid.RowDefinitions>
                <Grid x:Name="PART_HeaderBar" Grid.Row="0" Panel.ZIndex="{Binding Source={StaticResource Window.HeaderBar.HeaderZIndex}}">
                    <StackPanel Orientation="Horizontal" VerticalAlignment="Stretch" HorizontalAlignment="Left" Margin="20,20,0,0">
                        <Image Source="{TemplateBinding Icon}" Height="{Binding Source={StaticResource Window.HeaderBar.HeaderIconHeight}}" Width="{Binding Source={StaticResource Window.HeaderBar.HeaderIconWidth}}"/>
                    </StackPanel>
                    <StackPanel Orientation="Horizontal" VerticalAlignment="Stretch" HorizontalAlignment="Right" Margin="0,0,15,0">
                        <ui:RoundedButton x:Name="PART_Hide_Button" 
                                          Command="{x:Static com:ExtendedSystemCommands.HideInTreyWindowCommand}" 
                                          ToolTip="Hide" Content="{x:Static fil:WindowButtonFilling.HideButtonFilling}">
                            <ui:RoundedButton.Style>
                                <Style TargetType="{x:Type ui:RoundedButton}">
                                    <Setter Property="WindowChrome.IsHitTestVisibleInChrome" Value="True"/>
                                    <Setter Property="Foreground" Value="White"/>
                                    <Setter Property="Background" Value="#26FFFFFF"/>
                                    <Setter Property="BorderBrush" Value="Transparent"/>
                                    <Setter Property="Focusable" Value="False" />
                                    <Setter Property="Edge" Value="26"/>
                                    <Setter Property="CornerRadius" Value="20"/>
                                    <Setter Property="Margin" Value="0,0,10,0"/>
                                    <Setter Property="IsTabStop" Value="False"/>
                                    <Setter Property="Visibility" Value="Visible"/>
                                    <Style.Triggers>
                                       
                                        <DataTrigger Binding="{Binding IsHideable,RelativeSource={RelativeSource TemplatedParent}}" Value="false">
                                            <Setter Property="Visibility" Value="Collapsed"/>
                                        </DataTrigger>
                                        <Trigger Property="IsMouseOver" Value="True">
                                            <Setter Property="Background" Value="#4CFFFFFF"/>
                                            <Setter Property="BorderBrush" Value="Transparent"/>
                                        </Trigger>
                                        <Trigger Property="IsPressed" Value="True">
                                            <Setter Property="Background" Value="#4C616161"/>
                                            <Setter Property="BorderBrush" Value="Transparent"/>
                                        </Trigger>
                                        <Trigger Property="IsEnabled" Value="False">
                                            <Setter Property="Background" Value="#7F252525"/>
                                            <Setter Property="BorderBrush" Value="Transparent"/>
                                        </Trigger>
                                    </Style.Triggers>
                                </Style>
                            </ui:RoundedButton.Style>
                         
                            
                        </ui:RoundedButton>
                        <ui:RoundedButton x:Name="PART_Minimize_Button" Style="{DynamicResource DefaultWindowRightButtonStyle}" Command="{x:Static com:ExtendedSystemCommands.MinimizeWindowCommand}" ToolTip="Minimize" Content="{x:Static fil:WindowButtonFilling.MinimizeButtonFilling}"/>
                        <ui:RoundedButton x:Name="PART_MaximizeAndRestore_Button" Style="{DynamicResource DefaultWindowRightButtonStyle}"/>
                        <ui:RoundedButton x:Name="PART_Close_Button" Style="{DynamicResource DefaultWindowRightButtonStyle}" Command="{x:Static com:ExtendedSystemCommands.CloseWindowCommand}" ToolTip="Close" Content="{x:Static fil:WindowButtonFilling.CloseButtonFilling}"/>
                    </StackPanel>
                </Grid>
                <Grid Grid.RowSpan="2">
                    <AdornerDecorator>
                        <ContentPresenter
                                Content="{TemplateBinding Content}" 
                                ContentTemplate="{TemplateBinding ContentTemplate}" 
                                SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}"/>
                    </AdornerDecorator>
                    <ResizeGrip x:Name="WindowResizeGrip" HorizontalAlignment="Right" VerticalAlignment="Bottom" Visibility="Collapsed" IsTabStop="False" />
                </Grid>
            </Grid>
        </Grid>
        <ControlTemplate.Triggers>
           
            <Trigger Property="ResizeMode" Value="CanResizeWithGrip">
                <Setter TargetName="WindowResizeGrip" Property="Visibility" Value="Visible" />
            </Trigger>

            <Trigger Property="WindowStyle" Value="ToolWindow">
                <Setter TargetName="PART_Minimize_Button" Property="Visibility" Value="Collapsed"/>
                <Setter TargetName="PART_MaximizeAndRestore_Button" Property="Visibility" Value="Collapsed"/>
            </Trigger>

            <Trigger Property="WindowState" Value="Normal">
                <Setter TargetName="PART_MaximizeAndRestore_Button" Property="Command" Value="{x:Static com:ExtendedSystemCommands.MaximizeWindowCommand}"/>
                <Setter TargetName="PART_MaximizeAndRestore_Button" Property="Content" Value="{x:Static fil:WindowButtonFilling.MaximizeButtonFilling}"/>
                <Setter TargetName="PART_MaximizeAndRestore_Button" Property="ToolTip" Value="Maximize"/>

                <Setter TargetName="PART_ExternalGrid" Property="Margin" Value="0"/>
            </Trigger>

            <Trigger Property="WindowState" Value="Maximized">
                <Setter TargetName="PART_MaximizeAndRestore_Button" Property="Command" Value="{x:Static com:ExtendedSystemCommands.RestoreWindowCommand}"/>
                <Setter TargetName="PART_MaximizeAndRestore_Button" Property="Content" Value="{x:Static fil:WindowButtonFilling.RestoreButtonFilling}"/>
                <Setter TargetName="PART_MaximizeAndRestore_Button" Property="ToolTip" Value="Restore"/>

                <Setter TargetName="PART_ExternalGrid" Property="Margin" Value="7"/>
            </Trigger>
        </ControlTemplate.Triggers>
    </ControlTemplate>

DashboardWindow :

  public partial class DashboardWindow : ExtendedWindow, INotifyPropertyChanged
    {
        public DashboardWindow()
        {
            InitializeComponent();
            DataContext = this;
        }
        private bool myvalue;
        public bool Value 
         {
        get { return myvalue; }
        set
        {
            if (myvalue != value)
            {
                    myvalue = value;
                OnPropertyChanged(nameof(Value));
            }
        }
        }
        public event PropertyChangedEventHandler PropertyChanged;

        protected virtual void OnPropertyChanged(string propertyName)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
    }
}

DashboardWindow:

<ui:ExtendedWindow x:Class="Temphouse.Windows.DashboardWindow"
        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:ui="clr-namespace:CoreLand.UI.CustomControls;assembly=CoreLand.UI"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:Temphouse.Windows"
        d:Template="{DynamicResource DefaultExtendedWindowTemplate}" 
        mc:Ignorable="d" IsHideable="{Binding Value,Mode=TwoWay,UpdateSourceTrigger=PropertyChanged}"
        Title="DashboardWindow" Height="450" Width="800" Icon="/Icon.ico">
    <Grid>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="80"/>
            <ColumnDefinition Width="100"/>
            <ColumnDefinition Width="179*"/>
        </Grid.ColumnDefinitions>

        <Separator Grid.Column="1" Style="{DynamicResource VerticalSeparatorStyle}"/>
        <CheckBox IsChecked="{Binding Value,Mode=TwoWay,UpdateSourceTrigger=PropertyChanged}" Width="100" Height="100" Grid.Column="1"  Foreground="White" Content="value" Background="AliceBlue"/>
    </Grid>
</ui:ExtendedWindow>

The result:

If the response is helpful, please click "Accept Answer" and upvote it.

Note: Please follow the steps in our documentation to enable e-mail notifications if you want to receive the related email notification for this thread.

Hui Liu-MSFT 48,681 Reputation points Microsoft External Staff

2023-06-26T03:01:02.6833333+00:00

Hi,@Oscallo. Is there any update to the question? Did my answer solve your problem? If so, you could accept it as the answer. It's helpful for community members with related questions.
Oscallo 0 Reputation points

2023-06-26T17:34:22.9166667+00:00

Hi, @Hui Liu-MSFT . I apologize for the delay. This is not exactly what I had in mind. I'm trying to make a library that could be used as an alternative to the standard window. And I'm annoyed not by the ability to hide the button in the designer, so that it does not interfere during design work. While the program is running, the button is hidden, if necessary.

P.S. I dare to assume that this fragment is attached to a specific instance of ExtendedWindow.

<Trigger Property="IsHideable" Value="False">

This fragment is attached to the static DP ExtendedWindow.

<Trigger Property="ui:ExtendedWindow.IsHideable" Value="False">

And therefore, the static option only receives the DefaultValue from the DP. The other option cannot find the DefaultValue and therefore I get "Error:XDG0010. Properties cannot have null value in trigger."
Hui Liu-MSFT 48,681 Reputation points Microsoft External Staff

2023-06-28T09:51:36.53+00:00

Hi,@Oscallo. I understand your requirement, I made some attempts and they work at runtime but the values are not updated at design time window. Seems like it accepts static values, changes in value are not reflected automatically.
Oscallo 0 Reputation points

2023-06-28T15:41:42.43+00:00

Hi, @Hui Liu-MSFT . Yes, I know that, but it haunts me that if I bind a trigger to any of the DPs that already exist in the Window class. Then the code works, maybe you know what this riddle lies in ....
Hui Liu-MSFT 48,681 Reputation points Microsoft External Staff

2023-06-30T08:43:35.13+00:00

Hi,@Oscallo. I tested the wpf projects of .net and .net framework in visual studio 2019 and visual studio 2022 respectively, and the results are the same.

When creating a custom control that inherits from Window, its template must be explicitly used before it can be displayed in the designer. Its dependency properties do not work in the designer, but it can work in runtime.

When creating a custom control that inherits Control, its template is displayed directly in the designer, its dependency properties work fine in the designer, and it works in the runtime.

I haven't found any relevant documentation so far, and not sure if it's a bug. I'll be back if there is an update.

Share via

Why doesn't the Visual Studio 2022 designer show changes?

1 answer

Your answer