using System;
|
using System.Collections;
|
using System.Collections.ObjectModel;
|
using System.Collections.Specialized;
|
using System.ComponentModel;
|
using System.Data.Common;
|
using System.Globalization;
|
using System.Windows;
|
using System.Windows.Controls;
|
using System.Windows.Data;
|
using System.Windows.Media;
|
|
namespace UILib
|
{
|
public class TreeViewColumnWidthHelper
|
{
|
public static GridLength? GetAutoWidth(GridViewColumn column)
|
{
|
return (GridLength?)column.GetValue(AutoWidthProperty);
|
}
|
|
public static void SetAutoWidth(GridViewColumn column, GridLength? length)
|
{
|
column.SetValue(AutoWidthProperty, length);
|
}
|
|
public static readonly DependencyProperty AutoWidthProperty =
|
DependencyProperty.RegisterAttached("AutoWidth", typeof(GridLength?), typeof(GridViewColumn),
|
new PropertyMetadata(null));
|
}
|
|
public class SimpleTreeListViewButtonConverter : IMultiValueConverter
|
{
|
public static SimpleTreeListViewButtonConverter Instance = new SimpleTreeListViewButtonConverter();
|
public static readonly double sqrt2 = Math.Sqrt(2);
|
|
public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
|
{
|
if (values[0] is TreeListViewItem tlvi)
|
{
|
if (values[1] is int level && parameter.ToString() == "Size")
|
{
|
double BaseSize = (double)values[2];
|
return (level + 1) * BaseSize;
|
}
|
|
|
if (values[1] is int level1 && values[2] is int index
|
&& values[3] is bool IsExpanded
|
&& values[4] is bool IsLastNode
|
&& values[5] is bool HasItems && parameter.ToString() == "Content")
|
{
|
double BaseSize = (double)values[6];
|
double BaseHalfSize = BaseSize / 2;
|
double Length = BaseHalfSize + 1;
|
|
var res = new GeometryGroup()
|
{
|
FillRule = FillRule.Nonzero
|
};
|
if (level1 == 0)
|
{
|
// 画上面那根线
|
res.Children.Add(new LineGeometry
|
{
|
StartPoint = new Point((level1 * BaseSize) + BaseHalfSize, 0),
|
EndPoint = new Point((level1 * BaseSize) + BaseHalfSize, BaseHalfSize - (Length / 2)),
|
});
|
// 画右边那根线
|
res.Children.Add(new LineGeometry
|
{
|
StartPoint = new Point((level1 * BaseSize) + BaseHalfSize + (Length / 2), BaseHalfSize),
|
EndPoint = new Point((level1 * BaseSize) + BaseSize, BaseHalfSize),
|
});
|
}
|
else
|
{
|
// 画上面那根线
|
res.Children.Add(new LineGeometry
|
{
|
StartPoint = new Point((level1 * BaseSize) + BaseHalfSize, 0),
|
EndPoint = new Point((level1 * BaseSize) + BaseHalfSize, BaseHalfSize - (Length / 2)),
|
});
|
// 画右边那根线
|
res.Children.Add(new LineGeometry
|
{
|
StartPoint = new Point((level1 * BaseSize) + BaseHalfSize + (Length / 2), BaseHalfSize),
|
EndPoint = new Point((level1 * BaseSize) + BaseSize, BaseHalfSize),
|
});
|
|
var parent = tlvi.parent;
|
while (parent != null)
|
{
|
if (!parent.IsLastNode)
|
{
|
res.Children.Add(new LineGeometry
|
{
|
StartPoint = new Point((parent.level * BaseSize) + BaseHalfSize, 0),
|
EndPoint = new Point((parent.level * BaseSize) + BaseHalfSize, BaseSize),
|
});
|
}
|
parent = parent.parent;
|
}
|
}
|
|
if (!IsLastNode)
|
{
|
res.Children.Add(new LineGeometry
|
{
|
StartPoint = new Point((level1 * BaseSize) + BaseHalfSize, BaseHalfSize + (Length / 2)),
|
EndPoint = new Point((level1 * BaseSize) + BaseHalfSize, BaseSize),
|
});
|
}
|
|
|
if (HasItems)
|
{
|
//画方
|
res.Children.Add(new RectangleGeometry(new Rect((level1 * BaseSize) + ((BaseSize - Length) / 2), ((BaseSize - Length) / 2), Length, Length)));
|
|
res.Children.Add(new LineGeometry
|
{
|
StartPoint = new Point((level1 * BaseSize) + BaseHalfSize - (Length / 2),
|
BaseHalfSize),
|
EndPoint = new Point((level1 * BaseSize) + BaseHalfSize + (Length / 2), BaseHalfSize),
|
});
|
|
if (!IsExpanded)
|
{
|
res.Children.Add(new LineGeometry
|
{
|
StartPoint = new Point((level1 * BaseSize) + BaseHalfSize,
|
BaseHalfSize - (Length / 2)),
|
EndPoint = new Point((level1 * BaseSize) + BaseHalfSize,
|
BaseHalfSize + (Length / 2)),
|
});
|
}
|
}
|
else
|
{
|
if (!IsLastNode)
|
{
|
res.Children.Add(new LineGeometry
|
{
|
StartPoint = new Point((level1 * BaseSize) + BaseHalfSize, BaseHalfSize - (Length / 2)),
|
EndPoint = new Point((level1 * BaseSize) + BaseHalfSize, BaseHalfSize + (Length / 2)),
|
});
|
}
|
else
|
{
|
res.Children.Add(new LineGeometry
|
{
|
StartPoint = new Point((level1 * BaseSize) + BaseHalfSize, BaseHalfSize - (Length / 2)),
|
EndPoint = new Point((level1 * BaseSize) + BaseHalfSize, BaseHalfSize),
|
});
|
}
|
|
res.Children.Add(new LineGeometry
|
{
|
StartPoint = new Point((level1 * BaseSize) + BaseHalfSize, BaseHalfSize),
|
EndPoint = new Point((level1 * BaseSize) + BaseHalfSize + (Length / 2), BaseHalfSize),
|
});
|
}
|
tlvi.root.UpdateColumnsWidth();
|
return res;
|
}
|
}
|
return null;
|
}
|
|
public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
|
{
|
throw new NotImplementedException();
|
}
|
}
|
|
public class TreeListViewButtonConverter : IMultiValueConverter
|
{
|
public static TreeListViewButtonConverter Instance = new TreeListViewButtonConverter();
|
|
|
public static readonly double sqrt2 = Math.Sqrt(2);
|
|
public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
|
{
|
if (values[0] is TreeListViewItem tlvi)
|
{
|
if (values[1] is int level && parameter.ToString() == "Size")
|
{
|
double BaseSize = (double)values[2];
|
return (level + 1) * BaseSize;
|
}
|
|
if (parameter.ToString() == "Index")
|
{
|
|
int totalIndex = 1;
|
int Traverse(TreeListViewItem item)
|
{
|
if (item != tlvi)
|
{
|
totalIndex++;
|
foreach (var obj in item.Items)
|
{
|
var childItem = item.ItemContainerGenerator.ContainerFromItem(obj) as TreeListViewItem;
|
if (childItem != null)
|
return Traverse(childItem);
|
}
|
}
|
return totalIndex;
|
}
|
|
foreach (var obj in tlvi.root.Items)
|
{
|
var item_0 = tlvi.root.ItemContainerGenerator.ContainerFromItem(obj) as TreeListViewItem;
|
if (item_0 != null)
|
return Traverse(item_0);
|
}
|
return totalIndex;
|
}
|
|
|
if (values[1] is int level1 && values[2] is int index
|
&& values[3] is bool IsExpanded
|
&& values[4] is bool IsLastNode
|
&& values[5] is bool HasItems && parameter.ToString() == "Content")
|
{
|
double BaseSize = (double)values[6];
|
double BaseHalfSize = BaseSize / 2;
|
double Radius = BaseHalfSize *0.6;
|
var res = new GeometryGroup()
|
{
|
FillRule = FillRule.Nonzero
|
};
|
if (level1 == 0)
|
{
|
res.Children.Add(new LineGeometry
|
{
|
StartPoint = new Point((level1 * BaseSize) + BaseHalfSize, 0),
|
EndPoint = new Point((level1 * BaseSize) + BaseHalfSize, BaseHalfSize - Radius),
|
});
|
}
|
else
|
{
|
if (index == 0)
|
{
|
res.Children.Add(new LineGeometry
|
{
|
StartPoint = new Point((level1 * BaseSize), 0),
|
EndPoint = new Point((level1 * BaseSize) + (((sqrt2 * BaseHalfSize) - Radius) / sqrt2),
|
((sqrt2 * BaseHalfSize) - Radius) / sqrt2)
|
});
|
}
|
else
|
{
|
res.Children.Add(new LineGeometry
|
{
|
StartPoint = new Point((level1 * BaseSize) + BaseHalfSize, 0),
|
EndPoint = new Point((level1 * BaseSize) + BaseHalfSize, BaseHalfSize - Radius),
|
});
|
}
|
var parent = tlvi.parent;
|
while (parent != null)
|
{
|
if (!parent.IsLastNode)
|
{
|
res.Children.Add(new LineGeometry
|
{
|
StartPoint = new Point((parent.level * BaseSize) + BaseHalfSize, 0),
|
EndPoint = new Point((parent.level * BaseSize) + BaseHalfSize, BaseSize),
|
});
|
}
|
parent = parent.parent;
|
}
|
}
|
|
if (!IsLastNode)
|
{
|
res.Children.Add(new LineGeometry
|
{
|
StartPoint = new Point((level1 * BaseSize) + BaseHalfSize, BaseHalfSize + Radius),
|
EndPoint = new Point((level1 * BaseSize) + BaseHalfSize, BaseSize),
|
});
|
}
|
|
// 有子项并且是展开状态，统一画斜线
|
if (HasItems)
|
{
|
if (IsExpanded)
|
{
|
res.Children.Add(new LineGeometry
|
{
|
StartPoint = new Point((level1 * BaseSize) + BaseHalfSize + (((sqrt2 * BaseHalfSize) - Radius) / sqrt2),
|
BaseHalfSize + (((sqrt2 * BaseHalfSize) - Radius) / sqrt2)),
|
EndPoint = new Point((level1 + 1) * BaseSize, BaseSize),
|
});
|
}
|
}
|
|
//最后画圆
|
res.Children.Add(new EllipseGeometry
|
{
|
Center = new Point((level1 * BaseSize) + BaseHalfSize, BaseHalfSize),
|
RadiusX = Radius,
|
RadiusY = Radius,
|
|
});
|
|
if (HasItems)
|
{
|
res.Children.Add(new LineGeometry
|
{
|
StartPoint = new Point((level1 * BaseSize) + BaseHalfSize - Radius,
|
BaseHalfSize),
|
EndPoint = new Point((level1 * BaseSize) + BaseHalfSize + Radius, BaseHalfSize),
|
});
|
|
if (!IsExpanded)
|
{
|
res.Children.Add(new LineGeometry
|
{
|
StartPoint = new Point((level1 * BaseSize) + BaseHalfSize,
|
BaseHalfSize - Radius),
|
EndPoint = new Point((level1 * BaseSize) + BaseHalfSize,
|
BaseHalfSize + Radius),
|
});
|
}
|
}
|
tlvi.root.UpdateColumnsWidth();
|
return res;
|
}
|
}
|
return null;
|
}
|
|
public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
|
{
|
throw new NotImplementedException();
|
}
|
}
|
|
public class TreeListView : TreeView
|
{
|
public static readonly DependencyProperty ColumnsProperty =
|
DependencyProperty.Register("Columns", typeof(GridViewColumnCollection), typeof(TreeListView),
|
new PropertyMetadata(null));
|
|
public GridViewColumnCollection Columns
|
{
|
get { return (GridViewColumnCollection)GetValue(ColumnsProperty); }
|
set { SetValue(ColumnsProperty, value); }
|
}
|
|
public static readonly DependencyProperty ColumnHeaderContainerStyleProperty =
|
DependencyProperty.Register("ColumnHeaderContainerStyle", typeof(Style), typeof(TreeListView),
|
new PropertyMetadata(null));
|
|
public Style ColumnHeaderContainerStyle
|
{
|
get { return (Style)GetValue(ColumnHeaderContainerStyleProperty); }
|
set { SetValue(ColumnHeaderContainerStyleProperty, value); }
|
}
|
|
static TreeListView()
|
{
|
DefaultStyleKeyProperty.OverrideMetadata(typeof(TreeListView), new FrameworkPropertyMetadata(typeof(TreeListView)));
|
}
|
|
public TreeListView()
|
{
|
Columns = new GridViewColumnCollection();
|
}
|
|
internal void UpdateColumnsWidth()
|
{
|
int i = 0;
|
// foreach(var item in this.It)
|
|
foreach (GridViewColumn col in Columns)
|
{
|
var length = TreeViewColumnWidthHelper.GetAutoWidth(col);
|
if (length == null)
|
{
|
continue;
|
}
|
if (length.Value.GridUnitType == GridUnitType.Auto)
|
{
|
if (double.IsNaN(col.Width))
|
{
|
col.Width = col.ActualWidth;
|
}
|
col.Width = double.NaN;
|
}
|
}
|
}
|
|
public override void OnApplyTemplate()
|
{
|
base.OnApplyTemplate();
|
}
|
|
protected override void OnItemsChanged(NotifyCollectionChangedEventArgs e)
|
{
|
base.OnItemsChanged(e);
|
}
|
|
protected override void OnItemsSourceChanged(IEnumerable oldValue, IEnumerable newValue)
|
{
|
base.OnItemsSourceChanged(oldValue, newValue);
|
if (oldValue is INotifyCollectionChanged oncc)
|
{
|
oncc.CollectionChanged -= Nncc_CollectionChanged;
|
}
|
|
if (oldValue is INotifyPropertyChanged onpc)
|
{
|
onpc.PropertyChanged -= Nnpc_PropertyChanged;
|
}
|
|
|
if (newValue is INotifyCollectionChanged nncc)
|
{
|
nncc.CollectionChanged += Nncc_CollectionChanged;
|
}
|
|
if (newValue is INotifyPropertyChanged nnpc)
|
{
|
nnpc.PropertyChanged += Nnpc_PropertyChanged;
|
}
|
}
|
|
internal void UpdateChildrenUI()
|
{
|
if (ItemsSource is IEnumerable source)
|
{
|
foreach (var obj in source)
|
{
|
var sb = this.ItemContainerGenerator.ContainerFromItem(obj) as TreeListViewItem;
|
sb?.TryUpdateUI();
|
}
|
}
|
}
|
|
private void Nnpc_PropertyChanged(object sender, PropertyChangedEventArgs e)
|
{
|
//UpdateChildrenUI();
|
}
|
|
private void Nncc_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
|
{
|
UpdateChildrenUI();
|
}
|
|
protected override DependencyObject GetContainerForItemOverride()
|
{
|
return new TreeListViewItem(0, this, null);
|
}
|
}
|
|
public class TreeListViewItem : TreeViewItem, INotifyPropertyChanged
|
{
|
public static readonly DependencyProperty ColumnsProperty =
|
DependencyProperty.Register("Columns", typeof(GridViewColumnCollection), typeof(TreeListViewItem),
|
new PropertyMetadata(null));
|
|
public event PropertyChangedEventHandler PropertyChanged;
|
|
private int _totalIndex;
|
public int TotalIndex
|
{
|
get => _totalIndex;
|
set
|
{
|
if (_totalIndex != value)
|
{
|
_totalIndex = value;
|
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(TotalIndex)));
|
}
|
}
|
}
|
|
public int level
|
{
|
get
|
{
|
int i = 0;
|
var p = parent;
|
while (p != null)
|
{
|
i++;
|
p = p.parent;
|
}
|
return i;
|
}
|
}
|
|
public int index
|
{
|
get
|
{
|
return parent == null ? root.Items.IndexOf(this.DataContext) : parent.Items.IndexOf(this.DataContext);
|
}
|
}
|
|
public bool IsLastNode
|
{
|
get
|
{
|
return parent == null ? index == root.Items.Count - 1 : index == parent.Items.Count - 1;
|
}
|
}
|
|
public TreeListView root { get; private set; }
|
public TreeListViewItem parent { get; private set; }
|
|
public TreeListViewItem(int level, TreeListView root, TreeListViewItem parent)
|
{
|
this.IsExpanded = true;
|
this.root = root;
|
this.parent = parent;
|
this.Loaded += TreeListViewItem_Loaded;
|
}
|
|
private void TreeListViewItem_Loaded(object sender, RoutedEventArgs e)
|
{
|
|
}
|
|
protected override void OnItemsSourceChanged(IEnumerable oldValue, IEnumerable newValue)
|
{
|
base.OnItemsSourceChanged(oldValue, newValue);
|
if (oldValue is INotifyCollectionChanged oncc)
|
{
|
oncc.CollectionChanged -= Nncc_CollectionChanged;
|
}
|
|
if (oldValue is INotifyPropertyChanged onpc)
|
{
|
onpc.PropertyChanged -= Nnpc_PropertyChanged;
|
}
|
|
|
if (newValue is INotifyCollectionChanged nncc)
|
{
|
nncc.CollectionChanged += Nncc_CollectionChanged;
|
}
|
|
if (newValue is INotifyPropertyChanged nnpc)
|
{
|
nnpc.PropertyChanged += Nnpc_PropertyChanged;
|
}
|
}
|
|
protected override void OnItemsChanged(NotifyCollectionChangedEventArgs e)
|
{
|
base.OnItemsChanged(e);
|
}
|
|
private void Nnpc_PropertyChanged(object sender, PropertyChangedEventArgs e)
|
{
|
//root.UpdateChildrenUI();
|
}
|
|
private void Nncc_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
|
{
|
//root.UpdateChildrenUI();
|
TryUpdateUI();
|
}
|
|
internal void TryUpdateUI()
|
{
|
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(level)));
|
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(index)));
|
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(IsLastNode)));
|
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(HasItems)));
|
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(IsExpanded)));
|
if (ItemsSource is IEnumerable source)
|
{
|
foreach (var obj in source)
|
{
|
var sb = this.ItemContainerGenerator.ContainerFromItem(obj) as TreeListViewItem;
|
sb?.TryUpdateUI();
|
}
|
}
|
}
|
|
static TreeListViewItem()
|
{
|
DefaultStyleKeyProperty.OverrideMetadata(typeof(TreeListViewItem), new FrameworkPropertyMetadata(typeof(TreeListViewItem)));
|
}
|
|
protected override DependencyObject GetContainerForItemOverride()
|
{
|
return new TreeListViewItem(level + 1, root, this);
|
}
|
}
|
}
|
