From 9d1660270272180cd71147d6ddd53d1382643d2e Mon Sep 17 00:00:00 2001
From: wenxiangchao <wenxiangchao@ihengxin.com.cn>
Date: 星期一, 02 十一月 2026 18:00:14 +0800
Subject: [PATCH] merge: 并入远程 Initial commit 作为历史根节点
---
HMI.UI/DpUtil/UniformGridHelper.cs | 238 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 238 insertions(+), 0 deletions(-)
diff --git a/HMI.UI/DpUtil/UniformGridHelper.cs b/HMI.UI/DpUtil/UniformGridHelper.cs
new file mode 100644
index 0000000..1b12a2b
--- /dev/null
+++ b/HMI.UI/DpUtil/UniformGridHelper.cs
@@ -0,0 +1,238 @@
+锘縰sing System.Collections.Generic;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+using System.Windows.Media;
+
+namespace HMI.UI.DpUtil
+{
+ public class UniformGridHelper
+ {
+ public static double GetInnerBorder(DependencyObject obj)
+ {
+ return (double)obj.GetValue(InnerBorderProperty);
+ }
+
+ public static void SetInnerBorder(DependencyObject obj, object value)
+ {
+ double dv = double.Parse(value.ToString());
+ obj.SetValue(InnerBorderProperty, dv);
+ }
+
+ public static readonly DependencyProperty InnerBorderProperty =
+ DependencyProperty.RegisterAttached("InnerBorder", typeof(object), typeof(UniformGrid),
+ new PropertyMetadata(0, OnInnerBorderChanged));
+
+ public static Brush GetInnerBorderBrush(DependencyObject obj)
+ {
+ return (Brush)obj.GetValue(InnerBorderBrushProperty);
+ }
+ public static void SetInnerBorderBrush(DependencyObject obj, Brush value)
+ {
+ obj.SetValue(InnerBorderBrushProperty, value);
+ }
+ public static readonly DependencyProperty InnerBorderBrushProperty =
+ DependencyProperty.RegisterAttached("InnerBorderBrush", typeof(Brush), typeof(UniformGrid),
+ new PropertyMetadata(null, OnInnerBorderChanged));
+
+ public static string GetInnerBorderIgnore(DependencyObject obj)
+ {
+ return (string)obj.GetValue(InnerBorderIgnoreProperty);
+ }
+ public static void SetInnerBorderIgnore(DependencyObject obj, string value)
+ {
+ obj.SetValue(InnerBorderIgnoreProperty, value);
+ }
+
+ public static readonly DependencyProperty InnerBorderIgnoreProperty =
+ DependencyProperty.RegisterAttached("InnerBorderIgnore", typeof(string),
+ typeof(UniformGrid), new PropertyMetadata("None", OnInnerBorderChanged));
+
+ private static void OnInnerBorderChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+ {
+ if (d is UniformGrid grid)
+ {
+ if (e.Property == InnerBorderProperty || e.Property == InnerBorderIgnoreProperty)
+ {
+ grid.Loaded += GridInnerBorder_Loaded;
+ return;
+ }
+ }
+ }
+
+ private static void GridInnerBorder_Loaded(object sender, RoutedEventArgs e)
+ {
+ UniformGrid grid = sender as UniformGrid;
+ RefreshGridInnerBorder(grid);
+ grid.Loaded -= GridInnerBorder_Loaded;
+ }
+
+ public static void RefreshGridInnerBorder(UniformGrid grid)
+ {
+ double width = GetInnerBorder(grid);
+ if (width <= 0) return;
+ var rowCount = grid.Rows;
+ var columnCount = grid.Columns;
+ int totalCount = rowCount * columnCount;
+
+ string baseData = GetInnerBorderIgnore(grid);
+ HashSet<string> data = new HashSet<string>(baseData.Split(','));
+ bool ignoreTop = data.Contains("All") || data.Contains("Top"),
+ ignoreBottom = data.Contains("All") || data.Contains("Bottom"),
+ ignoreLeft = data.Contains("All") || data.Contains("Left"),
+ ignoreRight = data.Contains("All") || data.Contains("Right");
+
+ rowCount = (grid.Children.Count / columnCount)
+ + (grid.Children.Count % columnCount > 0 ? 1 : 0);
+ var brush = GetInnerBorderBrush(grid) ?? Brushes.Black;
+
+ for (int i = 0; i < grid.Children.Count; i++)
+ {
+ var child = grid.Children[i];
+
+ if (child is Control control)
+ {
+
+ int col = i % columnCount;
+ int row = i / columnCount;
+
+ double left = (col == 0 && ignoreLeft) ? 0 : width;
+ double top = (row == 0 && ignoreTop) ? 0 : width;
+
+ double right = ignoreRight ? 0 : ((col == columnCount - 1) ? width : 0);
+ double bottom = ignoreBottom ? 0 : ((row == rowCount - 1) ? width : 0);
+
+ var bt = new Thickness(left, top, right, bottom);
+
+ control.BorderBrush = brush;
+ control.BorderThickness = bt;
+ }
+
+ if (child is Border border)
+ {
+
+ int col = i % columnCount;
+ int row = i / columnCount;
+
+ double left = (col == 0 && ignoreLeft) ? 0 : width;
+ double top = (row == 0 && ignoreTop) ? 0 : width;
+
+ double right = ignoreRight ? 0 : ((col == columnCount - 1) ? width : 0);
+ double bottom = ignoreBottom ? 0 : ((row == rowCount - 1) ? width : 0);
+
+ var bt = new Thickness(left, top, right, bottom);
+
+ border.BorderBrush = brush;
+ border.BorderThickness = bt;
+ }
+
+ }
+ }
+
+ public static void RefreshLineSize(UniformGrid grid)
+ {
+ Thickness parentThickness = default;
+ Brush brush = default;
+ var parent = grid.Parent;
+ if (parent is System.Windows.Controls.Control parentControl)
+ {
+ parentThickness = parentControl.BorderThickness;
+ brush = parentControl.BorderBrush;
+ }
+ else if (parent is Border border)
+ {
+ parentThickness = border.BorderThickness;
+ brush = border.BorderBrush;
+ }
+
+ //var value = GetLineSize(grid);
+ //if (value == null) return;
+ //double size = (double)value;
+
+ int totalCount = grid.Children.Count;
+ var columnCount = grid.Columns;
+ int rowCount = grid.Rows;
+
+ for (int i = 0; i < totalCount; i++)
+ {
+ int row = i / columnCount;
+ int rest = i % columnCount;
+
+
+ var cell = grid.Children[i];
+
+ var bt = new Thickness(rest == 0 ? 0 : parentThickness.Left,
+ row == 0 ? 0 : parentThickness.Top,
+ rest == columnCount - 1 ? 0 : parentThickness.Right,
+ row == rowCount - 1 ? 0 : parentThickness.Bottom);
+
+ if (cell is Control child)
+ {
+ child.BorderThickness = bt;
+ child.BorderBrush = brush;
+ }
+ }
+ }
+
+ public static void RefreshDefault(UniformGrid grid, ControlTemplate template)
+ {
+ int totalCount = grid.Columns * grid.Rows;
+
+ int rest = totalCount - grid.Children.Count;
+ if (rest <= 0) return;
+
+ for (int i = 0; i < rest; i++)
+ {
+ var control = new Control
+ {
+ Template = template
+ };
+ grid.Children.Add(control);
+ }
+ }
+
+ public static ControlTemplate GetDefaultTemplate(DependencyObject obj)
+ {
+ return (ControlTemplate)obj.GetValue(DefaultTemplateProperty);
+ }
+ public static void SetDefaultTemplate(DependencyObject obj, ControlTemplate value)
+ {
+ obj.SetValue(DefaultTemplateProperty, value);
+ }
+ public static readonly DependencyProperty DefaultTemplateProperty =
+ DependencyProperty.RegisterAttached("DefaultTemplate", typeof(ControlTemplate), typeof(UniformGrid),
+ new PropertyMetadata(null, OnDefaultTemplateChanged));
+
+ private static void OnDefaultTemplateChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+ {
+ if (d is UniformGrid grid)
+ {
+ if (e.Property == DefaultTemplateProperty)
+ {
+ var tem = GetDefaultTemplate(grid);
+ if (tem == null) return;
+
+ //var rowCount = grid.Rows;
+ int columnCount = grid.Columns;
+ int totalCount = grid.Children.Count;
+ int rowCount = totalCount / columnCount;
+ int last = totalCount % columnCount;
+ if (last == 0)
+ {
+ return;
+ }
+ int addCount = columnCount - last;
+
+ for (int i = 0; i < addCount; i++)
+ {
+ Button u = new Button
+ {
+ Template = tem
+ };
+ grid.Children.Add(u);
+ }
+ }
+ }
+ }
+ }
+}
--
Gitblit v1.9.1