Merge branch 'master' of https://github.com/corvinsz/MaterialDesignInXamlToolkit

Author: Corvin Szimion

Directory.packages.props

@@ -26,9 +26,9 @@
     <PackageVersion Include="System.Net.Http" Version="4.3.4" />
     <PackageVersion Include="System.Text.RegularExpressions" Version="4.3.1" />
     <PackageVersion Include="VirtualizingWrapPanel" Version="1.5.8" />
-    <PackageVersion Include="XAMLTest" Version="1.2.1" />
+    <PackageVersion Include="XAMLTest" Version="1.2.2" />
     <PackageVersion Include="xunit" Version="2.6.2" />
     <PackageVersion Include="xunit.runner.visualstudio" Version="2.5.4" />
     <PackageVersion Include="Xunit.StaFact" Version="1.1.11" />
   </ItemGroup>
-</Project>
+</Project>

docs/Freezable_Object_for_Enhanced_Performance.md

@@ -0,0 +1,27 @@
+[Home](..\README.md) > Using `Freezable` Objects for Enhanced Performance
+
+---
+
+# Using `Freezable` Objects for Enhanced Performance
+
+## Background information
+
+WPF provides the `Freezable` class for objects that can be made immutable to optimize performance, such as brushes, pens, and transforms.
+
+## Setting Objects as `Freezable`
+
+When an object is frozen, it becomes immutable, which reduces memory usage and allows WPF to optimize rendering.
+
+```csharp
+SolidColorBrush myBrush = new SolidColorBrush(Colors.Blue);
+if (myBrush.CanFreeze)
+{
+    myBrush.Freeze();
+}
+```
+
+Frozen objects cannot be modified, so only freeze objects that don’t require changes.
+
+## Benefits of Freezable Objects
+
+Freezable objects improve rendering speed, especially for large visuals or repeated animations. This technique is particularly useful in complex UIs with many reused resources.

docs/Optimize_UI_Thread_Performance.md

@@ -0,0 +1,45 @@
+[Home](..\README.md) > How to Optimize UI Thread Performance?
+
+---
+
+# How to Optimize UI Thread Performance?
+
+## Background information
+
+The UI thread in WPF is responsible for rendering controls and handling user interactions. Heavy computations or complex bindings on the UI thread can lead to sluggish performance and poor user experience.
+
+## Using `Dispatcher.BeginInvoke`
+
+For non-UI-intensive tasks that still need to interact with the UI, use `Dispatcher.BeginInvoke` to move tasks off the UI thread without blocking it:
+
+```csharp
+// Execute this in the background without freezing the UI
+Dispatcher.BeginInvoke((Action)(() =>
+{
+    // Update UI elements here
+}));
+```
+
+## Avoiding Complex Bindings
+
+Complex bindings, especially with large data sets, can slow down the UI. Consider simplifying bindings, reducing converters, or using `INotifyPropertyChanged` with view models to optimize data flow.
+
+```xaml
+<!-- Avoid multi-level bindings when possible -->
+<TextBlock Text="{Binding User.Name}" />
+```
+
+> [!NOTE]
+> Always test performance impacts when using nested or complex bindings.
+
+## Use `VirtualizingStackPanel` for Large Lists
+
+For large collections, use `VirtualizingStackPanel` to only create visuals for items in view:
+
+```xaml
+<ListBox VirtualizingStackPanel.IsVirtualizing="True" />
+```
+
+This reduces memory usage and improves scrolling performance in lists.
+
+

docs/Reducing_Layout_Complexity.md

@@ -0,0 +1,29 @@
+# Reducing Layout Complexity
+
+## Background information
+
+Complex layouts can slow down WPF performance, especially with nested controls or excessive use of `Grid` and `StackPanel`.
+
+## Avoid Nested Grids and StackPanels
+
+Overuse of nested layouts can create rendering bottlenecks. Try to simplify the structure or use a `UniformGrid` or `DockPanel` for simpler arrangements.
+
+```xaml
+<!-- Instead of nesting multiple StackPanels, use a single DockPanel -->
+<DockPanel>
+    <TextBlock Text="Header" DockPanel.Dock="Top" />
+    <ListView DockPanel.Dock="Bottom" />
+</DockPanel>
+```
+
+## Prefer Static Resources Over Dynamic Resources
+
+Static resources are faster to load compared to dynamic ones. Use dynamic resources only if you need runtime changes in resource values.
+
+```xaml
+<!-- Use StaticResource instead of DynamicResource for better performance -->
+<Style x:Key="ButtonStyle" TargetType="Button" BasedOn="{StaticResource BaseButtonStyle}" />
+```
+
+> [!NOTE]
+> Dynamic resources are reevaluated each time they’re used, which may impact performance.

src/MainDemo.Wpf/Domain/MainWindowViewModel.cs

@@ -475,7 +475,9 @@ private static IEnumerable<DemoItem> GenerateDemoItems(ISnackbarMessageQueue sna
         {
             DocumentationLink.DemoPageLink<NumericUpDown>(),
             DocumentationLink.StyleLink(nameof(NumericUpDown)),
-            DocumentationLink.ApiLink<NumericUpDown>()
+            DocumentationLink.ApiLink<NumericUpDown>(),
+            DocumentationLink.ApiLink<DecimalUpDown>(),
+            DocumentationLink.ApiLink<UpDownBase>()
         });
     }
 

src/MainDemo.Wpf/Domain/TabsViewModel.cs

@@ -23,10 +23,10 @@ internal class TabsViewModel : ViewModelBase
 
     public TabsViewModel()
     {
-        var closeCommand = new AnotherCommandImplementation(_ =>
+        var closeCommand = new AnotherCommandImplementation(tab =>
         {
-            if (SelectedTab is { } selectedTab)
-                CustomTabs?.Remove(selectedTab);
+            if (tab is CustomTab castedTab)
+                CustomTabs?.Remove(castedTab);
         });
 
         CustomTabs = new()

src/MainDemo.Wpf/NumericUpDown.xaml

@@ -1,4 +1,4 @@
-<UserControl x:Class="MaterialDesignDemo.NumericUpDown"
+<UserControl x:Class="MaterialDesignDemo.NumericUpDown"
              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"
@@ -25,12 +25,19 @@
     <StackPanel Margin="0,16,0,0"
                 DockPanel.Dock="Top"
                 Orientation="Horizontal">
+      
       <smtx:XamlDisplay Margin="10,5"
                         VerticalAlignment="Top"
                         UniqueKey="numericUpDown_default">
         <materialDesign:NumericUpDown />
       </smtx:XamlDisplay>
 
+      <smtx:XamlDisplay Margin="10,5"
+                  VerticalAlignment="Top"
+                  UniqueKey="decimalUpDown_default">
+        <materialDesign:DecimalUpDown ValueStep="0.5" Minimum="-2.5" Maximum="2.5" />
+      </smtx:XamlDisplay>
+
       <smtx:XamlDisplay Margin="10,5"
                         VerticalAlignment="Top"
                         UniqueKey="numericUpDown_customButtonContent">

src/MainDemo.Wpf/Tabs.xaml

@@ -732,7 +732,7 @@
             <DataTemplate>
               <StackPanel Orientation="Horizontal">
                 <TextBlock Text="{Binding CustomHeader}" />
-                <Button Command="{Binding CloseCommand}">
+                <Button Command="{Binding CloseCommand}" CommandParameter="{Binding}">
                   <Button.Template>
                     <ControlTemplate>
                       <materialDesign:PackIcon Kind="Close"

src/MaterialDesignThemes.Wpf/DecimalUpDown.cs

@@ -0,0 +1,42 @@
+#if !NET8_0_OR_GREATER
+using System.Globalization;
+#endif
+
+namespace MaterialDesignThemes.Wpf;
+
+public class DecimalUpDown
+#if NET8_0_OR_GREATER
+    : UpDownBase<decimal>
+#else
+    : UpDownBase<decimal, DecimalArithmetic>
+#endif
+{
+    static DecimalUpDown()
+    {
+        DefaultStyleKeyProperty.OverrideMetadata(typeof(DecimalUpDown), new FrameworkPropertyMetadata(typeof(DecimalUpDown)));
+    }
+}
+
+#if !NET8_0_OR_GREATER
+public class DecimalArithmetic : IArithmetic<decimal>
+{
+    public decimal Add(decimal value1, decimal value2) => value1 + value2;
+
+    public decimal Subtract(decimal value1, decimal value2) => value1 - value2;
+
+    public int Compare(decimal value1, decimal value2) => value1.CompareTo(value2);
+
+    public decimal MinValue() => decimal.MinValue;
+
+    public decimal MaxValue() => decimal.MaxValue;
+
+    public decimal One() => 1m;
+
+    public decimal Max(decimal value1, decimal value2) => Math.Max(value1, value2);
+
+    public decimal Min(decimal value1, decimal value2) => Math.Min(value1, value2);
+
+    public bool TryParse(string text, IFormatProvider? formatProvider, out decimal value)
+        => decimal.TryParse(text, NumberStyles.Number, formatProvider, out value);
+}
+#endif

src/MaterialDesignThemes.Wpf/HintAssist.cs

@@ -130,6 +130,17 @@ public static void SetHintPaddingBrush(DependencyObject obj, Brush? value)
         => obj.SetValue(HintPaddingBrushProperty, value);
     #endregion
 
+    #region AttachedProperty: ApplyHintPaddingBrush
+    public static readonly DependencyProperty ApplyHintPaddingBrushProperty =
+        DependencyProperty.RegisterAttached("ApplyHintPaddingBrush", typeof(bool), typeof(HintAssist), new PropertyMetadata(false));
+
+    public static bool GetApplyHintPaddingBrush(DependencyObject obj)
+        => (bool)obj.GetValue(ApplyHintPaddingBrushProperty);
+
+    public static void SetApplyHintPaddingBrush(DependencyObject obj, bool value)
+        => obj.SetValue(ApplyHintPaddingBrushProperty, value);
+    #endregion
+
     #region AttachedProperty : HelperTextProperty
     public static readonly DependencyProperty HelperTextProperty
         = DependencyProperty.RegisterAttached("HelperText", typeof(string), typeof(HintAssist),