ControlzEx · batzen · Jan 28, 2022 · May 20, 2020 · May 20, 2020 · Jul 25, 2020
diff --git a/.gitignore b/.gitignore
@@ -62,6 +62,7 @@ artifacts/
 *.tlh
 *.tmp
 *.tmp_proj
+*_wpftmp.csproj
 *.log
 *.binlog
 *.vspscc

diff --git a/GitVersion.yml b/GitVersion.yml
@@ -1,6 +1,6 @@
 assembly-versioning-scheme: Major
 assembly-file-versioning-scheme: MajorMinorPatchTag
-next-version: 5.0.0
+next-version: 6.0.0
 mode: ContinuousDeployment
 branches:
   master:

diff --git a/appveyor.yml b/appveyor.yml
@@ -15,14 +15,15 @@ environment:
     secure: CUpRJxMLeUZwNPMcqI0wECaWfy5AMnWn1UZhBd9WnQ3Z16lJP1Vzrkf24mccbhUD
   azure-key-vault-certificate:
     secure: BSPdW2TgnQtoQXXbeDECug==
+  IGNORE_NORMALISATION_GIT_HEAD_MOVE: 1
 
 skip_tags: true
-image: Visual Studio 2019 Preview
+image: Visual Studio 2022
 test: off
 
 install:
   - ps: Invoke-WebRequest 'https://dot.net/v1/dotnet-install.ps1' -OutFile 'dotnet-install.ps1'
-  - ps: ./dotnet-install.ps1 -Version 5.0.103 -InstallDir "C:\Program Files\dotnet"
+  - ps: ./dotnet-install.ps1 -Version 6.0.100 -InstallDir "C:\Program Files\dotnet"
 
 pull_requests:
   do_not_increment_build_number: false

diff --git a/build.cake b/build.cake
@@ -6,7 +6,7 @@
 #tool dotnet:?package=NuGetKeyVaultSignTool&version=1.2.28
 #tool dotnet:?package=AzureSignTool&version=2.0.17
 #tool dotnet:?package=GitReleaseManager.Tool&version=0.12.0
-#tool dotnet:?package=GitVersion.Tool&version=5.7.0
+#tool dotnet:?package=GitVersion.Tool&version=5.6.3
 
 #addin nuget:?package=Cake.Figlet&version=1.4.0
 
@@ -28,9 +28,9 @@ var isLocal = BuildSystem.IsLocalBuild;
 // Set build version
 if (isLocal == false || verbosity == Verbosity.Verbose)
 {
-    GitVersion(new GitVersionSettings { OutputType = GitVersionOutput.BuildServer });
+    GitVersion(new GitVersionSettings { OutputType = GitVersionOutput.BuildServer, NoFetch = true });
 }
-GitVersion gitVersion = GitVersion(new GitVersionSettings { OutputType = GitVersionOutput.Json });
+GitVersion gitVersion = GitVersion(new GitVersionSettings { OutputType = GitVersionOutput.Json, NoFetch = true });
 
 var isPullRequest = AppVeyor.Environment.PullRequest.IsPullRequest;
 var branchName = gitVersion.BranchName;

diff --git a/src/ControlzEx.Showcase/App.xaml b/src/ControlzEx.Showcase/App.xaml
@@ -3,38 +3,43 @@
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              xmlns:local="clr-namespace:ControlzEx.Showcase"
              xmlns:theming="clr-namespace:ControlzEx.Showcase.Theming"
-             StartupUri="MainWindow.xaml">
+             xmlns:controlzEx="urn:controlzex"
+             StartupUri="MainWindow.xaml"
+             ShutdownMode="OnMainWindowClose">
     <Application.Resources>
         <ResourceDictionary>
             <theming:ShowcaseLibraryThemeProvider x:Key="{x:Static theming:ShowcaseLibraryThemeProvider.DefaultInstance}" />
             <theming:SecondShowcaseLibraryThemeProvider x:Key="{x:Static theming:SecondShowcaseLibraryThemeProvider.DefaultInstance}" />
 
-            <Style x:Key="{x:Type local:WindowChromeWindow}" TargetType="{x:Type local:WindowChromeWindow}">
+            <SolidColorBrush x:Key="Button.Static.Background" Color="#FFDDDDDD" />
+            <SolidColorBrush x:Key="Button.Static.Border" Color="#FF707070" />
+            <SolidColorBrush x:Key="Button.MouseOver.Background" Color="#FFBEE6FD" />
+            <SolidColorBrush x:Key="Button.MouseOver.Border" Color="#FF3C7FB1" />
+            <SolidColorBrush x:Key="Button.Pressed.Background" Color="#FFC4E5F6" />
+            <SolidColorBrush x:Key="Button.Pressed.Border" Color="#FF2C628B" />
+            <SolidColorBrush x:Key="Button.Disabled.Background" Color="#FFF4F4F4" />
+            <SolidColorBrush x:Key="Button.Disabled.Border" Color="#FFADB2B5" />
+            <SolidColorBrush x:Key="Button.Disabled.Foreground" Color="#FF838383" />
+
+            <Style x:Key="{x:Type controlzEx:WindowChromeWindow}" TargetType="{x:Type controlzEx:WindowChromeWindow}">
                 <Setter Property="BorderThickness" Value="1" />
+                <Setter Property="BorderBrush" Value="{x:Null}" />
                 <Setter Property="NCActiveBrush" Value="{Binding Background, RelativeSource={RelativeSource Self}}" />
                 <Setter Property="NCCurrentBrush" Value="{Binding NCActiveBrush, RelativeSource={RelativeSource Self}}" />
                 <Setter Property="NCNonActiveBrush" Value="{Binding Source={x:Static SystemColors.WindowFrameBrush}}" />
-                <Setter Property="ResizeBorderThickness" Value="8" />
                 <Setter Property="Template">
                     <Setter.Value>
-                        <ControlTemplate TargetType="{x:Type local:WindowChromeWindow}">
+                        <ControlTemplate TargetType="{x:Type controlzEx:WindowChromeWindow}">
                             <Grid Background="{TemplateBinding Background}">
                                 <AdornerDecorator>
                                     <ContentPresenter />
                                 </AdornerDecorator>
 
-                                <Border x:Name="PART_Border2"
-                                        HorizontalAlignment="Stretch"
-                                        VerticalAlignment="Stretch"
-                                        Background="{x:Null}"
-                                        BorderThickness="{TemplateBinding BorderThickness}"
-                                        UseLayoutRounding="True" />
-
                                 <Border x:Name="PART_Border"
                                         HorizontalAlignment="Stretch"
                                         VerticalAlignment="Stretch"
                                         Background="{x:Null}"
-                                        BorderBrush="{TemplateBinding GlowBrush}"
+                                        BorderBrush="{TemplateBinding BorderBrush}"
                                         BorderThickness="{TemplateBinding BorderThickness}"
                                         UseLayoutRounding="True" />
 
@@ -45,13 +50,6 @@
                                             Visibility="Collapsed" />
                             </Grid>
                             <ControlTemplate.Triggers>
-                                <!--  handle active/inactive state  -->
-                                <Trigger Property="IsActive" Value="False">
-                                    <Setter TargetName="PART_Border" Property="BorderBrush" Value="{Binding Path=NonActiveGlowBrush, Mode=OneWay, RelativeSource={RelativeSource TemplatedParent}}" />
-                                </Trigger>
-                                <Trigger SourceName="PART_Border" Property="BorderBrush" Value="{x:Null}">
-                                    <Setter TargetName="PART_Border2" Property="BorderBrush" Value="Black" />
-                                </Trigger>
                                 <MultiTrigger>
                                     <MultiTrigger.Conditions>
                                         <Condition Property="Window.ResizeMode" Value="CanResizeWithGrip" />
@@ -81,10 +79,18 @@
                 </Style.Triggers>
             </Style>
 
-            <Style x:Key="NoneWindowStyle"
-                   BasedOn="{StaticResource {x:Type local:WindowChromeWindow}}"
-                   TargetType="{x:Type local:WindowChromeWindow}">
-                <Setter Property="WindowStyle" Value="None" />
+            <Style x:Key="WindowTitleBarButton"
+                   TargetType="Button">
+                <Style.Triggers>
+                    <Trigger Property="controlzEx:NonClientControlProperties.IsNCMouseOver" Value="true">
+                        <Setter Property="Background" Value="{StaticResource Button.MouseOver.Background}" />
+                        <Setter Property="BorderBrush" Value="{StaticResource Button.MouseOver.Border}" />
+                    </Trigger>
+                    <Trigger Property="controlzEx:NonClientControlProperties.IsNCPressed" Value="true">
+                        <Setter Property="Background" Value="{StaticResource Button.Pressed.Background}" />
+                        <Setter Property="BorderBrush" Value="{StaticResource Button.Pressed.Border}" />
+                    </Trigger>
+                </Style.Triggers>
             </Style>
         </ResourceDictionary>
     </Application.Resources>

diff --git a/src/ControlzEx.Showcase/Controls/UniformGridEx.cs b/src/ControlzEx.Showcase/Controls/UniformGridEx.cs
@@ -0,0 +1,233 @@
+namespace ControlzEx.Showcase
+{
+    using System;
+    using System.Windows;
+    using System.Windows.Controls;
+    using System.Windows.Media;
+
+    public class UniformGridEx : Panel
+    {
+        public static readonly DependencyProperty FirstColumnProperty = DependencyProperty.Register(nameof(FirstColumn), typeof(int), typeof(UniformGridEx), new FrameworkPropertyMetadata(0, FrameworkPropertyMetadataOptions.AffectsMeasure), ValidateFirstColumn);
+        public static readonly DependencyProperty ColumnsProperty = DependencyProperty.Register(nameof(Columns), typeof(int), typeof(UniformGridEx), new FrameworkPropertyMetadata(0, FrameworkPropertyMetadataOptions.AffectsMeasure), ValidateColumns);
+        public static readonly DependencyProperty RowsProperty = DependencyProperty.Register(nameof(Rows), typeof(int), typeof(UniformGridEx), new FrameworkPropertyMetadata(0, FrameworkPropertyMetadataOptions.AffectsMeasure), ValidateRows);
+        public static readonly DependencyProperty ShowGridLinesProperty = DependencyProperty.Register(nameof(ShowGridLines), typeof(bool), typeof(UniformGridEx), new FrameworkPropertyMetadata(false, OnShowGridLinesChanged));
+        public static readonly DependencyProperty GridLinesRendererProperty = DependencyProperty.Register(nameof(GridLinesRenderer), typeof(GridLinesRendererBase), typeof(UniformGridEx), new PropertyMetadata(default(UniformGridGridLinesRenderer), OnGridLinesRendererChanged));
+
+        private int columns;
+        private int rows;
+
+        public int FirstColumn
+        {
+            get => (int)this.GetValue(FirstColumnProperty);
+            set => this.SetValue(FirstColumnProperty, value);
+        }
+
+        public int Columns
+        {
+            get => (int)this.GetValue(ColumnsProperty);
+            set => this.SetValue(ColumnsProperty, value);
+        }
+
+        public int Rows
+        {
+            get => (int)this.GetValue(RowsProperty);
+            set => this.SetValue(RowsProperty, value);
+        }
+
+        public bool ShowGridLines
+        {
+            get => (bool)this.GetValue(ShowGridLinesProperty);
+            set => this.SetValue(ShowGridLinesProperty, value);
+        }
+
+        public GridLinesRendererBase GridLinesRenderer
+        {
+            get => (GridLinesRendererBase)this.GetValue(GridLinesRendererProperty);
+            set => this.SetValue(GridLinesRendererProperty, value);
+        }
+
+        protected override int VisualChildrenCount => base.VisualChildrenCount + (this.GridLinesRenderer is not null ? 1 : 0);
+
+        private static bool ValidateFirstColumn(object o)
+        {
+            return (int)o >= 0;
+        }
+
+        private static bool ValidateColumns(object o)
+        {
+            return (int)o >= 0;
+        }
+
+        private static bool ValidateRows(object o)
+        {
+            return (int)o >= 0;
+        }
+
+        protected override Visual GetVisualChild(int index)
+        {
+            if (index != base.VisualChildrenCount)
+            {
+                return base.GetVisualChild(index);
+            }
+
+            return this.GridLinesRenderer is not null
+                ? (Visual)this.GridLinesRenderer
+                : throw new ArgumentOutOfRangeException(nameof(index), index, null);
+        }
+
+        protected override Size MeasureOverride(Size constraint)
+        {
+            this.UpdateComputedValues();
+
+            var availableSize = new Size(constraint.Width / this.columns, constraint.Height / this.rows);
+            var minChildWidth = 0.0;
+            var minChildHeight = 0.0;
+            var index = 0;
+
+            for (var count = this.InternalChildren.Count; index < count; ++index)
+            {
+                var internalChild = this.InternalChildren[index];
+                internalChild.Measure(availableSize);
+                var desiredSize = internalChild.DesiredSize;
+
+                if (minChildWidth < desiredSize.Width)
+                {
+                    minChildWidth = desiredSize.Width;
+                }
+
+                if (minChildHeight < desiredSize.Height)
+                {
+                    minChildHeight = desiredSize.Height;
+                }
+            }
+
+            return new Size(minChildWidth * this.columns, minChildHeight * this.rows);
+        }
+
+        protected override Size ArrangeOverride(Size arrangeSize)
+        {
+            var finalRect = new Rect(0.0, 0.0, arrangeSize.Width / this.columns, arrangeSize.Height / this.rows);
+            var columnWidth = finalRect.Width;
+            var rowHeight = finalRect.Height;
+            var adjustedWidth = arrangeSize.Width - 1.0;
+
+            finalRect.X += finalRect.Width * this.FirstColumn;
+
+            foreach (UIElement internalChild in this.InternalChildren)
+            {
+                internalChild.Arrange(finalRect);
+
+                if (internalChild.Visibility != Visibility.Collapsed)
+                {
+                    finalRect.X += columnWidth;
+
+                    if (finalRect.X >= adjustedWidth)
+                    {
+                        finalRect.Y += finalRect.Height;
+                        finalRect.X = 0.0;
+                    }
+                }
+            }
+
+            this.EnsureGridLinesRenderer()?.UpdateRenderBounds(arrangeSize, this.columns, columnWidth, this.rows, rowHeight);
+
+            return arrangeSize;
+        }
+
+        private void UpdateComputedValues()
+        {
+            this.columns = this.Columns;
+            this.rows = this.Rows;
+
+            if (this.FirstColumn >= this.columns)
+            {
+                this.FirstColumn = 0;
+            }
+
+            if (this.rows != 0
+                && this.columns != 0)
+            {
+                return;
+            }
+
+            var visibleChildrenCount = 0;
+            var index = 0;
+            for (var count = this.InternalChildren.Count; index < count; ++index)
+            {
+                if (this.InternalChildren[index].Visibility != Visibility.Collapsed)
+                {
+                    ++visibleChildrenCount;
+                }
+            }
+
+            if (visibleChildrenCount == 0)
+            {
+                visibleChildrenCount = 1;
+            }
+
+            if (this.rows == 0)
+            {
+                if (this.columns > 0)
+                {
+                    this.rows = (visibleChildrenCount + this.FirstColumn + (this.columns - 1)) / this.columns;
+                }
+                else
+                {
+                    this.rows = (int)Math.Sqrt(visibleChildrenCount);
+                    if (this.rows * this.rows < visibleChildrenCount)
+                    {
+                        ++this.rows;
+                    }
+
+                    this.columns = this.rows;
+                }
+            }
+            else
+            {
+                if (this.columns != 0)
+                {
+                    return;
+                }
+
+                this.columns = (visibleChildrenCount + (this.rows - 1)) / this.rows;
+            }
+        }
+
+        private GridLinesRendererBase EnsureGridLinesRenderer()
+        {
+            if (this.ShowGridLines)
+            {
+                this.GridLinesRenderer ??= this.CreateGridLinesRenderer();
+
+                if (this.GridLinesRenderer.Parent != this)
+                {
+                    this.AddVisualChild(this.GridLinesRenderer);
+                }
+            }
+            else if (this.ShowGridLines == false
+                     && this.GridLinesRenderer is not null)
+            {
+                this.RemoveVisualChild(this.GridLinesRenderer);
+            }
+
+            return this.GridLinesRenderer;
+        }
+
+        protected virtual GridLinesRendererBase CreateGridLinesRenderer()
+        {
+            return new UniformGridGridLinesRenderer();
+        }
+
+        private static void OnShowGridLinesChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            var grid = (UniformGridEx)d;
+            grid.InvalidateVisual();
+        }
+
+        private static void OnGridLinesRendererChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            var grid = (UniformGridEx)d;
+            grid.InvalidateVisual();
+        }
+    }
+}