1535 lines
62 KiB
C#
1535 lines
62 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.Collections.Specialized;
|
|
using System.ComponentModel;
|
|
using System.Data;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Linq.Expressions;
|
|
using System.Windows;
|
|
using System.Windows.Controls;
|
|
using System.Windows.Controls.Primitives;
|
|
using System.Windows.Data;
|
|
using System.Windows.Input;
|
|
using System.Windows.Media;
|
|
using System.Xml.Serialization;
|
|
using ExtendedGrid.Base;
|
|
using ExtendedGrid.Classes;
|
|
using ExtendedGrid.Interface;
|
|
using Expression = System.Linq.Expressions.Expression;
|
|
using Path = System.Windows.Shapes.Path;
|
|
|
|
namespace ExtendedGrid.ExtendedGridControl
|
|
{
|
|
public sealed class ExtendedDataGrid : CopyDg, INotifyPropertyChanged
|
|
{
|
|
#region Members
|
|
|
|
private static readonly Uri DataGridUri = new Uri("/DataGridTransform;component/Styles/DataGrid.Generic.xaml",
|
|
UriKind.Relative);
|
|
|
|
private readonly ResourceDictionary _dataGridUriStyle = new ResourceDictionary {Source = DataGridUri};
|
|
|
|
private static readonly Uri DefaultThemeUri = new Uri("/DataGridTransform;component/DataGridThemes/Default.xaml",
|
|
UriKind.Relative);
|
|
|
|
private const string GenericThemeUri = "/DataGridTransform;component/DataGridThemes/{0}.xaml";
|
|
private readonly ResourceDictionary _defaultGridTheme = new ResourceDictionary {Source = DefaultThemeUri};
|
|
private DataTable _rowSummariesTable = new DataTable();
|
|
private ObservableCollection<GroupByData> _groupByCollection = new ObservableCollection<GroupByData>();
|
|
|
|
public const int Sum = 0;
|
|
public const int Average = 1;
|
|
public const int Count = 2;
|
|
public const int Min = 3;
|
|
public const int Max = 4;
|
|
public const int Smallest = 5;
|
|
public const int Largest = 6;
|
|
private ResourceDictionary _lastTheme;
|
|
internal List<DataGridColumn> ColumnsInGroupBy = new List<DataGridColumn>();
|
|
|
|
public enum Themes
|
|
{
|
|
Default,
|
|
Office2007Silver,
|
|
Office2007Black,
|
|
Office2007Blue,
|
|
Windows7,
|
|
OrangeDarkExplorer,
|
|
System,
|
|
ElectronicMedia
|
|
}
|
|
|
|
private bool _inWidthChange;
|
|
private bool _updatingColumnInfo;
|
|
|
|
public static readonly DependencyProperty ColumnInfoProperty = DependencyProperty.Register("ColumnInfo",
|
|
typeof (
|
|
ObservableCollection
|
|
<
|
|
ColumnInformation
|
|
>),
|
|
typeof (
|
|
ExtendedDataGrid),
|
|
new FrameworkPropertyMetadata
|
|
(null,
|
|
FrameworkPropertyMetadataOptions
|
|
.
|
|
BindsTwoWayByDefault,
|
|
ColumnInfoChangedCallback)
|
|
);
|
|
|
|
private int? _lastFrozenRowCount;
|
|
|
|
private readonly List<string> _computaions = new List<string>
|
|
{
|
|
"Sum",
|
|
"Average",
|
|
"Count",
|
|
"Min",
|
|
"Max",
|
|
"Smallest",
|
|
"Largest"
|
|
};
|
|
|
|
private readonly List<string> _summableComputaions = new List<string> {"Sum", "Average", "Count", "Min", "Max"};
|
|
private readonly List<string> _nonSummableComputaions = new List<string> {"Smallest", "Largest", "Count"};
|
|
private DataRow _draggedItem;
|
|
/// <summary>
|
|
/// Format of count on row summary
|
|
/// </summary>
|
|
public string RowSummaryCountFormat { get; set; }
|
|
/// <summary>
|
|
/// Format of sum on row summary
|
|
/// </summary>
|
|
public string RowSummarySumFormat { get; set; }
|
|
/// <summary>
|
|
/// Format of average on row summary
|
|
/// </summary>
|
|
public string RowSummaryAverageFormat { get; set; }
|
|
/// <summary>
|
|
/// Format of minimum on row summary
|
|
/// </summary>
|
|
public string RowSummaryMinFormat { get; set; }
|
|
/// <summary>
|
|
/// Format of maximum on row summary
|
|
/// </summary>
|
|
public string RowSummaryMaxFormat { get; set; }
|
|
/// <summary>
|
|
/// Format of smallest on row summary
|
|
/// </summary>
|
|
public string RowSummarySmallestFormat { get; set; }
|
|
/// <summary>
|
|
/// Format of largest on row summary
|
|
/// </summary>
|
|
public string RowSummaryLargestFormat { get; set; }
|
|
/// <summary>
|
|
/// If set to true will remove 3 state sorting
|
|
/// And it will revert to normal two state sorting
|
|
/// If set to true it will perform 3 state sorting
|
|
/// </summary>
|
|
public bool OnlyTwoWaySorting { get; set; }
|
|
|
|
#endregion
|
|
|
|
#region Constructors
|
|
|
|
public ExtendedDataGrid()
|
|
{
|
|
AddResources();
|
|
AutoFilterHelper = new AutoFilterHelper(this);
|
|
(Items.SortDescriptions as INotifyCollectionChanged).CollectionChanged += SortDescriptionsCollectionChanged;
|
|
Sorting += DataGridStandardSorting;
|
|
Loaded += ExtendedDataGridLoaded;
|
|
LoadingRow += ExtendedDataGridLoadingRow;
|
|
Columns.CollectionChanged += ColumnsCollectionChanged;
|
|
GroupByCollection.CollectionChanged += GroupByCollectionCollectionChanged;
|
|
GroupByColumnAdded += ExtendedDataGridGroupByColumnAdded;
|
|
GroupByColumnRemoved += ExtendedDataGridGroupByColumnRemoved;
|
|
PreviewKeyDown += ExtendedDataGridPreviewKeyDown;
|
|
RowHeaderChanged += ExtendedDataGridRowHeaderChanged;
|
|
FrozenColumnCountChanged += ExtendedDataGridFrozenColumnCountChanged;
|
|
MouseDown += ExtendedDataGridMouseDown;
|
|
for (int i = 0; i < 8; i++)
|
|
{
|
|
var row = RowSummariesTable.NewRow();
|
|
RowSummariesTable.Rows.Add(row);
|
|
}
|
|
NotifyPropertyChanged("RowSummariesTable");
|
|
//Group Style Start
|
|
var groupStyle = FindResource("CustomGroupStyle");
|
|
GroupStyle.Add((GroupStyle) groupStyle);
|
|
//Group Style End
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Events
|
|
/// <summary>
|
|
/// Event is fired when the Row header is changed
|
|
/// </summary>
|
|
public event EventHandler RowHeaderChanged;
|
|
/// <summary>
|
|
/// Frozen column count changed event
|
|
/// </summary>
|
|
public event EventHandler FrozenColumnCountChanged;
|
|
/// <summary>
|
|
/// Event is fired when any any column is added in group by
|
|
/// </summary>
|
|
public event EventHandler GroupByColumnAdded;
|
|
/// <summary>
|
|
/// Event is fired when any column is removed from group by
|
|
/// </summary>
|
|
public event EventHandler GroupByColumnRemoved;
|
|
public event PropertyChangedEventHandler PropertyChanged;
|
|
|
|
#endregion
|
|
|
|
#region Override
|
|
|
|
protected override void OnColumnReordered(DataGridColumnEventArgs e)
|
|
{
|
|
UpdateColumnInfo();
|
|
base.OnColumnReordered(e);
|
|
if (RowSummariesGrid != null)
|
|
{
|
|
//If columns are reordred its important to resorder row summaries if it exisi.
|
|
var rowSummariesColumn =
|
|
RowSummariesGrid.Columns.FirstOrDefault(column => column.SortMemberPath == e.Column.SortMemberPath);
|
|
if (rowSummariesColumn != null)
|
|
{
|
|
rowSummariesColumn.DisplayIndex = e.Column.DisplayIndex;
|
|
}
|
|
}
|
|
}
|
|
|
|
protected override void OnInitialized(EventArgs e)
|
|
{
|
|
EventHandler sortDirectionChangedHandler = (sender, x) => UpdateColumnInfo();
|
|
EventHandler widthPropertyChangedHandler = (sender, x) => _inWidthChange = true;
|
|
var sortDirectionPropertyDescriptor =
|
|
DependencyPropertyDescriptor.FromProperty(DataGridColumn.SortDirectionProperty, typeof (DataGridColumn));
|
|
var widthPropertyDescriptor = DependencyPropertyDescriptor.FromProperty(DataGridColumn.WidthProperty,
|
|
typeof (DataGridColumn));
|
|
|
|
Loaded += (sender, x) =>
|
|
{
|
|
foreach (var column in Columns)
|
|
{
|
|
sortDirectionPropertyDescriptor.AddValueChanged(column, sortDirectionChangedHandler);
|
|
widthPropertyDescriptor.AddValueChanged(column, widthPropertyChangedHandler);
|
|
}
|
|
};
|
|
Unloaded += (sender, x) =>
|
|
{
|
|
foreach (var column in Columns)
|
|
{
|
|
sortDirectionPropertyDescriptor.RemoveValueChanged(column,
|
|
sortDirectionChangedHandler);
|
|
widthPropertyDescriptor.RemoveValueChanged(column, widthPropertyChangedHandler);
|
|
}
|
|
};
|
|
|
|
base.OnInitialized(e);
|
|
}
|
|
|
|
protected override void OnItemsSourceChanged(IEnumerable oldValue, IEnumerable newValue)
|
|
{
|
|
base.OnItemsSourceChanged(oldValue, newValue);
|
|
CommitEdit();
|
|
CommitEdit();
|
|
|
|
foreach (var column in Columns)
|
|
{
|
|
var extendedColumn = column as IExtendedColumn;
|
|
if (extendedColumn != null)
|
|
{
|
|
GetSummaryValue(extendedColumn);
|
|
}
|
|
}
|
|
var cvs = CollectionViewSource.GetDefaultView(ItemsSource);
|
|
if (cvs != null)
|
|
cvs.GroupDescriptions.CollectionChanged +=
|
|
GroupDescriptionsCollectionChanged;
|
|
|
|
var scrollViewer = FindControls.FindChild<ScrollViewer>(this, "DG_ScrollViewer");
|
|
if (scrollViewer != null)
|
|
{
|
|
scrollViewer.ScrollToLeftEnd();
|
|
}
|
|
InvalidateArrange();
|
|
}
|
|
|
|
protected override void OnExecutedCommitEdit(ExecutedRoutedEventArgs e)
|
|
{
|
|
base.OnExecutedCommitEdit(e);
|
|
if (e.OriginalSource == null) return;
|
|
var extendedColumn = ((DataGridCell) e.OriginalSource).Column as IExtendedColumn;
|
|
if (extendedColumn != null)
|
|
GetSummaryValue(extendedColumn);
|
|
}
|
|
|
|
protected override void OnPropertyChanged(DependencyPropertyChangedEventArgs e)
|
|
{
|
|
base.OnPropertyChanged(e);
|
|
switch (e.Property.Name)
|
|
{
|
|
case "RowHeaderWidth":
|
|
if (RowHeaderChanged != null)
|
|
RowHeaderChanged(this, new EventArgs());
|
|
break;
|
|
case "FrozenColumnCount":
|
|
if (FrozenColumnCountChanged != null)
|
|
FrozenColumnCountChanged(this, new EventArgs());
|
|
break;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Methods
|
|
/// <summary>
|
|
/// THis helps to recompute the row summaries if the data is committed to the data grid
|
|
/// </summary>
|
|
public void FireNotifyForRowSummaries()
|
|
{
|
|
NotifyPropertyChanged("RowSummariesTable");
|
|
}
|
|
|
|
private void ExtendedDataGridMouseDown(object sender, MouseButtonEventArgs e)
|
|
{
|
|
if (e.ChangedButton == MouseButton.Right)
|
|
{
|
|
if (Columns.Count(c => c.Visibility == Visibility.Visible) == 0)
|
|
{
|
|
var cm = _dataGridUriStyle["DataGridHeaderColumnChooser"] as ContextMenu;
|
|
if (cm != null)
|
|
{
|
|
cm.Tag = this;
|
|
cm.IsOpen = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ExtendedDataGridFrozenColumnCountChanged(object sender, EventArgs e)
|
|
{
|
|
if (RowSummariesGrid != null)
|
|
{
|
|
RowSummariesGrid.FrozenColumnCount = FrozenColumnCount;
|
|
}
|
|
}
|
|
|
|
private void ExtendedDataGridRowHeaderChanged(object sender, EventArgs e)
|
|
{
|
|
ArrangeColumnSplitter();
|
|
}
|
|
|
|
private void ArrangeColumnSplitter()
|
|
{
|
|
var grid = this;
|
|
if ((!grid.ShowColumnSplitter || grid.FrozenColumnCount == 0))
|
|
return;
|
|
double tillNowWidth = 0;
|
|
if (GridSplitterGrid == null)
|
|
return;
|
|
var listOfColumn = Columns.ToList().OrderBy(c => c.DisplayIndex);
|
|
foreach (var column in listOfColumn)
|
|
{
|
|
if (column.Visibility == Visibility.Visible && column.DisplayIndex < FrozenColumnCount)
|
|
{
|
|
tillNowWidth = tillNowWidth + column.ActualWidth - 0.5;
|
|
}
|
|
}
|
|
GridSplitterGrid.ColumnDefinitions[0].Width = new GridLength(tillNowWidth + GetGridHeaderActualWidth(this));
|
|
}
|
|
|
|
private double GetGridHeaderActualWidth(DataGrid grid)
|
|
{
|
|
if (grid.HeadersVisibility == DataGridHeadersVisibility.None ||
|
|
grid.HeadersVisibility == DataGridHeadersVisibility.Column)
|
|
return 0;
|
|
return grid.RowHeaderWidth;
|
|
}
|
|
|
|
private void GroupDescriptionsCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
|
|
{
|
|
|
|
if (e.Action == NotifyCollectionChangedAction.Add)
|
|
{
|
|
foreach (var gc in e.NewItems)
|
|
{
|
|
var columnName = ((PropertyGroupDescription) gc).PropertyName;
|
|
var count = GroupByCollection.Count(g => g.SortMemberPath == columnName);
|
|
if (count == 0)
|
|
{
|
|
var column = Columns.FirstOrDefault(c => c.SortMemberPath == columnName);
|
|
if (column != null)
|
|
{
|
|
AddGroupByColumn(column, false);
|
|
if (ColumnsInGroupBy.Count(g => g.SortMemberPath == columnName) == 0)
|
|
{
|
|
ColumnsInGroupBy.Add(column);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (e.Action == NotifyCollectionChangedAction.Remove)
|
|
{
|
|
foreach (var gc in e.OldItems)
|
|
{
|
|
var columnName = ((PropertyGroupDescription) gc).PropertyName;
|
|
var count = GroupByCollection.Count(g => g.SortMemberPath == columnName);
|
|
if (count > 0)
|
|
{
|
|
var group = GroupByCollection.First(g => g.SortMemberPath == columnName);
|
|
GroupByCollection.Remove(group);
|
|
var column = ColumnsInGroupBy.First(c => c.SortMemberPath == columnName);
|
|
ColumnsInGroupBy.Remove(column);
|
|
var cvs = CollectionViewSource.GetDefaultView(ItemsSource);
|
|
if (cvs != null)
|
|
cvs.Refresh();
|
|
|
|
}
|
|
}
|
|
}
|
|
NotifyPropertyChanged("GroupByCollection");
|
|
}
|
|
|
|
private void ExtendedDataGridPreviewKeyDown(object sender, KeyEventArgs e)
|
|
{
|
|
|
|
if (!AllowUserToCopy)
|
|
{
|
|
if (e.Key == Key.C)
|
|
{
|
|
if (Keyboard.IsKeyDown(Key.LeftCtrl) || (Keyboard.IsKeyDown(Key.RightCtrl)))
|
|
{
|
|
e.Handled = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ExtendedDataGridGroupByColumnRemoved(object sender, EventArgs e)
|
|
{
|
|
var args = (GroupByEventArgs) e;
|
|
var columnName = args.Column.SortMemberPath;
|
|
var count = GroupByCollection.Count(gc => gc.SortMemberPath == columnName);
|
|
if (count <= 0) return;
|
|
var itemToBeRemoved = GroupByCollection.First(gc => gc.SortMemberPath == columnName);
|
|
GroupByCollection.Remove(itemToBeRemoved);
|
|
var itemToBeRemoved1 = ColumnsInGroupBy.First(gc => gc.SortMemberPath == columnName);
|
|
var index = ColumnsInGroupBy.IndexOf(itemToBeRemoved1);
|
|
var lastCount = ColumnsInGroupBy.Count;
|
|
ColumnsInGroupBy.Remove(itemToBeRemoved1);
|
|
if (ColumnsInGroupBy.Count == 0)
|
|
{
|
|
if (_lastFrozenRowCount != null && _lastFrozenRowCount != 0)
|
|
FrozenRowCount = _lastFrozenRowCount;
|
|
}
|
|
|
|
var cvs = CollectionViewSource.GetDefaultView(ItemsSource);
|
|
var propertyGroupDescription =
|
|
cvs.GroupDescriptions.Where(gd => ((PropertyGroupDescription) (gd)).PropertyName == columnName).Cast
|
|
<PropertyGroupDescription>().FirstOrDefault();
|
|
|
|
if (propertyGroupDescription == null) return;
|
|
cvs.GroupDescriptions.Remove(propertyGroupDescription);
|
|
cvs.Refresh();
|
|
if (index != lastCount - 1)
|
|
ArrangeGroupBy();
|
|
}
|
|
|
|
internal void ArrangeGroupBy()
|
|
{
|
|
|
|
var listOfDataGridColumn = (from item in GroupByCollection
|
|
let count = Columns.Count(c => c.SortMemberPath == item.SortMemberPath)
|
|
where count > 0
|
|
select Columns[GetColumnIndex(Columns, item.SortMemberPath)]).ToList();
|
|
GroupByCollection.Clear();
|
|
|
|
foreach (var column in listOfDataGridColumn)
|
|
{
|
|
AddGroupByColumn(column, false);
|
|
NotifyPropertyChanged("GroupByCollection");
|
|
}
|
|
}
|
|
|
|
private void AddGroupByColumn(DataGridColumn column, bool shouldAdd)
|
|
{
|
|
// If there is no drop target for a dragged column, don't allow grouping
|
|
if (GroupByControlVisibility == Visibility.Collapsed)
|
|
{
|
|
return;
|
|
}
|
|
IsGroupByOn = true;
|
|
var columnName = column.Header;
|
|
var count = GroupByCollection.Count(gc => Equals(gc.SortMemberPath, columnName));
|
|
if (count == 0)
|
|
{
|
|
var newItem = new GroupByData
|
|
{
|
|
ColumnName = (string) columnName,
|
|
Index = GroupByCollection.Count,
|
|
SortDirection = Convert.ToString(column.SortDirection),
|
|
SortMemberPath = column.SortMemberPath
|
|
};
|
|
|
|
var border = FindControls.FindChild<Border>(this, "");
|
|
var headerPanel = FindControls.FindChild<DockPanel>(border, "headerPanel");
|
|
var groupByContentControl = FindControls.FindChild<ContentControl>(headerPanel, "groupByContentControl");
|
|
var group = FindControls.FindChild<ItemsControl>(groupByContentControl, "group");
|
|
if (group != null) group.UpdateLayout();
|
|
if (GroupByCollection.Count > 0 && group != null)
|
|
{
|
|
newItem.GridWidth =
|
|
((ContentPresenter)
|
|
(@group.ItemContainerGenerator.ContainerFromIndex(GroupByCollection.Count - 1))).ActualWidth +
|
|
10;
|
|
newItem.GridSecondColumnWidth = (newItem.GridWidth -
|
|
GroupByCollection[GroupByCollection.Count - 1].GridWidth)/2;
|
|
}
|
|
|
|
if (GroupByCollection.Count == 0)
|
|
{
|
|
|
|
if (FrozenRowCount != null && FrozenRowCount != 0)
|
|
{
|
|
_lastFrozenRowCount = FrozenRowCount;
|
|
FrozenRowCount = 0;
|
|
}
|
|
|
|
}
|
|
GroupByCollection.Add(newItem);
|
|
|
|
if (!shouldAdd) return;
|
|
|
|
try
|
|
{
|
|
var cvs = CollectionViewSource.GetDefaultView(ItemsSource);
|
|
cvs.GroupDescriptions.Add(new PropertyGroupDescription(column.SortMemberPath));
|
|
|
|
cvs.Refresh();
|
|
}
|
|
catch (Exception)
|
|
{
|
|
GroupByCollection.Remove(newItem);
|
|
MessageBox.Show("Cannot group by when row is being edited.", "Error", MessageBoxButton.OK,
|
|
MessageBoxImage.Error);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void RaiseGroupByColumnRemoved(DataGridColumn column)
|
|
{
|
|
GroupByColumnRemoved(this, new GroupByEventArgs {Column = column});
|
|
}
|
|
|
|
private void AddTheme(Themes value)
|
|
{
|
|
if (!UriParser.IsKnownScheme("pack"))
|
|
UriParser.Register(new GenericUriParser(GenericUriParserOptions.GenericAuthority), "pack", -1);
|
|
|
|
//Remove last loaded themes
|
|
|
|
if (Resources.MergedDictionaries.Contains(_lastTheme))
|
|
Resources.MergedDictionaries.Remove(_lastTheme);
|
|
|
|
//Add new Theme
|
|
var newTheme = new ResourceDictionary { Source = new Uri(String.Format(GenericThemeUri, value.ToString()), UriKind.Relative) };
|
|
if (!Resources.MergedDictionaries.Contains(newTheme))
|
|
{
|
|
Resources.MergedDictionaries.Add(newTheme);
|
|
_lastTheme = newTheme;
|
|
}
|
|
|
|
}
|
|
private void GroupByCollectionCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
|
|
{
|
|
var border = FindControls.FindChild<Border>(this, "");
|
|
var headerPanel = FindControls.FindChild<DockPanel>(border, "headerPanel");
|
|
var groupByContentControl = FindControls.FindChild<ContentControl>(headerPanel, "groupByContentControl");
|
|
var txtDragName = FindControls.FindChild<TextBlock>(groupByContentControl, "txtDragName");
|
|
var clearButton = FindControls.FindChild<Button>(groupByContentControl, "btnClearGroup");
|
|
if (txtDragName != null)
|
|
txtDragName.Visibility = GroupByCollection.Count == 0 ? Visibility.Visible : Visibility.Collapsed;
|
|
if (clearButton != null)
|
|
clearButton.Visibility = GroupByCollection.Count != 0 ? Visibility.Visible : Visibility.Collapsed;
|
|
}
|
|
|
|
private void ExtendedDataGridGroupByColumnAdded(object sender, EventArgs e)
|
|
{
|
|
var args = e as GroupByEventArgs;
|
|
if (args != null)
|
|
AddGroupByColumn(args.Column, true);
|
|
}
|
|
|
|
public void UpdateRowSummaries()
|
|
{
|
|
foreach (var column in Columns)
|
|
{
|
|
GetSummaryValue((IExtendedColumn) column);
|
|
}
|
|
}
|
|
|
|
private void GetSummaryValue(IExtendedColumn column)
|
|
{
|
|
|
|
if (!ShowRowSummaries) return;
|
|
if (Columns.Count == 0) return;
|
|
var dataView = ItemsSource as DataView;
|
|
if (dataView != null)
|
|
{
|
|
if (((DataView) ItemsSource).Count == 0) return;
|
|
var type =
|
|
((DataView) ItemsSource).Table.Columns[((DataGridColumn) column).SortMemberPath].DataType;
|
|
var isSummable = IsSummable(type);
|
|
var columnName = ((DataGridColumn) column).SortMemberPath;
|
|
if (isSummable)
|
|
{
|
|
foreach (var computation in _summableComputaions)
|
|
{
|
|
if (
|
|
(!String.IsNullOrEmpty(
|
|
Convert.ToString(
|
|
RowSummariesTable.Rows[_computaions.IndexOf(computation)][
|
|
((DataGridColumn) column).SortMemberPath])) ||
|
|
(column.SummaryColumnSettings != null &&
|
|
column.SummaryColumnSettings.SummaryOperands.Count(so => so.Operation == computation) > 0)))
|
|
RowSummariesTable.Rows[_computaions.IndexOf(computation)][
|
|
columnName] =
|
|
GetRowSummariesValue(computation,
|
|
columnName);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
foreach (var computation in _nonSummableComputaions)
|
|
if (
|
|
column != null && (!String.IsNullOrEmpty(
|
|
Convert.ToString(
|
|
RowSummariesTable.Rows[_computaions.IndexOf(computation)][
|
|
columnName])) ||
|
|
(column.SummaryColumnSettings != null &&
|
|
column.SummaryColumnSettings.SummaryOperands.Count(
|
|
so => so.Operation == computation) > 0)))
|
|
RowSummariesTable.Rows[_computaions.IndexOf(computation)][
|
|
columnName] =
|
|
GetRowSummariesValue(computation,
|
|
columnName);
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool IsSummable(Type type)
|
|
{
|
|
try
|
|
{
|
|
ParameterExpression paramA = Expression.Parameter(type, "a");
|
|
ParameterExpression paramB = Expression.Parameter(type, "b");
|
|
BinaryExpression addExpression = Expression.Add(paramA, paramB);
|
|
var add = Expression.Lambda(addExpression, paramA, paramB).Compile();
|
|
var v = Activator.CreateInstance(type);
|
|
add.DynamicInvoke(v, v);
|
|
return true;
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
internal void DefaultViewListChanged(object sender, ListChangedEventArgs e)
|
|
{
|
|
LoadRowSummaries();
|
|
}
|
|
|
|
internal void LoadRowSummaries()
|
|
{
|
|
NotifyPropertyChanged("RowSummariesTable");
|
|
}
|
|
|
|
private object GetRowSummariesValue(string computation, string columnName)
|
|
{
|
|
|
|
object value = "";
|
|
var dataView = ItemsSource as DataView;
|
|
if (dataView != null)
|
|
{
|
|
var itemSourceDataTable = dataView.Table;
|
|
var currentColumnName = columnName;
|
|
object actualValue;
|
|
switch (computation)
|
|
{
|
|
case "Count":
|
|
|
|
value = itemSourceDataTable.Rows.Count;
|
|
break;
|
|
case "Sum":
|
|
actualValue = itemSourceDataTable.Compute("Sum(" + currentColumnName + ")", "");
|
|
if (actualValue != DBNull.Value)
|
|
value = Convert.ToDouble(itemSourceDataTable.Compute("Sum(" + currentColumnName + ")", ""));
|
|
|
|
break;
|
|
case "Average":
|
|
actualValue = itemSourceDataTable.Compute("Avg(" + currentColumnName + ")", "");
|
|
if (actualValue != DBNull.Value)
|
|
value = Convert.ToDouble(itemSourceDataTable.Compute("Avg(" + currentColumnName + ")", ""));
|
|
break;
|
|
case "Min":
|
|
actualValue = itemSourceDataTable.Compute("Min(" + currentColumnName + ")", "");
|
|
if (actualValue != DBNull.Value)
|
|
value = Convert.ToDouble(itemSourceDataTable.Compute("Min(" + currentColumnName + ")", ""));
|
|
break;
|
|
case "Max":
|
|
actualValue = itemSourceDataTable.Compute("Max(" + currentColumnName + ")", "");
|
|
if (actualValue != DBNull.Value)
|
|
value = Convert.ToDouble(itemSourceDataTable.Compute("Max(" + currentColumnName + ")", ""));
|
|
break;
|
|
case "Smallest":
|
|
var lengthOfCells =
|
|
(from DataRow row in itemSourceDataTable.Rows
|
|
select Convert.ToString(row[currentColumnName]).Length).ToList();
|
|
var minValue = "";
|
|
foreach (
|
|
var row in
|
|
itemSourceDataTable.Rows.Cast<DataRow>().Where(
|
|
row => Convert.ToString(row[currentColumnName]).Length == lengthOfCells.Min()))
|
|
{
|
|
minValue = Convert.ToString(row[currentColumnName]);
|
|
|
|
break;
|
|
}
|
|
|
|
if (lengthOfCells.Count > 0)
|
|
{
|
|
|
|
value = minValue;
|
|
}
|
|
|
|
break;
|
|
case "Largest":
|
|
|
|
var lengthOfCells1 =
|
|
(from DataRow row in itemSourceDataTable.Rows
|
|
select Convert.ToString(row[currentColumnName]).Length).ToList();
|
|
var maxValue = "";
|
|
foreach (
|
|
var row in
|
|
itemSourceDataTable.Rows.Cast<DataRow>().Where(
|
|
row => Convert.ToString(row[currentColumnName]).Length == lengthOfCells1.Max()))
|
|
{
|
|
maxValue = Convert.ToString(row[currentColumnName]);
|
|
break;
|
|
}
|
|
|
|
if (lengthOfCells1.Count > 0)
|
|
{
|
|
|
|
value = maxValue;
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
return "";
|
|
}
|
|
}
|
|
if (String.IsNullOrEmpty(Convert.ToString(value)))
|
|
value = " ";
|
|
return value;
|
|
}
|
|
|
|
internal DataGridColumn GetRowSummariesGridColumnForSortMemberPath(string sortMemberPath)
|
|
{
|
|
if (RowSummariesGrid != null)
|
|
return RowSummariesGrid.Columns.FirstOrDefault(column => column.SortMemberPath == sortMemberPath);
|
|
return null;
|
|
}
|
|
|
|
private void ColumnsCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
|
|
{
|
|
if (e.NewItems == null)
|
|
return;
|
|
switch (e.Action)
|
|
{
|
|
case NotifyCollectionChangedAction.Add:
|
|
foreach (var column in e.NewItems)
|
|
{
|
|
if (!RowSummariesTable.Columns.Contains(((DataGridColumn) column).SortMemberPath))
|
|
{
|
|
RowSummariesTable.Columns.Add(((DataGridColumn) column).SortMemberPath);
|
|
if (RowSummariesGrid != null)
|
|
{
|
|
var oldColumn =
|
|
GetRowSummariesGridColumnForSortMemberPath(((DataGridColumn) column).SortMemberPath);
|
|
if (oldColumn == null)
|
|
RowSummariesGrid.Columns.Add(new DataGridTextColumn
|
|
{
|
|
SortMemberPath =
|
|
((DataGridColumn) column).SortMemberPath,
|
|
DisplayIndex =
|
|
((DataGridColumn) column).DisplayIndex,
|
|
Visibility =
|
|
((DataGridColumn) column).Visibility,
|
|
Width = ((DataGridColumn) column).Width
|
|
});
|
|
|
|
}
|
|
}
|
|
var actualColumn =
|
|
column as IExtendedColumn;
|
|
if (actualColumn != null)
|
|
GetSummaryValue(actualColumn);
|
|
}
|
|
break;
|
|
case NotifyCollectionChangedAction.Remove:
|
|
foreach (var column in e.NewItems)
|
|
{
|
|
if (RowSummariesTable.Columns.Contains(((DataGridColumn) column).SortMemberPath))
|
|
{
|
|
RowSummariesTable.Columns.Remove(((DataGridColumn) column).SortMemberPath);
|
|
if (RowSummariesGrid != null)
|
|
{
|
|
var rowSummariesColumn =
|
|
GetRowSummariesGridColumnForSortMemberPath(((DataGridColumn) column).SortMemberPath);
|
|
if (rowSummariesColumn != null)
|
|
{
|
|
var oldColumn =
|
|
GetRowSummariesGridColumnForSortMemberPath(
|
|
((DataGridColumn) column).SortMemberPath);
|
|
if (oldColumn != null)
|
|
RowSummariesGrid.Columns.Remove(rowSummariesColumn);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case NotifyCollectionChangedAction.Replace:
|
|
{
|
|
var newColumns = e.NewItems;
|
|
foreach (var column in e.OldItems)
|
|
{
|
|
if (RowSummariesTable.Columns.Contains(((DataGridColumn) column).SortMemberPath))
|
|
{
|
|
var oldColumn = RowSummariesTable.Columns[((DataGridColumn) column).SortMemberPath];
|
|
if (oldColumn != null)
|
|
{
|
|
oldColumn.ColumnName =
|
|
(string) ((DataGridColumn) newColumns[e.OldItems.IndexOf(column)]).Header;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
NotifyPropertyChanged("RowSummariesTable");
|
|
LoadRowSummaries();
|
|
}
|
|
|
|
private void ExtendedDataGridLoadingRow(object sender, DataGridRowEventArgs e)
|
|
{
|
|
|
|
if (IsGroupByOn)
|
|
return;
|
|
if (IsVerticalScrolling)
|
|
return;
|
|
if (ShowRowNumber)
|
|
{
|
|
var formattedText = new FormattedText((e.Row.GetIndex() + 1).ToString(CultureInfo.InvariantCulture),
|
|
CultureInfo.GetCultureInfo("en-us"),
|
|
FlowDirection.LeftToRight,
|
|
new Typeface("Arial"), FontSize = 9, Brushes.Black);
|
|
double textWidth = formattedText.Width*72/96;
|
|
if (textWidth > RowHeaderActualWidth && textWidth > 17)
|
|
{
|
|
RowHeaderWidth = textWidth + 2;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
e.Row.Header = " ";
|
|
if (Double.IsNaN(RowHeaderWidth))
|
|
RowHeaderWidth = 17;
|
|
}
|
|
NotifyPropertyChanged("RowSummariesTable");
|
|
}
|
|
|
|
private void ExtendedDataGridLoaded(object sender, RoutedEventArgs e)
|
|
{
|
|
var scrollViewer = FindControls.FindChild<ScrollViewer>(this, "DG_ScrollViewer");
|
|
if (scrollViewer != null)
|
|
{
|
|
ScrollingPreviewService.OnVerticalScrollingPreviewTemplateChanged(scrollViewer,
|
|
ScrollToolTipDataTemplate);
|
|
}
|
|
NotifyPropertyChanged("RowSummariesTable");
|
|
LoadRowSummaries();
|
|
GroupByHeaderText = GroupByHeaderText;
|
|
if (ShowRowNumber)
|
|
DataGridBehavior.SetRowNumber(this, true);
|
|
var grpContentCtrl = GetGroupByContentControl();
|
|
if (grpContentCtrl != null)
|
|
{
|
|
grpContentCtrl.SizeChanged += GrpContentCtrlSizeChanged;
|
|
}
|
|
}
|
|
|
|
private void GrpContentCtrlSizeChanged(object sender, SizeChangedEventArgs e)
|
|
{
|
|
IsGroupByOn = false;
|
|
}
|
|
|
|
private ContentControl GetGroupByContentControl()
|
|
{
|
|
try
|
|
{
|
|
var border = FindControls.FindChild<Border>(this, "");
|
|
var headerPanel = FindControls.FindChild<DockPanel>(border, "headerPanel");
|
|
var groupByContentControl = FindControls.FindChild<ContentControl>(headerPanel, "groupByContentControl");
|
|
return groupByContentControl;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private void NotifyPropertyChanged(String info)
|
|
{
|
|
if (PropertyChanged != null)
|
|
{
|
|
PropertyChanged(this, new PropertyChangedEventArgs(info));
|
|
}
|
|
}
|
|
|
|
private void AddResources()
|
|
{
|
|
if (!UriParser.IsKnownScheme("pack"))
|
|
UriParser.Register(new GenericUriParser(GenericUriParserOptions.GenericAuthority), "pack", -1);
|
|
//Data grid
|
|
if (!Resources.MergedDictionaries.Contains(_dataGridUriStyle))
|
|
Resources.MergedDictionaries.Add(_dataGridUriStyle);
|
|
//Themes Default
|
|
if (!Resources.MergedDictionaries.Contains(_defaultGridTheme))
|
|
Resources.MergedDictionaries.Add(_defaultGridTheme);
|
|
_lastTheme = _defaultGridTheme;
|
|
}
|
|
/// <summary>
|
|
/// Clears the filter was specified column
|
|
/// </summary>
|
|
/// <param name="columnName"></param>
|
|
public void ClearFilter(string columnName)
|
|
{
|
|
AutoFilterHelper.RemoveAllFilter(this, columnName);
|
|
DataGridColumnHeader header =
|
|
FindControls.GetColumnHeaderFromColumn(Columns[GetColumnIndex(Columns, columnName)], this);
|
|
if (header != null)
|
|
{
|
|
var popUp = FindControls.FindChild<Popup>(header, "popupDrag");
|
|
if (popUp != null)
|
|
{
|
|
popUp.Tag = "False";
|
|
}
|
|
}
|
|
}
|
|
|
|
private static int GetColumnIndex(IEnumerable<DataGridColumn> columns, string filedName)
|
|
{
|
|
int index = 0;
|
|
foreach (DataGridColumn col in columns)
|
|
{
|
|
if (col.SortMemberPath == filedName)
|
|
{
|
|
return index;
|
|
}
|
|
index++;
|
|
}
|
|
return index;
|
|
}
|
|
/// <summary>
|
|
/// Export to excel
|
|
/// </summary>
|
|
/// <param name="workSheetName">Name you want in first sheet</param>
|
|
/// <param name="fullFilePath">Path where you need to save the excel file</param>
|
|
/// <param name="toOpen">Show open or not after creation</param>
|
|
public void ExportToExcel(string workSheetName, string fullFilePath, bool toOpen)
|
|
{
|
|
try
|
|
{
|
|
//Select all rows
|
|
Focus();
|
|
SelectAll();
|
|
//Copy the entire grid
|
|
ClipboardCopyMode = DataGridClipboardCopyMode.IncludeHeader;
|
|
ApplicationCommands.Copy.Execute(null, this);
|
|
Clipboard.GetText();
|
|
//ExportToExcelService.CreateExcelFromClipboard(workSheetName, fullFilePath, toOpen);
|
|
UnselectAll();
|
|
}
|
|
catch (Exception)
|
|
{
|
|
UnselectAll();
|
|
throw;
|
|
}
|
|
|
|
}
|
|
/// <summary>
|
|
/// Export to PDF
|
|
/// </summary>
|
|
/// <param name="fullFilePath">Path where you need to save the pdf file</param>
|
|
/// <param name="toOpen">Show open or not after creation</param>
|
|
public void ExportToPdf(string fullFilePath, bool toOpen)
|
|
{
|
|
try
|
|
{
|
|
//Select all rows
|
|
Focus();
|
|
SelectAll();
|
|
//Copy the entire grid
|
|
ClipboardCopyMode = DataGridClipboardCopyMode.IncludeHeader;
|
|
ApplicationCommands.Copy.Execute(null, this);
|
|
Clipboard.GetText();
|
|
//ExportToExcelService.CreatePdfFromClipboard("PDF", fullFilePath, toOpen);
|
|
UnselectAll();
|
|
}
|
|
catch (Exception)
|
|
{
|
|
UnselectAll();
|
|
throw;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Export to PDF
|
|
/// </summary>
|
|
/// <param name="fullFilePath">Path where you need to save the pdf file</param>
|
|
/// <param name="tableStyle">It is excel style you want to export</param>
|
|
/// <param name="toOpen">Show open or not after creation</param>
|
|
//public void ExportToPdf(string fullFilePath, bool toOpen)
|
|
//{
|
|
// try
|
|
// {
|
|
// //Select all rows
|
|
// Focus();
|
|
// SelectAll();
|
|
// //Copy the entire grid
|
|
// ClipboardCopyMode = DataGridClipboardCopyMode.IncludeHeader;
|
|
// ApplicationCommands.Copy.Execute(null, this);
|
|
// Clipboard.GetText();
|
|
// //ExportToExcelService.CreatePdfFromClipboard("PDF", fullFilePath, tableStyle, toOpen);
|
|
// UnselectAll();
|
|
// }
|
|
// catch (Exception)
|
|
// {
|
|
// UnselectAll();
|
|
// throw;
|
|
// }
|
|
//}
|
|
/// <summary>
|
|
/// Export to Csv
|
|
/// </summary>
|
|
/// <param name="workSheetName">Name of the first sheet</param>
|
|
/// <param name="fullFilePath">Path where csv file is supposed to be saved</param>
|
|
/// <param name="toOpen">To open or not after creation of csv file</param>
|
|
public void ExportToCsv(string workSheetName, string fullFilePath, bool toOpen)
|
|
{
|
|
try
|
|
{
|
|
//Select all rows
|
|
Focus();
|
|
SelectAll();
|
|
//Copy the entire grid
|
|
ClipboardCopyMode = DataGridClipboardCopyMode.IncludeHeader;
|
|
ApplicationCommands.Copy.Execute(null, this);
|
|
Clipboard.GetText();
|
|
//ExportToExcelService.CreateCsvFromClipboard(workSheetName, fullFilePath, toOpen);
|
|
UnselectAll();
|
|
}
|
|
catch (Exception)
|
|
{
|
|
UnselectAll();
|
|
throw;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Export to excel
|
|
/// </summary>
|
|
/// <param name="workSheetName">Sheet of the first sheet</param>
|
|
/// <param name="fullFilePath">Path where is it is supposed to be saved</param>
|
|
/// <param name="tableStyle">Style of excel you want to create</param>
|
|
/// <param name="toOpen">To open or not after creation</param>
|
|
//public void ExportToExcel(string workSheetName, string fullFilePath, bool toOpen)
|
|
//{
|
|
// try
|
|
// {
|
|
// //Select all rows
|
|
// Focus();
|
|
// SelectAll();
|
|
// //Copy the entire grid
|
|
// ClipboardCopyMode = DataGridClipboardCopyMode.IncludeHeader;
|
|
// ApplicationCommands.Copy.Execute(null, this);
|
|
// Clipboard.GetText();
|
|
// //ExportToExcelService.CreateExcelFromClipboard(workSheetName, fullFilePath, tableStyle, toOpen);
|
|
// UnselectAll();
|
|
// }
|
|
// catch (Exception)
|
|
// {
|
|
// UnselectAll();
|
|
// throw;
|
|
// }
|
|
//}
|
|
|
|
internal void RaiseGroupByColumnAdded(DataGridColumn column)
|
|
{
|
|
if (GroupByColumnAdded != null)
|
|
GroupByColumnAdded(this, new GroupByEventArgs {Column = column});
|
|
}
|
|
|
|
private static void ColumnInfoChangedCallback(DependencyObject dependencyObject,
|
|
DependencyPropertyChangedEventArgs e)
|
|
{
|
|
var grid = (ExtendedDataGrid) dependencyObject;
|
|
if (!grid._updatingColumnInfo)
|
|
{
|
|
grid.ColumnInfoChanged();
|
|
}
|
|
}
|
|
|
|
private void SortDescriptionsCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
|
|
{
|
|
// clear all the headers of sort order
|
|
foreach (DataGridColumn column in Columns)
|
|
{
|
|
string sortPath = SortHelpers.GetSortMemberPath(column);
|
|
if (sortPath != null)
|
|
{
|
|
var sortOrder1 = new Path();
|
|
DataGridColumnHeader header = FindControls.GetColumnHeaderFromColumn(column, this);
|
|
if (header != null)
|
|
{
|
|
var popUp = FindControls.FindChild<Popup>(header, "popupDrag");
|
|
if (popUp != null)
|
|
{
|
|
sortOrder1 = FindControls.FindChild<Path>(header, "SortArrow");
|
|
}
|
|
if (sortOrder1 != null)
|
|
{
|
|
sortOrder1.Tag = null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// add sort order
|
|
int sortIndex = 0;
|
|
foreach (SortDescription sortDesc in Items.SortDescriptions)
|
|
{
|
|
sortIndex++;
|
|
var sortOrder = new Path();
|
|
var txtSortOrder = new TextBlock();
|
|
|
|
DataGridColumnHeader header =
|
|
FindControls.GetColumnHeaderFromColumn(Columns[GetColumnIndex(Columns, sortDesc.PropertyName)], this);
|
|
if (header != null)
|
|
{
|
|
var popUp = FindControls.FindChild<Popup>(header, "popupDrag");
|
|
if (popUp != null)
|
|
{
|
|
sortOrder = FindControls.FindChild<Path>(header, "SortArrow");
|
|
txtSortOrder = FindControls.FindChild<TextBlock>(header, "txtSortOrder");
|
|
}
|
|
}
|
|
if (sortDesc.PropertyName ==
|
|
SortHelpers.GetSortMemberPath(Columns[GetColumnIndex(Columns, sortDesc.PropertyName)]))
|
|
{
|
|
|
|
|
|
if (Items.SortDescriptions.Count > 1 && ShowSortOrder)
|
|
{
|
|
|
|
if (sortOrder != null)
|
|
{
|
|
sortOrder.Tag = "True";
|
|
if (txtSortOrder != null)
|
|
{
|
|
txtSortOrder.Text = sortIndex.ToString(CultureInfo.InvariantCulture);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sortOrder.Tag = null;
|
|
}
|
|
}
|
|
|
|
NotifyPropertyChanged("RowSummariesTable");
|
|
}
|
|
|
|
private void UpdateColumnInfo()
|
|
{
|
|
_updatingColumnInfo = true;
|
|
ColumnInfo = new ObservableCollection<ColumnInformation>(Columns.Select(x => new ColumnInformation(x)));
|
|
_updatingColumnInfo = false;
|
|
}
|
|
|
|
protected override void OnPreviewMouseLeftButtonUp(MouseButtonEventArgs e)
|
|
{
|
|
if (_inWidthChange)
|
|
{
|
|
_inWidthChange = false;
|
|
UpdateColumnInfo();
|
|
}
|
|
base.OnPreviewMouseLeftButtonUp(e);
|
|
}
|
|
|
|
private void ColumnInfoChanged()
|
|
{
|
|
Items.SortDescriptions.Clear();
|
|
foreach (var column in ColumnInfo)
|
|
{
|
|
var realColumn = Columns.FirstOrDefault(x => column.SortMemberPath.Equals(x.SortMemberPath));
|
|
if (realColumn == null)
|
|
{
|
|
continue;
|
|
}
|
|
column.Apply(realColumn, Columns.Count, Items.SortDescriptions);
|
|
}
|
|
}
|
|
|
|
private string SerializeObjectToXML<T>(T item)
|
|
{
|
|
var xs = new XmlSerializer(typeof (T));
|
|
using (var stringWriter = new StringWriter())
|
|
{
|
|
xs.Serialize(stringWriter, item);
|
|
return stringWriter.ToString();
|
|
}
|
|
}
|
|
|
|
private T DeserializeFromXml<T>(string xml)
|
|
{
|
|
T result;
|
|
var ser = new XmlSerializer(typeof (T));
|
|
using (TextReader tr = new StringReader(xml))
|
|
{
|
|
result = (T) ser.Deserialize(tr);
|
|
}
|
|
return result;
|
|
}
|
|
/// <summary>
|
|
/// Get the column information in xml (string) basically used to save data
|
|
/// </summary>
|
|
/// <returns>xml representation of column information in string</returns>
|
|
public string GetColumnInformation()
|
|
{
|
|
UpdateColumnInfo();
|
|
return SerializeObjectToXML(ColumnInfo);
|
|
}
|
|
/// <summary>
|
|
/// This is used to apply the column information last saved
|
|
/// </summary>
|
|
/// <param name="xmlOfColumnInformation">xml representation of column information</param>
|
|
/// <returns></returns>
|
|
public bool SetColumnInformation(string xmlOfColumnInformation)
|
|
{
|
|
try
|
|
{
|
|
ColumnInfo = DeserializeFromXml<ObservableCollection<ColumnInformation>>(xmlOfColumnInformation);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private void DataGridStandardSorting(object sender, DataGridSortingEventArgs e)
|
|
{
|
|
if (OnlyTwoWaySorting)
|
|
return;
|
|
string sortPropertyName = SortHelpers.GetSortMemberPath(e.Column);
|
|
if (!String.IsNullOrEmpty(sortPropertyName))
|
|
{
|
|
// sorting is cleared when the previous state is Descending
|
|
if (e.Column.SortDirection.HasValue && e.Column.SortDirection.Value == ListSortDirection.Descending)
|
|
{
|
|
int index = SortHelpers.FindSortDescription(Items.SortDescriptions, sortPropertyName);
|
|
if (index != -1)
|
|
{
|
|
e.Column.SortDirection = null;
|
|
// remove the sort description
|
|
Items.SortDescriptions.RemoveAt(index);
|
|
Items.Refresh();
|
|
if ((Keyboard.Modifiers & ModifierKeys.Shift) != ModifierKeys.Shift)
|
|
{
|
|
// clear any other sort descriptions for the multisorting case
|
|
Items.SortDescriptions.Clear();
|
|
Items.Refresh();
|
|
}
|
|
// stop the default sort
|
|
e.Handled = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Property
|
|
|
|
internal bool IsGroupByColumnRemoved
|
|
{
|
|
get { return GroupByColumnRemoved != null; }
|
|
}
|
|
|
|
internal DataGrid RowSummariesGrid { get; set; }
|
|
internal bool IsVerticalScrolling { get; set; }
|
|
|
|
public DataRow DraggedItem
|
|
{
|
|
get { return _draggedItem; }
|
|
set
|
|
{
|
|
_draggedItem = value;
|
|
NotifyPropertyChanged("DraggedItem");
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Group by collection
|
|
/// </summary>
|
|
public ObservableCollection<GroupByData> GroupByCollection
|
|
{
|
|
get { return _groupByCollection; }
|
|
set
|
|
{
|
|
|
|
_groupByCollection = value;
|
|
NotifyPropertyChanged("GroupByCollection");
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// DataTable which keeps record of summary row
|
|
/// </summary>
|
|
public DataTable RowSummariesTable
|
|
{
|
|
get { return _rowSummariesTable; }
|
|
set
|
|
{
|
|
|
|
_rowSummariesTable = value;
|
|
NotifyPropertyChanged("RowSummariesTable");
|
|
}
|
|
}
|
|
|
|
internal Grid GridSplitterGrid { get; set; }
|
|
|
|
internal AutoFilterHelper AutoFilterHelper { get; private set; }
|
|
|
|
internal bool IsGroupByOn { get; private set; }
|
|
|
|
#endregion
|
|
|
|
#region "Attached Properties"
|
|
/// <summary>
|
|
/// Auto Filter Font Size
|
|
/// </summary>
|
|
public double AutoFilterFontSize
|
|
{
|
|
get { return (double) GetValue(AutoFilterFontSizeProperty); }
|
|
set { SetValue(AutoFilterFontSizeProperty, value); }
|
|
}
|
|
|
|
public static readonly DependencyProperty AutoFilterFontSizeProperty = DependencyProperty.Register(
|
|
"AutoFilterFontSize", typeof (double), typeof (ExtendedDataGrid), new PropertyMetadata(9.0));
|
|
/// <summary>
|
|
/// Search Auto Filter Visibility
|
|
/// </summary>
|
|
public Visibility SearchAutoFilterVisibility
|
|
{
|
|
get { return (Visibility) GetValue(SearchAutoFilterVisibilityProperty); }
|
|
set { SetValue(SearchAutoFilterVisibilityProperty, value); }
|
|
}
|
|
|
|
public static readonly DependencyProperty SearchAutoFilterVisibilityProperty = DependencyProperty.Register(
|
|
"SearchAutoFilterVisibility", typeof (Visibility), typeof (ExtendedDataGrid),
|
|
new PropertyMetadata(Visibility.Visible));
|
|
/// <summary>
|
|
/// Group By Control Visibility
|
|
/// </summary>
|
|
public Visibility GroupByControlVisibility
|
|
{
|
|
get { return (Visibility) GetValue(GroupByControlVisibilityProperty); }
|
|
set { SetValue(GroupByControlVisibilityProperty, value); }
|
|
}
|
|
|
|
public static readonly DependencyProperty GroupByControlVisibilityProperty = DependencyProperty.Register(
|
|
"GroupByControlVisibility", typeof (Visibility), typeof (ExtendedDataGrid),
|
|
new PropertyMetadata(Visibility.Visible));
|
|
/// <summary>
|
|
/// Hide Column Chooser
|
|
/// </summary>
|
|
public Boolean HideColumnChooser
|
|
{
|
|
get { return (Boolean) GetValue(HideColumnChooseProperty); }
|
|
set { SetValue(HideColumnChooseProperty, value); }
|
|
}
|
|
|
|
public static readonly DependencyProperty HideColumnChooseProperty = DependencyProperty.Register(
|
|
"HideColumnChooser", typeof (Boolean), typeof (ExtendedDataGrid), new PropertyMetadata(false));
|
|
/// <summary>
|
|
/// Column Info
|
|
/// </summary>
|
|
public ObservableCollection<ColumnInformation> ColumnInfo
|
|
{
|
|
get { return (ObservableCollection<ColumnInformation>) GetValue(ColumnInfoProperty); }
|
|
set { SetValue(ColumnInfoProperty, value); }
|
|
}
|
|
|
|
public static readonly DependencyProperty GroupByHeaderTextProperty = DependencyProperty.Register(
|
|
"GroupByHeaderText", typeof (string), typeof (ExtendedDataGrid),
|
|
new PropertyMetadata("Click a plus sign in column header to group by that column."));
|
|
/// <summary>
|
|
/// Group By Header Text
|
|
/// </summary>
|
|
public string GroupByHeaderText
|
|
{
|
|
get { return (string) GetValue(GroupByHeaderTextProperty); }
|
|
set
|
|
{
|
|
SetValue(GroupByHeaderTextProperty, value);
|
|
var textBox = FindControls.FindChild<TextBlock>(this, "txtDragName");
|
|
if (textBox != null)
|
|
{
|
|
textBox.Text = value;
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Theme of the data grid
|
|
/// </summary>
|
|
public Themes Theme
|
|
{
|
|
get { return (Themes) GetValue(ThemeProperty); }
|
|
set
|
|
{
|
|
AddTheme(value);
|
|
SetValue(ThemeProperty, value);
|
|
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Allow to user to copy
|
|
/// </summary>
|
|
public Boolean AllowUserToCopy
|
|
{
|
|
get { return (Boolean) GetValue(AllowUserToCopyProperty); }
|
|
set { SetValue(AllowUserToCopyProperty, value); }
|
|
}
|
|
|
|
public static readonly DependencyProperty AllowUserToCopyProperty = DependencyProperty.Register(
|
|
"AllowUserToCopy", typeof (Boolean), typeof (ExtendedDataGrid), new PropertyMetadata(true));
|
|
|
|
public static readonly DependencyProperty ThemeProperty = DependencyProperty.Register(
|
|
"Theme", typeof (Themes), typeof (ExtendedDataGrid), new PropertyMetadata(Themes.Default));
|
|
|
|
/// <summary>
|
|
/// Can User Reorder Rows
|
|
/// </summary>
|
|
public Boolean CanUserReorderRows
|
|
{
|
|
get { return (Boolean) GetValue(CanUserReorderRowsProperty); }
|
|
set { SetValue(CanUserReorderRowsProperty, value); }
|
|
}
|
|
|
|
public static readonly DependencyProperty CanUserReorderRowsProperty = DependencyProperty.Register(
|
|
"CanUserReorderRows", typeof (Boolean), typeof (ExtendedDataGrid), new PropertyMetadata(false));
|
|
|
|
/// <summary>
|
|
/// Show Sort Order
|
|
/// </summary>
|
|
public Boolean ShowSortOrder
|
|
{
|
|
get { return (Boolean) GetValue(ShowSortOrderProperty); }
|
|
set { SetValue(ShowSortOrderProperty, value); }
|
|
}
|
|
|
|
public static readonly DependencyProperty ShowSortOrderProperty = DependencyProperty.Register(
|
|
"ShowSortOrder", typeof (Boolean), typeof (ExtendedDataGrid), new PropertyMetadata(false));
|
|
|
|
/// <summary>
|
|
/// Show Column Splitter
|
|
/// </summary>
|
|
public Boolean ShowColumnSplitter
|
|
{
|
|
get { return (Boolean) GetValue(ShowColumnSplitterProperty); }
|
|
set { SetValue(ShowColumnSplitterProperty, value); }
|
|
}
|
|
|
|
public static readonly DependencyProperty ShowColumnSplitterProperty = DependencyProperty.Register(
|
|
"ShowColumnSplitter", typeof (Boolean), typeof (ExtendedDataGrid), new PropertyMetadata(false));
|
|
|
|
/// <summary>
|
|
/// Footer Data Template
|
|
/// </summary>
|
|
public DataTemplate FooterDataTemplate
|
|
{
|
|
get { return (DataTemplate) GetValue(FooterDataTemplateProperty); }
|
|
set
|
|
{
|
|
SetValue(FooterDataTemplateProperty, value);
|
|
SetValue(ScrollingPreviewService.VerticalScrollingPreviewTemplateProperty,
|
|
GetValue(FooterDataTemplateProperty));
|
|
}
|
|
}
|
|
|
|
public static readonly DependencyProperty FooterDataTemplateProperty = DependencyProperty.Register(
|
|
"FooterDataTemplate", typeof (DataTemplate), typeof (ExtendedDataGrid));
|
|
|
|
/// <summary>
|
|
/// Scroll Tool Tip Data Template
|
|
/// </summary>
|
|
public DataTemplate ScrollToolTipDataTemplate
|
|
{
|
|
get { return (DataTemplate) GetValue(ScrollToolTipDataTemplateProperty); }
|
|
set { SetValue(ScrollToolTipDataTemplateProperty, value); }
|
|
}
|
|
|
|
public static readonly DependencyProperty ScrollToolTipDataTemplateProperty = DependencyProperty.Register(
|
|
"ScrollToolTipDataTemplate", typeof (DataTemplate), typeof (ExtendedDataGrid));
|
|
|
|
/// <summary>
|
|
/// Show Row Number
|
|
/// </summary>
|
|
public Boolean ShowRowNumber
|
|
{
|
|
get { return (Boolean) GetValue(ShowRowNumberProperty); }
|
|
set { SetValue(ShowRowNumberProperty, value); }
|
|
}
|
|
|
|
public static readonly DependencyProperty ShowRowNumberProperty = DependencyProperty.Register(
|
|
"ShowRowNumber", typeof (Boolean), typeof (ExtendedDataGrid), new PropertyMetadata(false));
|
|
|
|
/// <summary>
|
|
/// Show Row Summaries
|
|
/// </summary>
|
|
public Boolean ShowRowSummaries
|
|
{
|
|
get { return (Boolean) GetValue(ShowRowSummariesProperty); }
|
|
set { SetValue(ShowRowSummariesProperty, value); }
|
|
}
|
|
|
|
public static readonly DependencyProperty ShowRowSummariesProperty = DependencyProperty.Register(
|
|
"ShowRowSummaries", typeof (Boolean), typeof (ExtendedDataGrid), new PropertyMetadata(false));
|
|
|
|
#endregion
|
|
}
|
|
}
|