public bool Evaluate(DataGridColumn column, int gridRow, object itemRow)
{
if (EvaluateFunction == null)
return false;
return EvaluateFunction(column, gridRow, itemRow);
}
/// <summary>
/// Initializes a new instance of the <see cref="T:System.Windows.Controls.DataGridColumnEventArgs" /> class.
/// </summary>
/// <param name="column">The column that the event occurs for.</param>
public DataGridColumnEventArgs(DataGridColumn column)
{
if (column == null)
{
throw new ArgumentNullException("column");
}
this.Column = column;
}
public DataGridBeginningEditEventArgs(DataGridColumn column,
DataGridRow row,
RoutedEventArgs editingEventArgs)
{
this.Column = column;
this.Row = row;
this.EditingEventArgs = editingEventArgs;
}
public DataGridEndingEditEventArgs(DataGridColumn column,
DataGridRow row,
FrameworkElement editingElement,
DataGridEditingUnit editingUnit)
{
this.Column = column;
this.Row = row;
this.EditingElement = editingElement;
this.EditingUnit = editingUnit;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:System.Windows.Controls.DataGridPreparingCellForEditEventArgs" /> class.
/// </summary>
/// <param name="column">The column that contains the cell to be edited.</param>
/// <param name="row">The row that contains the cell to be edited.</param>
/// <param name="editingEventArgs">Information about the user gesture that caused the cell to enter edit mode.</param>
/// <param name="editingElement">The element that the column displays for a cell in editing mode.</param>
public DataGridPreparingCellForEditEventArgs(DataGridColumn column,
DataGridRow row,
RoutedEventArgs editingEventArgs,
FrameworkElement editingElement)
{
this.Column = column;
this.Row = row;
this.EditingEventArgs = editingEventArgs;
this.EditingElement = editingElement;
}
/// <summary>
/// AutomationPeer for an item in a DataGrid
/// </summary>
public DataGridCellItemAutomationPeer(object item, DataGridColumn dataGridColumn) : base()
{
if (item == null)
{
throw new ArgumentNullException("item");
}
if (dataGridColumn == null)
{
throw new ArgumentNullException("dataGridColumn");
}
_item = item;
_column = dataGridColumn;
}
/// <summary>
/// Measures the children of a <see cref="T:Avalonia.Controls.Primitives.DataGridColumnHeadersPresenter" /> to
/// prepare for arranging them during the <see cref="M:System.Windows.FrameworkElement.ArrangeOverride(System.Windows.Size)" /> pass.
/// </summary>
/// <param name="availableSize">
/// The available size that this element can give to child elements. Indicates an upper limit that child elements should not exceed.
/// </param>
/// <returns>
/// The size that the <see cref="T:Avalonia.Controls.Primitives.DataGridColumnHeadersPresenter" /> determines it needs during layout, based on its calculations of child object allocated sizes.
/// </returns>
protected override Size MeasureOverride(Size availableSize)
{
if (OwningGrid == null)
{
return(base.MeasureOverride(availableSize));
}
if (!OwningGrid.AreColumnHeadersVisible)
{
return(Size.Empty);
}
double height = OwningGrid.ColumnHeaderHeight;
bool autoSizeHeight;
if (double.IsNaN(height))
{
// No explicit height values were set so we can autosize
height = 0;
autoSizeHeight = true;
}
else
{
autoSizeHeight = false;
}
double totalDisplayWidth = 0;
OwningGrid.ColumnsInternal.EnsureVisibleEdgedColumnsWidth();
DataGridColumn lastVisibleColumn = OwningGrid.ColumnsInternal.LastVisibleColumn;
foreach (DataGridColumn column in OwningGrid.ColumnsInternal.GetVisibleColumns())
{
// Measure each column header
bool autoGrowWidth = column.Width.IsAuto || column.Width.IsSizeToHeader;
DataGridColumnHeader columnHeader = column.HeaderCell;
if (column != lastVisibleColumn)
{
columnHeader.UpdateSeparatorVisibility(lastVisibleColumn);
}
// If we're not using star sizing or the current column can't be resized,
// then just set the display width according to the column's desired width
if (!OwningGrid.UsesStarSizing || (!column.ActualCanUserResize && !column.Width.IsStar))
{
// In the edge-case where we're given infinite width and we have star columns, the
// star columns grow to their predefined limit of 10,000 (or their MaxWidth)
double newDisplayWidth = column.Width.IsStar ?
Math.Min(column.ActualMaxWidth, DataGrid.DATAGRID_maximumStarColumnWidth) :
Math.Max(column.ActualMinWidth, Math.Min(column.ActualMaxWidth, column.Width.DesiredValue));
column.SetWidthDisplayValue(newDisplayWidth);
}
// If we're auto-growing the column based on the header content, we want to measure it at its maximum value
if (autoGrowWidth)
{
columnHeader.Measure(new Size(column.ActualMaxWidth, double.PositiveInfinity));
OwningGrid.AutoSizeColumn(column, columnHeader.DesiredSize.Width);
column.ComputeLayoutRoundedWidth(totalDisplayWidth);
}
else if (!OwningGrid.UsesStarSizing)
{
column.ComputeLayoutRoundedWidth(totalDisplayWidth);
columnHeader.Measure(new Size(column.LayoutRoundedWidth, double.PositiveInfinity));
}
// We need to track the largest height in order to auto-size
if (autoSizeHeight)
{
height = Math.Max(height, columnHeader.DesiredSize.Height);
}
totalDisplayWidth += column.ActualWidth;
}
// If we're using star sizing (and we're not waiting for an auto-column to finish growing)
// then we will resize all the columns to fit the available space.
if (OwningGrid.UsesStarSizing && !OwningGrid.AutoSizingColumns)
{
double adjustment = Double.IsPositiveInfinity(availableSize.Width) ? OwningGrid.CellsWidth : availableSize.Width - totalDisplayWidth;
totalDisplayWidth += adjustment - OwningGrid.AdjustColumnWidths(0, adjustment, false);
// Since we didn't know the final widths of the columns until we resized,
// we waited until now to measure each header
double leftEdge = 0;
foreach (DataGridColumn column in OwningGrid.ColumnsInternal.GetVisibleColumns())
{
column.ComputeLayoutRoundedWidth(leftEdge);
column.HeaderCell.Measure(new Size(column.LayoutRoundedWidth, double.PositiveInfinity));
if (autoSizeHeight)
{
height = Math.Max(height, column.HeaderCell.DesiredSize.Height);
}
leftEdge += column.ActualWidth;
}
}
// Add the filler column if it's not represented. We won't know whether we need it or not until Arrange
DataGridFillerColumn fillerColumn = OwningGrid.ColumnsInternal.FillerColumn;
if (!fillerColumn.IsRepresented)
{
Debug.Assert(!Children.Contains(fillerColumn.HeaderCell));
fillerColumn.HeaderCell.AreSeparatorsVisible = false;
Children.Insert(OwningGrid.ColumnsInternal.Count, fillerColumn.HeaderCell);
fillerColumn.IsRepresented = true;
// Optimize for the case where we don't need the filler cell
fillerColumn.HeaderCell.IsVisible = false;
}
fillerColumn.HeaderCell.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
if (DragIndicator != null)
{
DragIndicator.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
}
if (DropLocationIndicator != null)
{
DropLocationIndicator.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
}
OwningGrid.ColumnsInternal.EnsureVisibleEdgedColumnsWidth();
return(new Size(OwningGrid.ColumnsInternal.VisibleEdgedColumnsWidth, height));
}
/// <summary>
/// Initializes a new instance of the <see cref="GridFormEntityProperty"/> class.
/// </summary>
public GridFormEntityProperty(PropertyInfo property, object item, DataGridColumn column)
: base(property, item)
{
this.column = column;
}
public static CultureInfo GetCulture([NotNull] this DataGridColumn column)
{
Contract.Requires(column != null);
return(column.GetCultureKey()?.Culture);
}
/// <summary>
/// Helper method which generates and measures a
/// child of given index
/// </summary>
private UIElement GenerateChild(
IItemContainerGenerator generator,
Size constraint,
DataGridColumn column,
ref IDisposable generatorState,
ref int childIndex,
out Size childSize)
{
if (generatorState == null)
{
generatorState = generator.StartAt(IndexToGeneratorPositionForStart(generator, childIndex, out childIndex), GeneratorDirection.Forward, true);
}
return GenerateChild(generator, constraint, column, ref childIndex, out childSize);
}
/// <summary>
/// Instantiates a new instance of this class.
/// </summary>
/// <param name="column">The column of the cell that is about to enter edit mode.</param>
/// <param name="row">The row container of the cell container that is about to enter edit mode.</param>
/// <param name="editingEventArgs">The event arguments, if any, that led to the cell entering edit mode.</param>
public DataGridBeginningEditEventArgs(DataGridColumn column, DataGridRow row, RoutedEventArgs editingEventArgs)
{
_dataGridColumn = column;
_dataGridRow = row;
_editingEventArgs = editingEventArgs;
}
// TODO: Consider making a protected virtual so that sub-classes can customize the behavior
private void ScrollCellIntoView(object item, DataGridColumn column)
{
Debug.Assert(item != null, "item is null.");
Debug.Assert(column != null, "column is null.");
if (!column.IsVisible)
{
return;
}
// Devirtualize the concerned row if it is not already
DataGridRow row = ItemContainerGenerator.ContainerFromItem(item) as DataGridRow;
if (row == null)
{
ScrollRowIntoView(item);
UpdateLayout();
row = ItemContainerGenerator.ContainerFromItem(item) as DataGridRow;
}
// Use the row to scroll cell into view.
if (row != null)
{
int columnIndex = _columns.IndexOf(column);
row.ScrollCellIntoView(columnIndex);
}
}
/// <summary>
/// Method to perform sorting on datagrid
/// </summary>
/// <param name="sortColumn"></param>
internal void PerformSort(DataGridColumn sortColumn)
{
Debug.Assert(sortColumn != null, "column should not be null");
if (!CanUserSortColumns || !sortColumn.CanUserSort)
{
return;
}
if (CommitAnyEdit())
{
PrepareForSort(sortColumn);
DataGridSortingEventArgs eventArgs = new DataGridSortingEventArgs(sortColumn);
OnSorting(eventArgs);
if (Items.NeedsRefresh)
{
try
{
Items.Refresh();
}
catch (InvalidOperationException invalidOperationException)
{
Items.SortDescriptions.Clear();
throw new InvalidOperationException(SR.Get(SRID.DataGrid_ProbableInvalidSortDescription), invalidOperationException);
}
}
}
}
public void ScrollIntoView(object item, DataGridColumn column)
{
throw new NotImplementedException();
}
/// <summary>
/// Creates and returns a data-grid-column for the supplied model property definitor.
/// </summary>
public static DataGridColumn CreateGridColumn(IModelEntity Context, MModelPropertyDefinitor Definitor)
{
DataGridColumn Result = null;
if (Definitor.DeclaringType == typeof(bool))
{
var Column = new DataGridCheckBoxColumn();
var Binder = new Binding(Definitor.TechName);
Binder.Mode = BindingMode.TwoWay;
Column.Binding = Binder;
Result = Column;
}
else
if (Definitor.DeclaringType == typeof(ImageSource))
{
var Column = new DataGridTemplateColumn();
var EditorFactory = new FrameworkElementFactory(typeof(Image));
var Binder = new Binding(Definitor.TechName);
Binder.Mode = BindingMode.TwoWay;
EditorFactory.SetValue(Image.SourceProperty, Binder);
var CellTemplate = new DataTemplate();
CellTemplate.VisualTree = EditorFactory;
Column.CellTemplate = CellTemplate;
Result = Column;
}
else
if (Definitor.ItemsSourceGetter != null)
{
var Column = new DataGridComboBoxColumn();
Column.ItemsSource = Definitor.ItemsSourceGetter(Context);
if (!Definitor.ItemsSourceSelectedValuePath.IsAbsent())
{
Column.SelectedValuePath = Definitor.ItemsSourceSelectedValuePath;
}
if (!Definitor.ItemsSourceDisplayMemberPath.IsAbsent())
{
Column.DisplayMemberPath = Definitor.ItemsSourceDisplayMemberPath;
}
var Binder = new Binding(Definitor.TechName);
Binder.Mode = BindingMode.TwoWay;
Column.SelectedItemBinding = Binder;
var ComboStyle = new Style(typeof(ComboBox));
ComboStyle.Setters.Add(new Setter(ComboBox.FontSizeProperty, DEF_FONT_SIZE));
/*T This may crash? for edit value (as text)
* ComboStyle.Setters.Add(new Setter(ComboBox.IsEditableProperty, true));
* ComboStyle.Setters.Add(new Setter(ComboBox.IsReadOnlyProperty, false)); */
Column.EditingElementStyle = ComboStyle;
Column.ElementStyle = ComboStyle;
Result = Column;
}
else
{
var Column = new DataGridTextColumn();
var Binder = new Binding(Definitor.TechName);
Binder.Mode = (Definitor.DataType == typeof(string) || Definitor.BindingValueConverter != null
? BindingMode.TwoWay : BindingMode.OneWay);
Column.Binding = Binder;
Column.EditingElementStyle = new Style(typeof(TextBox));
Column.EditingElementStyle.Setters.Add(new Setter(TextBox.PaddingProperty, new Thickness(0, -1, 0, 0)));
Column.FontSize = DEF_FONT_SIZE;
Result = Column;
}
var Entitler = new TextBlock();
Entitler.Text = Definitor.Name;
Entitler.ToolTip = Definitor.Summary;
Entitler.Tag = Definitor;
Result.Header = Entitler;
Result.IsReadOnly = !Definitor.IsEditControlled;
Result.MinWidth = Math.Max(Definitor.Name.Length, Definitor.DisplayMinLength) * Display.CHAR_PXWIDTH_DEFAULT;
return(Result);
}
public static void SetCustomSorter(DataGridColumn gridColumn, ICustomSorter value)
{
gridColumn.SetValue(CustomSorterProperty, value);
}
public static GroupBox CreateColumnCustomizer(DataGridColumn columnSource)
{
TextBox displayIndexTextBox = new TextBox();
Binding tbBinding = new Binding("DisplayIndex");
tbBinding.Source = columnSource;
displayIndexTextBox.SetBinding(TextBox.TextProperty, tbBinding);
GroupBox gb_DisplayIndex = new GroupBox();
gb_DisplayIndex.Header = "DisplayIndex:";
gb_DisplayIndex.Content = displayIndexTextBox;
CheckBox canSortCB = new CheckBox();
canSortCB.Content = "CanUserSort";
Binding binding = new Binding("CanUserSort");
binding.Source = columnSource;
canSortCB.SetBinding(CheckBox.IsCheckedProperty, binding);
CheckBox canReorderCB = new CheckBox();
canReorderCB.Content = "CanUserReorder";
binding = new Binding("CanUserReorder");
binding.Source = columnSource;
canReorderCB.SetBinding(CheckBox.IsCheckedProperty, binding);
CheckBox canResizeCB = new CheckBox();
canResizeCB.Content = "CanUserResize";
binding = new Binding("CanUserResize");
binding.Source = columnSource;
canResizeCB.SetBinding(CheckBox.IsCheckedProperty, binding);
CheckBox isReadOnlyCB = new CheckBox();
isReadOnlyCB.Content = "IsReadOnly";
Binding binding1 = new Binding("IsReadOnly");
binding1.Source = columnSource;
isReadOnlyCB.SetBinding(CheckBox.IsCheckedProperty, binding1);
CheckBox isFrozenCB = new CheckBox();
isFrozenCB.Content = "IsFrozen";
isFrozenCB.IsEnabled = false;
binding = new Binding("IsFrozen");
binding.Source = columnSource;
binding.Mode = BindingMode.OneWay;
isFrozenCB.SetBinding(CheckBox.IsCheckedProperty, binding);
CheckBox isAutoGeneratedCB = new CheckBox();
isAutoGeneratedCB.Content = "IsAutoGenerated";
isAutoGeneratedCB.IsEnabled = false;
binding = new Binding("IsAutoGenerated");
binding.Source = columnSource;
binding.Mode = BindingMode.OneWay;
isAutoGeneratedCB.SetBinding(CheckBox.IsCheckedProperty, binding);
ComboBox sortDirectionComboBox = new ComboBox();
sortDirectionComboBox.Items.Add("null");
sortDirectionComboBox.Items.Add("Ascending");
sortDirectionComboBox.Items.Add("Descending");
Binding sortDirBinding = new Binding("SortDirection");
sortDirBinding.Source = columnSource;
// sortDirBinding.Converter = new SortDirectionConverter();
sortDirectionComboBox.SetBinding(ComboBox.SelectedItemProperty, sortDirBinding);
sortDirectionComboBox.SelectedIndex = 0;
GroupBox gb_SortDirection = new GroupBox();
gb_SortDirection.Header = "SortDirection:";
gb_SortDirection.Content = sortDirectionComboBox;
ComboBox cb_Visibility = new ComboBox();
cb_Visibility.ItemsSource = Enum.GetValues(typeof(Visibility));
binding = new Binding("Visibility");
binding.Source = columnSource;
cb_Visibility.SetBinding(ComboBox.SelectedItemProperty, binding);
cb_Visibility.SelectedIndex = 0;
GroupBox gb_Visibility = new GroupBox();
gb_Visibility.Header = "Visibility:";
gb_Visibility.Content = cb_Visibility;
TextBox widthTextBox = new TextBox();
Binding widthBinding = new Binding("Width");
widthBinding.Source = columnSource;
widthTextBox.SetBinding(TextBox.TextProperty, widthBinding);
GroupBox gb_Width = new GroupBox();
gb_Width.Header = "Width:";
gb_Width.Content = widthTextBox;
TextBox actualWidthTextBox = new TextBox();
Binding actualWidthBinding = new Binding("ActualWidth");
actualWidthBinding.Source = columnSource;
actualWidthBinding.Mode = BindingMode.OneWay;
actualWidthBinding.NotifyOnTargetUpdated = true;
actualWidthTextBox.SetBinding(TextBox.TextProperty, actualWidthBinding);
GroupBox gbActualWidth = new GroupBox();
gbActualWidth.Header = "ActualWidth:";
gbActualWidth.Content = actualWidthTextBox;
TextBox desiredWidthTextBox = new TextBox();
Binding desiredWidthBinding = new Binding("Width.DesiredValue");
desiredWidthBinding.Source = columnSource;
desiredWidthBinding.Mode = BindingMode.OneWay;
desiredWidthTextBox.SetBinding(TextBox.TextProperty, desiredWidthBinding);
GroupBox gb_DesiredWidth = new GroupBox();
gb_DesiredWidth.Header = "DesiredWidth:";
gb_DesiredWidth.Content = desiredWidthTextBox;
TextBox displayWidthTextBox = new TextBox();
Binding displayWidthBinding = new Binding("Width.DisplayValue");
displayWidthBinding.Source = columnSource;
displayWidthBinding.Mode = BindingMode.OneWay;
displayWidthTextBox.SetBinding(TextBox.TextProperty, displayWidthBinding);
GroupBox gb_DisplayWidth = new GroupBox();
gb_DisplayWidth.Header = "DisplayWidth:";
gb_DisplayWidth.Content = displayWidthTextBox;
TextBox minWidthTextBox = new TextBox();
Binding minWidthBinding = new Binding("MinWidth");
minWidthBinding.Source = columnSource;
minWidthTextBox.SetBinding(TextBox.TextProperty, minWidthBinding);
GroupBox gb_MinWidth = new GroupBox();
gb_MinWidth.Header = "MinWidth:";
gb_MinWidth.Content = minWidthTextBox;
TextBox maxWidthTextBox = new TextBox();
Binding maxWidthBinding = new Binding("MaxWidth");
maxWidthBinding.Source = columnSource;
maxWidthTextBox.SetBinding(TextBox.TextProperty, maxWidthBinding);
GroupBox gb_MaxWidth = new GroupBox();
gb_MaxWidth.Header = "MaxWidth:";
gb_MaxWidth.Content = maxWidthTextBox;
TextBox sortMemberPathTextBox = new TextBox();
binding = new Binding("SortMemberPath");
binding.Source = columnSource;
sortMemberPathTextBox.SetBinding(TextBox.TextProperty, binding);
GroupBox gb_SortMemberPath = new GroupBox();
gb_SortMemberPath.Header = "SortMemberPath:";
gb_SortMemberPath.Content = sortMemberPathTextBox;
StackPanel sp = new StackPanel();
sp.Children.Add(gb_DisplayIndex);
sp.Children.Add(canSortCB);
sp.Children.Add(canReorderCB);
sp.Children.Add(canResizeCB);
sp.Children.Add(isReadOnlyCB);
sp.Children.Add(isFrozenCB);
sp.Children.Add(isAutoGeneratedCB);
sp.Children.Add(gb_SortDirection);
sp.Children.Add(gb_Width);
//sp.Children.Add(gb_DesiredWidth);
//sp.Children.Add(gb_DisplayWidth);
//sp.Children.Add(gbActualWidth);
sp.Children.Add(gb_MinWidth);
sp.Children.Add(gb_MaxWidth);
sp.Children.Add(gb_SortMemberPath);
sp.Children.Add(gb_Visibility);
GroupBox gb_all = new GroupBox();
gb_all.Header = columnSource.Header + ":";
gb_all.Content = sp;
return(gb_all);
}
public static ICustomSorter GetCustomSorter(DataGridColumn gridColumn)
{
return((ICustomSorter)gridColumn.GetValue(CustomSorterProperty));
}
public ColumnHolder(DataGridColumn column, int sortOrder)
{
this.column = column;
this.sortOrder = sortOrder;
}
public void Calculate(MaterialBase materialBase, DataGridColumn column, object value)
{
base.Calculate(materialBase, column, value, Sys.Columns.CostAdjustment);
}
public void RaiseGroupByColumnAdded(DataGridColumn column)
{
GroupByColumnAdded(this, new GroupByEventArgs() {Column = column});
}
void ColumnFilterControl_Loaded(object sender, RoutedEventArgs e)
{
DataGridColumn column = null;
DataGridColumnHeader colHeader = null;
UIElement parent = (UIElement)VisualTreeHelper.GetParent(this);
while (parent != null)
{
parent = (UIElement)VisualTreeHelper.GetParent(parent);
if (colHeader == null)
{
colHeader = parent as DataGridColumnHeader;
}
if (Grid == null)
{
Grid = parent as ExDataGrid;
}
}
if (colHeader != null)
{
column = colHeader.Column;
}
CanUserFilter = Grid.CanUserFilter;
CanUserFreeze = Grid.CanUserFreeze;
CanUserGroup = Grid.CanUserGroup;
CanUserSelectDistinct = Grid.CanUserSelectDistinct;
if (column != null)
{
object oCanUserFilter = column.GetValue(ColumnConfiguration.CanUserFilterProperty);
if (oCanUserFilter != null)
{
CanUserFilter = (bool)oCanUserFilter;
}
object oCanUserFreeze = column.GetValue(ColumnConfiguration.CanUserFreezeProperty);
if (oCanUserFreeze != null)
{
CanUserFreeze = (bool)oCanUserFreeze;
}
object oCanUserGroup = column.GetValue(ColumnConfiguration.CanUserGroupProperty);
if (oCanUserGroup != null)
{
CanUserGroup = (bool)oCanUserGroup;
}
object oCanUserSelectDistinct = column.GetValue(ColumnConfiguration.CanUserSelectDistinctProperty);
if (oCanUserSelectDistinct != null)
{
CanUserSelectDistinct = (bool)oCanUserSelectDistinct;
}
}
if (Grid.FilterType == null)
{
return;
}
FilterColumnInfo = new OptionColumnInfo(column, Grid.FilterType);
Grid.RegisterOptionControl(this);
FilterOperations.Clear();
if (FilterColumnInfo.PropertyType != null)
{
FilterOperations.Add(new FilterOperationItem(Enums.FilterOperation.Equals, "Equals", "/Capnode.Wpf;component/Images/Equal.png"));
if (TypeHelper.IsStringType(FilterColumnInfo.PropertyType))
{
FilterOperations.Add(new FilterOperationItem(Enums.FilterOperation.Contains, "Contains", "/Capnode.Wpf;component/Images/Contains.png"));
FilterOperations.Add(new FilterOperationItem(Enums.FilterOperation.StartsWith, "Starts With", "/Capnode.Wpf;component/Images/StartsWith.png"));
FilterOperations.Add(new FilterOperationItem(Enums.FilterOperation.EndsWith, "Ends With", "/Capnode.Wpf;component/Images/EndsWith.png"));
}
if (TypeHelper.IsNumbericType(FilterColumnInfo.PropertyType))
{
FilterOperations.Add(new FilterOperationItem(Enums.FilterOperation.NotEquals, "Not Equal", "/Capnode.Wpf;component/Images/NotEqual.png"));
FilterOperations.Add(new FilterOperationItem(Enums.FilterOperation.GreaterThan, "Greater Than", "/Capnode.Wpf;component/Images/GreaterThan.png"));
FilterOperations.Add(new FilterOperationItem(Enums.FilterOperation.GreaterThanEqual, "Greater Than or Equal", "/Capnode.Wpf;component/Images/GreaterThanEqual.png"));
FilterOperations.Add(new FilterOperationItem(Enums.FilterOperation.LessThan, "Less Than", "/Capnode.Wpf;component/Images/LessThan.png"));
FilterOperations.Add(new FilterOperationItem(Enums.FilterOperation.LessThanEqual, "Less Than or Equal", "/Capnode.Wpf;component/Images/LessThanEqual.png"));
}
SelectedFilterOperation = FilterOperations[0];
}
if (FilterColumnInfo != null && FilterColumnInfo.IsValid)
{
foreach (var i in DistinctPropertyValues.Where(i => i.IsChecked))
{
i.IsChecked = false;
}
DistinctPropertyValues.Clear();
FilterText = string.Empty;
_boundColumnPropertyAccessor = null;
if (TypeHelper.IsNumbericType(FilterColumnInfo.PropertyType))
{
CanUserSelectDistinct = false;
Visibility = Visibility.Visible;
}
else if (!string.IsNullOrWhiteSpace(FilterColumnInfo.PropertyPath))
{
Visibility = Visibility.Visible;
ParameterExpression arg = linq.Expression.Parameter(typeof(object), "x");
linq.Expression expr = PropertyExpression(Grid.FilterType, FilterColumnInfo.PropertyPath, arg);
linq.Expression conversion = linq.Expression.Convert(expr, typeof(object));
_boundColumnPropertyAccessor = linq.Expression.Lambda <Func <object, object> >(conversion, arg).Compile();
}
else
{
Visibility = Visibility.Collapsed;
}
object oDefaultFilter = column.GetValue(ColumnConfiguration.DefaultFilterProperty);
if (oDefaultFilter != null)
{
FilterText = (string)oDefaultFilter;
}
}
CalcControlVisibility();
}
/// <summary>
/// Scrolls a cell into view.
/// If column is null then only vertical scroll is performed.
/// If row is null then only horizontal scroll is performed.
/// </summary>
/// <param name="item">The data item row that contains the cell.</param>
/// <param name="column">The cell's column.</param>
public void ScrollIntoView(object item, DataGridColumn column)
{
if (column == null)
{
ScrollIntoView(item);
return;
}
if (!column.IsVisible)
{
return;
}
if (ItemContainerGenerator.Status == GeneratorStatus.ContainersGenerated)
{
// Scroll by column only
if (item == null)
{
ScrollColumnIntoView(column);
}
else
{
ScrollCellIntoView(item, column);
}
}
else
{
// The items aren't generated, try at a later time
Dispatcher.BeginInvoke(DispatcherPriority.Loaded, new DispatcherOperationCallback(OnScrollIntoView), new object[] { item, column });
}
}
public static A AddColumnFl <A>(this A dataGrid, DataGridColumn column) where A : DataGrid
{
dataGrid.Columns.Add(column);
return(dataGrid);
}
/// <summary>
/// Called by DataGridColumnCollection when columns' DisplayIndex changes
/// </summary>
/// <param name="e"></param>
internal void UpdateColumnsOnVirtualizedCellInfoCollections(NotifyCollectionChangedAction action, int oldDisplayIndex, DataGridColumn oldColumn, int newDisplayIndex)
{
using (UpdateSelectedCells())
{
_selectedCells.OnColumnsChanged(action, oldDisplayIndex, oldColumn, newDisplayIndex, SelectedItems);
}
}
public DataGridCellEditEndedEventArgs(DataGridColumn column, DataGridRow row, DataGridEditAction editAction)
{
Column = column;
Row = row;
EditAction = editAction;
}
/// <summary>
/// Determines the sort direction and sort property name and adds a sort
/// description to the Items>SortDescriptions Collection. Clears all the
/// existing sort descriptions.
/// </summary>
/// <param name="column"></param>
/// <param name="clearExistingSortDescriptions"></param>
private void DefaultSort(DataGridColumn column, bool clearExistingSortDescriptions)
{
ListSortDirection sortDirection = ListSortDirection.Ascending;
Nullable<ListSortDirection> currentSortDirection = column.SortDirection;
if (currentSortDirection.HasValue &&
currentSortDirection.Value == ListSortDirection.Ascending)
{
sortDirection = ListSortDirection.Descending;
}
string sortPropertyName = column.SortMemberPath;
if (!string.IsNullOrEmpty(sortPropertyName))
{
int descriptorIndex = -1;
if (clearExistingSortDescriptions)
{
// clear the sortdesriptions collection
Items.SortDescriptions.Clear();
}
else
{
// get the index of existing descriptor to replace it
for (int i = 0; i < Items.SortDescriptions.Count; i++)
{
if (string.Compare(Items.SortDescriptions[i].PropertyName, sortPropertyName, StringComparison.Ordinal) == 0 &&
(GroupingSortDescriptionIndices == null ||
!GroupingSortDescriptionIndices.Contains(i)))
{
descriptorIndex = i;
break;
}
}
}
SortDescription sortDescription = new SortDescription(sortPropertyName, sortDirection);
try
{
if (descriptorIndex >= 0)
{
Items.SortDescriptions[descriptorIndex] = sortDescription;
}
else
{
Items.SortDescriptions.Add(sortDescription);
}
if (clearExistingSortDescriptions || !_sortingStarted)
{
RegenerateGroupingSortDescriptions();
_sortingStarted = true;
}
}
catch (InvalidOperationException invalidOperationException)
{
Items.SortDescriptions.Clear();
throw new InvalidOperationException(SR.Get(SRID.DataGrid_InvalidSortDescription), invalidOperationException);
}
column.SortDirection = sortDirection;
}
}
public static void ExportToExcel(DataGrid dGrid, string author, string companyName, string mergeCells,
int boldHeaderRows, string strFormat, Stream outputStream)
{
List <List <String> > mergeCellsList = new List <List <string> >();
if (!String.IsNullOrEmpty(mergeCells))
{
List <String> temp = mergeCells.Split(',').ToList();
temp.ForEach(p => mergeCellsList.Add(p.Split('-').ToList()));
}
StringBuilder strBuilder = new StringBuilder();
if (dGrid.ItemsSource == null)
{
return;
}
List <string> lstFields = new List <string>();
if (dGrid.HeadersVisibility == DataGridHeadersVisibility.Column ||
dGrid.HeadersVisibility == DataGridHeadersVisibility.All)
{
foreach (DataGridColumn dgcol in dGrid.Columns)
{
lstFields.Add(FormatField(dgcol.Header.ToString(), strFormat, true));
}
BuildStringOfRow(strBuilder, lstFields, strFormat);
}
int rowCount = 0;
foreach (object data in dGrid.ItemsSource)
{
lstFields.Clear();
for (int colCount = 0; colCount < dGrid.Columns.Count; colCount++)
//foreach (DataGridColumn col in dGrid.Columns)
{
DataGridColumn col = dGrid.Columns[colCount];
string strValue = "";
Binding objBinding = null;
if (col is DataGridBoundColumn)
{
objBinding = (col as DataGridBoundColumn).Binding;
}
if (col is DataGridTemplateColumn)
{
//This is a template column... let us see the underlying dependency object
DependencyObject objDO = (col as DataGridTemplateColumn).CellTemplate.LoadContent();
FrameworkElement oFE = (FrameworkElement)objDO;
FieldInfo oFI = oFE.GetType().GetField("TextProperty");
if (oFI != null)
{
var value = oFI.GetValue(null);
if (value != null)
{
var depProp = (DependencyProperty)value;
if (oFE.GetBindingExpression(depProp) != null)
{
objBinding = oFE.GetBindingExpression(depProp).ParentBinding;
}
}
}
}
if (objBinding != null)
{
if (objBinding.Path.Path != "")
{
PropertyInfo pi = data.GetType().GetProperty(objBinding.Path.Path);
if (pi != null)
{
strValue = pi.GetValue(data, null).ToString();
}
}
if (objBinding.Converter != null)
{
if (strValue != "")
{
strValue =
objBinding.Converter.Convert(strValue, typeof(string), objBinding.ConverterParameter,
objBinding.ConverterCulture).ToString();
}
}
}
// In mergeCellsList for each element, 0 has row num, 1 has column num, and 4 has number of cells to merge with this cell
var merge =
mergeCellsList.FirstOrDefault(
p => Convert.ToInt32(p[0]) == rowCount && Convert.ToInt32(p[1]) == colCount);
var bold = (rowCount < boldHeaderRows); //only header rows need to be bold
lstFields.Add(FormatField(strValue, strFormat, bold, merge == null ? null : merge[2]));
if (merge != null)
{
colCount += Convert.ToInt32(merge[2]); //don't process the merged cells
}
}
BuildStringOfRow(strBuilder, lstFields, strFormat);
rowCount++;
}
StreamWriter sw = new StreamWriter(outputStream);
if (strFormat == "XML" || strFormat == "XLSX")
{
//Let us write the headers for the Excel XML
WriteExcelHeader(sw, author, companyName);
}
sw.Write(strBuilder.ToString());
if (strFormat == "XML" || strFormat == "XLSX")
{
CloseTags(sw);
}
sw.Close();
}
/// <summary>
/// Scrolls the <see cref="FeatureDataGrid"/> vertically to display the row
/// for the specified <see cref="Graphic"/> and scrolls the <see cref="FeatureDataGrid"/>
/// horizontally to display the specified column.
/// </summary>
/// <param name="graphic">The graphic.</param>
/// <param name="column">The column.</param>
public void ScrollIntoView(Graphic graphic, DataGridColumn column)
{
#if SILVERLIGHT
int idx = GetGraphicIndexInGraphicsCollection(graphic);
if (idx > -1)
{
if (GraphicsLayer != null && Graphics != null && Graphics.Contains(graphic))
ScrollIntoView((ItemsSource as ICollectionView).SourceCollection.AsList()[idx], column);
}
#else
int idx = (_collection != null) ? _collection.IndexOf(graphic) : -1;
if (idx > -1)
base.ScrollIntoView(graphic, column);
#endif
}
private void AutoCheckUncheck(eAutoCheckArea area, bool checkValue)
{
try
{
switch (area)
{
case eAutoCheckArea.Table:
if (mDependsDT != null)
{
foreach (DataRow row in mDependsDT.Rows)
{
for (int i = 2; i < mDependsDT.Columns.Count; i++)
{
row[i] = checkValue;
}
}
}
break;
case eAutoCheckArea.Column:
DataGridColumn selectedCol = grdDependencies.grdMain.CurrentColumn;
if (selectedCol != null)
{
if (selectedCol.DisplayIndex > 1)
{
foreach (DataRow row in mDependsDT.Rows)
{
row[selectedCol.DisplayIndex] = checkValue;
}
}
else
{
Reporter.ToUser(eUserMsgKeys.SelectValidColumn);
}
}
else
{
Reporter.ToUser(eUserMsgKeys.SelectValidColumn);
}
break;
case eAutoCheckArea.Row:
if (grdDependencies.grdMain.CurrentItem != null)
{
DataRowView selectedRow = ((DataRowView)grdDependencies.grdMain.CurrentItem);
for (int i = 2; i < grdDependencies.grdMain.Columns.Count; i++)
{
selectedRow.Row[i] = checkValue;
}
}
else
{
Reporter.ToUser(eUserMsgKeys.SelectValidRow);
}
break;
}
//update helper details
SetDependenciesHelper();
}
catch (Exception ex)
{
Reporter.ToLog(eAppReporterLogLevel.ERROR, "Failed to do Auto check in 'VariablesDependenciesPage' grid", ex);
}
}
/// <summary>
/// Adds a column to a grid
/// </summary>
/// <param name="grid">Grid to add the column to</param>
/// <param name="totalColumnWidth"></param>
/// <param name="columnIndex">Index of the column</param>
/// <param name="column">Source column defintition which will be used to calculate the width of the column</param>
private void AddTableColumn(Grid grid, double totalColumnWidth, int columnIndex, DataGridColumn column)
{
//double proportion = column.Width.Value / (this.PageSize.Width - (this.PageMargin.Left + this.PageMargin.Right));
double proportion = column.ActualWidth / (this.PageSize.Width - (this.PageMargin.Left + this.PageMargin.Right));
ColumnDefinition colDefinition = new ColumnDefinition();
colDefinition.Width = new GridLength(proportion, GridUnitType.Star);
grid.ColumnDefinitions.Add(colDefinition);
TextBlock text = new TextBlock();
text.Style = this.TableHeaderTextStyle;
text.TextTrimming = TextTrimming.CharacterEllipsis;
text.Text = column.Header.ToString();;
text.SetValue(Grid.ColumnProperty, columnIndex);
grid.Children.Add(text);
_tableColumnDefinitions.Add(colDefinition);
}
private void RebuildDataGridColumns(IFieldMapperGridViewModel fmgvm, DataGrid dataGrid, PropertyDescriptor pd, FieldMapperGridControl host, bool updateFromInternalData = false)
{
int idx = 0;
dataGrid.Columns.Clear();
foreach (var column in fmgvm.Columns)
{
DataGridColumn dataGridColumn = null;
if (host.ItemTemplates.ContainsKey(column.Column))
{
dataGridColumn = new DataGridTemplateColumn()
{
CellTemplate = host.ItemTemplates[column.Column]
};
dataGridColumn.SortMemberPath = column.Column;
}
else if (host.ItemTemplates.ContainsKey(String.Empty))
{
dataGridColumn = new DataGridTemplateColumn()
{
CellTemplate = host.ItemTemplates[String.Empty]
};
dataGridColumn.SortMemberPath = column.Column;
}
else if (host.ItemTemplates.ContainsKey("Type:" + column.Type.FullName))
{
dataGridColumn = new CustomBoundColumn()
{
ContentTemplate = host.ItemTemplates["Type:" + column.Type.FullName], Binding = new Binding("Item[" + column.Column + "]")
};
dataGridColumn.SortMemberPath = column.Column;
}
else
{
dataGridColumn = new DataGridTextColumn()
{
Binding = new Binding("Item[" + column.Column + "]")
};
if (column.Type == typeof(DateTime))
{
(dataGridColumn as DataGridTextColumn).Binding.StringFormat = CultureInfo.CurrentCulture.DateTimeFormat.ShortDatePattern + " " + CultureInfo.CurrentCulture.DateTimeFormat.LongTimePattern;
}
dataGridColumn.SortMemberPath = column.Column;
}
dataGridColumn.Header = column.Header;
dataGridColumn.Visibility = column.Visible ? Visibility.Visible : Visibility.Collapsed;
dataGridColumn.Width = new DataGridLength(column.Width);
pd.AddValueChanged(dataGridColumn, (ox, ax) =>
{
column.SuppressNotifications();
column.Width = dataGridColumn.Width.IsAuto ? dataGridColumn.Width.DisplayValue : dataGridColumn.Width.Value;
column.AllowNotifications();
});
column.PropertyChanged += (ox, ax) =>
{
if (ax.PropertyName == "Visible")
{
if (column.Visible == false)
{
BackgroundTaskManager.DelayedPostIfPossible(() => { RebuildDataGridColumns(fmgvm, dataGrid, pd, host, false); return(true); });
}
}
if (ax.PropertyName == "Width")
{
dataGridColumn.Width = new DataGridLength(column.Width);
}
};
BindingOperations.SetBinding(dataGridColumn, DataGridTemplateColumn.WidthProperty, new Binding()
{
Source = column.Width
});
dataGrid.Columns.Add(dataGridColumn);
++idx;
}
dataGrid.ColumnDisplayIndexChanged += (o, a) => OnSettingsChanged(dataGrid, fmgvm);
dataGrid.ColumnReordered += (o, a) => OnSettingsChanged(dataGrid, fmgvm);
dataGrid.Sorting += (o, a) => OnSettingsChanged(dataGrid, fmgvm);
dataGrid.Items.SortDescriptions.Clear();
foreach (var column in fmgvm.Columns)
{
var dataGridColumn = dataGrid.Columns.Where(item => item.SortMemberPath == column.Header).FirstOrDefault();
if (dataGridColumn == null)
{
continue;
}
var fromInternalData = column.InternalProperties as PrivateFieldData?;
if (fromInternalData != null)
{
try
{
dataGridColumn.SortDirection = fromInternalData.Value.SortDirection;
if (dataGridColumn.SortDirection.HasValue)
{
dataGrid.Items.SortDescriptions.Add(new SortDescription(dataGridColumn.SortMemberPath, dataGridColumn.SortDirection.Value));
}
if (updateFromInternalData)
{
dataGridColumn.Visibility = fromInternalData.Value.Visibility;
}
}
catch (Exception)
{
}
}
}
}
public static CultureKey GetCultureKey([NotNull] this DataGridColumn column)
{
Contract.Requires(column != null);
return((column.Header as ILanguageColumnHeader)?.CultureKey);
}
private bool ShouldDisplayCell(DataGridColumn column, double frozenLeftEdge, double scrollingLeftEdge)
{
Debug.Assert(this.OwningGrid != null);
if (column.Visibility != Visibility.Visible)
{
return false;
}
double leftEdge = column.IsFrozen ? frozenLeftEdge : scrollingLeftEdge;
double rightEdge = leftEdge + column.ActualWidth;
return DoubleUtil.GreaterThan(rightEdge, 0) &&
DoubleUtil.LessThanOrClose(leftEdge, this.OwningGrid.CellsWidth) &&
DoubleUtil.GreaterThan(rightEdge, frozenLeftEdge); // scrolling column covered up by frozen column(s)
}
/// <summary>
/// Arranges the content of the <see cref="T:Avalonia.Controls.Primitives.DataGridColumnHeadersPresenter" />.
/// </summary>
/// <returns>
/// The actual size used by the <see cref="T:Avalonia.Controls.Primitives.DataGridColumnHeadersPresenter" />.
/// </returns>
/// <param name="finalSize">
/// The final area within the parent that this element should use to arrange itself and its children.
/// </param>
protected override Size ArrangeOverride(Size finalSize)
{
if (OwningGrid == null)
{
return(base.ArrangeOverride(finalSize));
}
if (OwningGrid.AutoSizingColumns)
{
// When we initially load an auto-column, we have to wait for all the rows to be measured
// before we know its final desired size. We need to trigger a new round of measures now
// that the final sizes have been calculated.
OwningGrid.AutoSizingColumns = false;
return(base.ArrangeOverride(finalSize));
}
double dragIndicatorLeftEdge = 0;
double frozenLeftEdge = 0;
double scrollingLeftEdge = -OwningGrid.HorizontalOffset;
foreach (DataGridColumn dataGridColumn in OwningGrid.ColumnsInternal.GetVisibleColumns())
{
DataGridColumnHeader columnHeader = dataGridColumn.HeaderCell;
Debug.Assert(columnHeader.OwningColumn == dataGridColumn);
if (dataGridColumn.IsFrozen)
{
columnHeader.Arrange(new Rect(frozenLeftEdge, 0, dataGridColumn.LayoutRoundedWidth, finalSize.Height));
columnHeader.Clip = null; // The layout system could have clipped this becaues it's not aware of our render transform
if (DragColumn == dataGridColumn && DragIndicator != null)
{
dragIndicatorLeftEdge = frozenLeftEdge + DragIndicatorOffset;
}
frozenLeftEdge += dataGridColumn.ActualWidth;
}
else
{
columnHeader.Arrange(new Rect(scrollingLeftEdge, 0, dataGridColumn.LayoutRoundedWidth, finalSize.Height));
EnsureColumnHeaderClip(columnHeader, dataGridColumn.ActualWidth, finalSize.Height, frozenLeftEdge, scrollingLeftEdge);
if (DragColumn == dataGridColumn && DragIndicator != null)
{
dragIndicatorLeftEdge = scrollingLeftEdge + DragIndicatorOffset;
}
}
scrollingLeftEdge += dataGridColumn.ActualWidth;
}
if (DragColumn != null)
{
if (DragIndicator != null)
{
EnsureColumnReorderingClip(DragIndicator, finalSize.Height, frozenLeftEdge, dragIndicatorLeftEdge);
var height = DragIndicator.Bounds.Height;
if (height <= 0)
{
height = DragIndicator.DesiredSize.Height;
}
DragIndicator.Arrange(new Rect(dragIndicatorLeftEdge, 0, DragIndicator.Bounds.Width, height));
}
if (DropLocationIndicator != null)
{
if (DropLocationIndicator is Control element)
{
EnsureColumnReorderingClip(element, finalSize.Height, frozenLeftEdge, DropLocationIndicatorOffset);
}
DropLocationIndicator.Arrange(new Rect(DropLocationIndicatorOffset, 0, DropLocationIndicator.Bounds.Width, DropLocationIndicator.Bounds.Height));
}
}
// Arrange filler
OwningGrid.OnFillerColumnWidthNeeded(finalSize.Width);
DataGridFillerColumn fillerColumn = OwningGrid.ColumnsInternal.FillerColumn;
if (fillerColumn.FillerWidth > 0)
{
fillerColumn.HeaderCell.IsVisible = true;
fillerColumn.HeaderCell.Arrange(new Rect(scrollingLeftEdge, 0, fillerColumn.FillerWidth, finalSize.Height));
}
else
{
fillerColumn.HeaderCell.IsVisible = false;
}
// This needs to be updated after the filler column is configured
DataGridColumn lastVisibleColumn = OwningGrid.ColumnsInternal.LastVisibleColumn;
if (lastVisibleColumn != null)
{
lastVisibleColumn.HeaderCell.UpdateSeparatorVisibility(lastVisibleColumn);
}
return(finalSize);
}
private static DataGridColumnHeader GetColumnHeaderFromColumn(DataGrid dataGrid, DataGridColumn column)
{
if (dataGrid == null || column == null)
{
return(null);
}
DataGridColumnHeader[] columnHeaders = GetColumnHeaders(dataGrid);
return((from DataGridColumnHeader columnHeader in columnHeaders
where columnHeader.Column == column
select columnHeader).FirstOrDefault());
}
/// <summary>
/// Called due to the cell's column definition changing.
/// Not called due to changes within the current column definition.
/// </summary>
/// <remarks>
/// Coerces ContentTemplate and ContentTemplateSelector.
/// </remarks>
/// <param name="oldColumn">The old column definition.</param>
/// <param name="newColumn">The new column definition.</param>
protected virtual void OnColumnChanged(DataGridColumn oldColumn, DataGridColumn newColumn)
{
// We need to call BuildVisualTree after changing the column (PrepareCell does this).
Content = null;
DataGridHelper.TransferProperty(this, StyleProperty);
DataGridHelper.TransferProperty(this, IsReadOnlyProperty);
}
internal DataGridCellItemAutomationPeer GetOrCreateCellItemPeer(DataGridColumn column)
{
DataGridCellItemAutomationPeer peer = null;
bool peerExists = _itemPeers.TryGetValue(column, out peer);
if (!peerExists || peer == null)
{
peer = new DataGridCellItemAutomationPeer(_item, column);
_itemPeers.Add(column, peer);
}
return peer;
}
public void TestInit() {
_column = new DataGridColumn();
}
private void mSort(DataGridColumn column)
{
if (column != null)
{
switch (column.DisplayIndex)
{
case 0:
switch (column.SortDirection)
{
case ListSortDirection.Ascending:
preDG_Html.OrderBy(x => x.Rank)
.ToList()
.ForEach(x => DG_Html.Items.Add(x));
preDG_Css.OrderBy(x => x.Rank)
.ToList()
.ForEach(x => DG_Css.Items.Add(x));
preDG_Js.OrderBy(x => x.Rank)
.ToList()
.ForEach(x => DG_Js.Items.Add(x));
preDG_Xml.OrderBy(x => x.Rank)
.ToList()
.ForEach(x => DG_Xml.Items.Add(x));
break;
case ListSortDirection.Descending:
preDG_Html.OrderByDescending(x => x.Rank)
.ToList()
.ForEach(x => DG_Html.Items.Add(x));
preDG_Css.OrderByDescending(x => x.Rank)
.ToList()
.ForEach(x => DG_Css.Items.Add(x));
preDG_Js.OrderByDescending(x => x.Rank)
.ToList()
.ForEach(x => DG_Js.Items.Add(x));
preDG_Xml.OrderByDescending(x => x.Rank)
.ToList()
.ForEach(x => DG_Xml.Items.Add(x));
break;
}
break;
case 1:
switch (column.SortDirection)
{
case ListSortDirection.Ascending:
preDG_Html.OrderBy(x => x.TestName)
.ToList()
.ForEach(x => DG_Html.Items.Add(x));
preDG_Css.OrderBy(x => x.TestName)
.ToList()
.ForEach(x => DG_Css.Items.Add(x));
preDG_Js.OrderBy(x => x.TestName)
.ToList()
.ForEach(x => DG_Js.Items.Add(x));
preDG_Xml.OrderBy(x => x.TestName)
.ToList()
.ForEach(x => DG_Xml.Items.Add(x));
break;
case ListSortDirection.Descending:
preDG_Html.OrderByDescending(x => x.TestName)
.ToList()
.ForEach(x => DG_Html.Items.Add(x));
preDG_Css.OrderByDescending(x => x.TestName)
.ToList()
.ForEach(x => DG_Css.Items.Add(x));
preDG_Js.OrderByDescending(x => x.TestName)
.ToList()
.ForEach(x => DG_Js.Items.Add(x));
preDG_Xml.OrderByDescending(x => x.TestName)
.ToList()
.ForEach(x => DG_Xml.Items.Add(x));
break;
}
break;
}
}
else
{
preDG_Html.ForEach(x => DG_Html.Items.Add(x));
preDG_Css.ForEach(x => DG_Css.Items.Add(x));
preDG_Js.ForEach(x => DG_Js.Items.Add(x));
preDG_Xml.ForEach(x => DG_Xml.Items.Add(x));
}
}
private void ScrollColumnIntoView(DataGridColumn column)
{
if (_rowTrackingRoot != null)
{
DataGridRow row = _rowTrackingRoot.Container;
if (row != null)
{
int columnIndex = _columns.IndexOf(column);
row.ScrollCellIntoView(columnIndex);
}
}
}
private void clients_status_columns_list_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
ListBox list = sender as ListBox;
foreach (ListBoxItem item in list.Items)
{
DataGridColumn column = null;
switch (item.DataContext.ToString())
{
case "owner":
column = clients_status_data_grid_owner_column;
break;
case "person1_id":
column = clients_status_data_grid_person_1_id_column;
break;
case "person1_name":
column = clients_status_data_grid_person_1_name_column;
break;
case "person2_id":
column = clients_status_data_grid_person_2_id_column;
break;
case "person2_name":
column = clients_status_data_grid_person_2_name_column;
break;
case "case_type":
column = clients_status_data_grid_case_type_column;
break;
case "court_name":
column = clients_status_data_grid_court_name_column;
break;
case "case_num":
column = clients_status_data_grid_case_num_column;
break;
case "work_essence":
column = clients_status_data_grid_work_essence_column;
break;
case "case_recievment_date":
column = clients_status_data_grid_case_receivement_date_column;
break;
case "creation_date":
column = clients_status_data_grid_creation_date_column;
break;
case "case_decision_date":
column = clients_status_data_grid_case_decision_date_column;
break;
case "total_price":
column = clients_status_data_grid_case_total_price_column;
break;
case "advanced_price":
column = clients_status_data_grid_case_advanced_price_column;
break;
case "case_status":
column = clients_status_cell;
break;
}
if (column != null)
{
column.Visibility = item.IsSelected ? Visibility.Visible : Visibility.Collapsed;
}
}
}
/// <summary>
/// Throws an ArgumentOutOfRangeException if the given displayIndex is invalid.
/// </summary>
internal void ValidateDisplayIndex(DataGridColumn column, int displayIndex)
{
InternalColumns.ValidateDisplayIndex(column, displayIndex);
}
public static CultureKey GetCultureKey([NotNull] this DataGridColumn column)
{
return((column.Header as ILanguageColumnHeader)?.CultureKey);
}
internal DataGridCell TryFindCell(object item, DataGridColumn column)
{
// Does not de-virtualize cells
DataGridRow row = (DataGridRow)ItemContainerGenerator.ContainerFromItem(item);
int columnIndex = _columns.IndexOf(column);
if ((row != null) && (columnIndex >= 0))
{
return row.TryGetCell(columnIndex);
}
return null;
}
public static CultureInfo GetCulture([NotNull] this DataGridColumn column)
{
return(column.GetCultureKey()?.Culture);
}
/// <summary>
/// Clears the sort directions for all the columns except the column to be sorted upon
/// </summary>
/// <param name="sortColumn"></param>
private void PrepareForSort(DataGridColumn sortColumn)
{
if ((Keyboard.Modifiers & ModifierKeys.Shift) == ModifierKeys.Shift)
{
return;
}
if (Columns != null)
{
foreach (DataGridColumn column in Columns)
{
if (column != sortColumn)
{
column.SortDirection = null;
}
}
}
}
private void dg_sorting(object sender, DataGridColumnEventArgs e)
{
if (e.Column.Tag.ToString() == null)
{
return;
}
// 直前に選ばれていたcollumが別ならアイコンを消しておく
if (c != e.Column && c != null)
{
c.SortDirection = null;
}
if (e.Column.SortDirection == null || e.Column.SortDirection == DataGridSortDirection.Ascending)
{
// 選択collumが未選択・昇順状態であれば、降順にする
e.Column.SortDirection = DataGridSortDirection.Descending;
//選択Collumによって分岐
if (e.Column.Tag.ToString() == "Date")
{
dataGrid.ItemsSource = new ObservableCollection <PaymentLog>(from i in Logs orderby i._date descending select i);
}
else if (e.Column.Tag.ToString() == "Type")
{
dataGrid.ItemsSource = new ObservableCollection <PaymentLog>(from i in Logs orderby i._type descending select i);
}
else if (e.Column.Tag.ToString() == "User")
{
dataGrid.ItemsSource = new ObservableCollection <PaymentLog>(from i in Logs orderby i._user_name descending select i);
}
else if (e.Column.Tag.ToString() == "Item")
{
dataGrid.ItemsSource = new ObservableCollection <PaymentLog>(from i in Logs orderby i._itemName descending select i);
}
else if (e.Column.Tag.ToString() == "Num")
{
dataGrid.ItemsSource = new ObservableCollection <PaymentLog>(from i in Logs orderby i._num descending select i);
}
else if (e.Column.Tag.ToString() == "Price")
{
dataGrid.ItemsSource = new ObservableCollection <PaymentLog>(from i in Logs orderby i._price descending select i);
}
else if (e.Column.Tag.ToString() == "Total")
{
dataGrid.ItemsSource = new ObservableCollection <PaymentLog>(from i in Logs orderby i._total_price descending select i);
}
}
else
{
// 選択collumが降順状態であれば、昇順にする
e.Column.SortDirection = DataGridSortDirection.Ascending;
// 選択collumによって分岐
if (e.Column.Tag.ToString() == "Date")
{
dataGrid.ItemsSource = new ObservableCollection <PaymentLog>(from i in Logs orderby i._date ascending select i);
}
else if (e.Column.Tag.ToString() == "Type")
{
dataGrid.ItemsSource = new ObservableCollection <PaymentLog>(from i in Logs orderby i._type ascending select i);
}
else if (e.Column.Tag.ToString() == "User")
{
dataGrid.ItemsSource = new ObservableCollection <PaymentLog>(from i in Logs orderby i._user_name ascending select i);
}
else if (e.Column.Tag.ToString() == "Item")
{
dataGrid.ItemsSource = new ObservableCollection <PaymentLog>(from i in Logs orderby i._itemName ascending select i);
}
else if (e.Column.Tag.ToString() == "Num")
{
dataGrid.ItemsSource = new ObservableCollection <PaymentLog>(from i in Logs orderby i._num ascending select i);
}
else if (e.Column.Tag.ToString() == "Price")
{
dataGrid.ItemsSource = new ObservableCollection <PaymentLog>(from i in Logs orderby i._price ascending select i);
}
else if (e.Column.Tag.ToString() == "Total")
{
dataGrid.ItemsSource = new ObservableCollection <PaymentLog>(from i in Logs orderby i._total_price ascending select i);
}
}
// 現在選ばれていたcollumの保持
c = e.Column;
}
/// <summary>
/// Helper method which estimates the width of the column
/// </summary>
private static double GetColumnEstimatedMeasureWidth(DataGridColumn column, double averageColumnWidth)
{
if (!column.IsVisible)
{
return 0.0;
}
double childMeasureWidth = column.Width.DisplayValue;
if (DoubleUtil.IsNaN(childMeasureWidth))
{
childMeasureWidth = Math.Max(averageColumnWidth, column.MinWidth);
childMeasureWidth = Math.Min(childMeasureWidth, column.MaxWidth);
}
return childMeasureWidth;
}
public static SizeRelatedCondition <TParent, bool> Add <TParent>(this SizeRelatedCondition <TParent, bool> condition,
DataGridColumn child) where TParent : FrameworkElement
{
return(condition.Add(b => child.Visibility = b ? Visibility.Visible : Visibility.Collapsed));
}
/// <summary>
/// Helper method which generates and measures a
/// child of given index
/// </summary>
private UIElement GenerateChild(
IItemContainerGenerator generator,
Size constraint,
DataGridColumn column,
ref int childIndex,
out Size childSize)
{
bool newlyRealized;
UIElement child = generator.GenerateNext(out newlyRealized) as UIElement;
if (child == null)
{
childSize = new Size();
return null;
}
AddContainerFromGenerator(childIndex, child, newlyRealized);
childIndex++;
MeasureChild(child, constraint);
DataGridLength width = column.Width;
childSize = child.DesiredSize;
if (!DoubleUtil.IsNaN(width.DisplayValue))
{
childSize = new Size(width.DisplayValue, childSize.Height);
}
return child;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="dataGridColumn"></param>
public DataGridColumnReorderingEventArgs(DataGridColumn dataGridColumn)
: base(dataGridColumn)
{
}
protected override DataGrid ReadRawData(DataGridColumns columns)
{
if (columns == null) throw new ArgumentNullException("columns");
Framework.Excel.Interop.Excel excel = null;
ExcelInterop.Worksheet worksheet = null;
try
{
Log.Info(String.Format("Reading data from Excel File '{0}'...", Settings.FilePath));
excel = Framework.Excel.Interop.Excel.Open(Settings.FilePath, Settings.Password);
worksheet = !Settings.Worksheet.IsNullOrBlank() ? excel.Worksheet(Settings.Worksheet) : excel.Worksheet(0);
ExcelInterop.Range range = worksheet.UsedRange;
object[,] cells = range.Value2;
DataGrid dataGrid = new DataGrid();
/*
* Headers
*/
var allColumns = columns.Expand();
int columnCount = range.Columns.Count;
for (int colIndex = 1; colIndex <= columnCount; colIndex++)
{
string columnName = Convert.ToString(cells[1, colIndex]);
if (columnName.IsNullOrBlank() || (columns.Any() && !allColumns.Any(c => c.ColumnName.Equals(columnName))))
{ continue; }
DataGridColumn column = new DataGridColumn(columnName) { OriginalSourceIndex = colIndex };
dataGrid.Columns.Add(column);
}
/*
* Data
*/
int rowCount;
if (Settings.RowCount > 0)
{
rowCount = (Settings.RowCount + 1 <= range.Rows.Count) ? Settings.RowCount + 1 : range.Rows.Count;
}
else if (Settings.RowCount < 0)
{
rowCount = range.Rows.Count + Settings.RowCount;
}
else
{
rowCount = range.Rows.Count;
}
for (int rowIndex = 2; rowIndex <= rowCount; rowIndex++)
{
DataGridRow dataGridRow = dataGrid.Rows.New();
foreach (DataGridColumn column in dataGrid.Columns)
{
try
{
DataGridCell cell = dataGridRow.Cells.New();
cell.OriginalValue = cells[rowIndex, column.OriginalSourceIndex];
}
catch (Exception exception)
{
throw new Exception(String.Format("An error occurred while reading cell at Row '{0}', Column '{1}'."
, rowIndex
, column.OriginalSourceIndex)
, exception);
}
}
}
return dataGrid;
}
catch (ExcelInteropException e)
{
throw e;
}
catch (Exception e)
{
throw new ExcelInteropException(String.Format("An error occurred while Reading data from Excel file '{0}'.", Settings.FilePath), e);
}
finally
{
// Worksheet
if (worksheet != null)
{
Marshal.FinalReleaseComObject(worksheet);
}
// Excel
if (excel != null)
{ excel.Dispose(); }
}
}
protected override bool HasCellPresenter(DataGridColumn column)
{
return false;
}
public DataGridColumnReorderingEventArgs(DataGridColumn dataGridColumn)
{
this.Column = dataGridColumn;
}
public static IComparer GetSorter(DataGridColumn column)
{
return((IComparer)column.GetValue(SorterProperty));
}
// This method is called from DataGrid.OnBeginningEdit/OnCommittingEdit/OnCancelingEdit
// Raises Invoked event when cell begin/cancel/commit edit
internal void RaiseAutomationCellInvokeEvents(DataGridColumn column, DataGridRow row)
{
DataGridItemAutomationPeer dataGridItemAutomationPeer = GetOrCreateItemPeer(row.Item);
if (dataGridItemAutomationPeer != null)
{
DataGridCellItemAutomationPeer cellPeer = dataGridItemAutomationPeer.GetOrCreateCellItemPeer(column);
if (cellPeer != null)
{
cellPeer.RaiseAutomationEvent(AutomationEvents.InvokePatternOnInvoked);
}
}
}
public static IEnumerable <T> GetAutoFilterValues <T>(IEnumerable <T> source, DataGridColumn column)
{
var grid = column.DataGrid;
// get all filter states without taking the current column into account
var filterStates = grid.FilteredColumns
.Where(c => c != column)
.Select(c => new DataGridColumnValue <DataGridFilterState>(c, c.FilterState));
var filter = C1DataGridFilterHelper.BuildFilterPredicate <T>(filterStates.ToArray(), DataGridFilterCombination.And);
if (filter == null)
{
return(source);
}
var filteredElements = new List <T>();
foreach (var elem in source)
{
if (filter(elem))
{
filteredElements.Add(elem);
}
}
return(filteredElements);
}
private void setStyle(DataGridColumn c, ListItemType tp)
{
}
public static void SetSorter(DataGridColumn column, IComparer value)
{
column.SetValue(SorterProperty, value);
}
